Fixed-Point Arithmetic Library

Fast, integer-only fixed-point arithmetic. All operations use pure integer math—no floating-point overhead.

What is Fixed-Point? (5-Minute Intro)

Fixed-point numbers store decimals using only integers. Think of it like storing money in cents instead of dollars:

$1.50 → store as 150 cents, then divide by 100 when needed
1.50 in fixed-point → store as a scaled integer, then divide by scale factor

Example: How Fixed-Point Works

Float: 2.5 (may be imprecise internally)
Fixed-Point s16x16: 2.5 stored as 163,840 (= 2.5 × 65,536)
           └─ 65,536 is 2^16 (the "scale factor")

Operations use only integers:
  163,840 + 65,536 = 229,376  → convert back to 3.5
  163,840 × 2      = 327,680  → convert back to 5.0

Why use it?

✅ Fast: Integer math is 5-100x faster than floating-point on embedded systems
✅ Predictable: No rounding errors; results are exact and reproducible
✅ Small: 2-4 bytes per value (vs 4-8 bytes for floats)
❌ Trade-off: Limited range and precision (you choose the split)

Float vs Fixed-Point (Quick Comparison)

Aspect	Float	Fixed-Point
Speed	Slow (50-100x) — no FPU on embedded	⭐ Fast (native integer)
Precision	✅ Auto-adjusts per value	Must choose in advance
Range	Large	You pick (via template)
Rounding errors	May accumulate in loops	❌ None — results exact
Size	4 bytes (float), 8 bytes (double)	2-4 bytes (your choice)
Setup	Just use `float`	Pick template parameters

→ Use fixed-point for FastLED because embedded systems have NO hardware float support.

The Two Main APIs: `sfixed_integer` and `ufixed_integer`

FastLED provides two templated types that are the primary entry point:

Signed Fixed-Point Integer

cpp

#include "fl/stl/fixed_point.h"

// sfixed_integer<IntBits, FracBits>
// Stores signed values (can be negative)

fl::sfixed_integer<16, 16> angle(3.14159f);  // ±32k range, 1/65k precision
fl::sfixed_integer<8, 24> smooth(0.5f);      // ±128 range, 1/16M precision
fl::sfixed_integer<24, 8> large(100000.5f);  // ±8M range, 1/256 precision

Unsigned Fixed-Point Integer

cpp

// ufixed_integer<IntBits, FracBits>
// Stores unsigned values (0 and positive only)

fl::ufixed_integer<8, 8> brightness(200.0f);  // 0-256 range, 1/256 precision
fl::ufixed_integer<16, 16> ratio(0.75f);      // 0-65k range, 1/65k precision

Template parameters explained:

Parameter	What It Controls	Example
IntBits	How many bits for numbers before decimal point	`sfixed_integer<16, 16>`: stores up to ±32,768
FracBits	How many bits for precision after decimal point	`sfixed_integer<16, 16>`: precision of 1/65,536

The Formula:

Range (signed) = [-2^IntBits, 2^IntBits) (e.g., 16 bits → ±65,536)
Range (unsigned) = [0, 2^IntBits) (e.g., 8 bits → 0 to 256)
Precision = 1/2^FracBits (e.g., 16 bits → 0.0000153 steps)
Total storage = (IntBits + FracBits) rounded up to 8, 16, 32, or 64 bits

Quick Examples (Start Here)

Example 1: Fade LED Brightness

cpp

#include "fl/stl/fixed_point.h"

// u8x8 = unsigned, 8-bit integer, 8-bit fraction
// Range: [0, 256), Precision: 1/256
fl::ufixed_integer<8, 8> brightness(200.0f);  // Start at 200

// Multiply brightness by 0.5 (50% fade)
// All math stays in fixed-point (no slow floats!)
fl::ufixed_integer<8, 8> half = fl::ufixed_integer<8, 8>(0.5f);
fl::ufixed_integer<8, 8> faded = brightness * half;

uint8_t output = faded.to_int();  // Convert back to int: 100
// ✅ Result: 200 × 0.5 = 100 (fast integer-only math)

Example 2: Smooth Animation

cpp

// Animate from 0 to 1 with easing
fl::sfixed_integer<16, 16> t(0.3f);  // Time: 0.0 to 1.0

// Smooth step (hermite interpolation)
auto eased = fl::smoothstep(
    fl::sfixed_integer<16, 16>(0.0f),
    fl::sfixed_integer<16, 16>(1.0f),
    t);

uint8_t hue = (eased * 255.0f).to_int();

Example 3: Rotate a Point

cpp

struct Point {
    fl::sfixed_integer<16, 16> x, y;
};

Point rotate(const Point& p, fl::sfixed_integer<16, 16> angle) {
    fl::sfixed_integer<16, 16> sin_a, cos_a;
    fl::sincos(angle, sin_a, cos_a);

    return {
        p.x * cos_a - p.y * sin_a,
        p.x * sin_a + p.y * cos_a
    };
}

Example 4: Perlin Noise (Animartrix)

cpp

// Used in 2D effects
fl::sfixed_integer<16, 16> x(0.5f);
fl::sfixed_integer<16, 16> y(0.5f);

// Noise returns [-1, 1]
auto pattern = perlin_s16x16::pnoise2d(x, y, ...);

uint8_t led = ((pattern + 1.0f) * 128.0f).to_int();

Understanding Range vs Precision (Key Concept)

Fixed-point forces a trade-off: You have a fixed number of bits (typically 32 or 64). You split them between integer and fractional parts. More bits for integers = larger range but coarser precision.

Visual example (32-bit fixed-point):

s16x16 (16 bits integer, 16 bits fraction)
  ├─ Range: ±32,767
  └─ Precision: 1/65,536 ≈ 0.0000153

s8x24 (8 bits integer, 24 bits fraction)
  ├─ Range: ±127
  └─ Precision: 1/16,777,216 ≈ 0.000000059

s24x8 (24 bits integer, 8 bits fraction)
  ├─ Range: ±8,388,607
  └─ Precision: 1/256 ≈ 0.0039

When to choose each:

Need values > 1000? → Use more IntBits (s24x8)
Need precision < 0.001? → Use more FracBits (s8x24)
Middle ground? → Stick with s16x16 — best for most use cases

Rarely need to think about this — s16x16 handles angles, brightness, coordinates, and most animation parameters just fine.

Creating and Converting Values

From Floats (Most Common)

cpp

// Initialize from float — compiler does the scaling automatically
fl::sfixed_integer<16, 16> angle(3.14159f);      // 3.14159
fl::ufixed_integer<8, 8> brightness(200.0f);     // 200.0
fl::sfixed_integer<8, 24> precise(0.1f);         // 0.1 (high precision)

Converting Back

cpp

auto value = fl::sfixed_integer<16, 16>(1.5f);

float f = value.to_float();       // → 1.5f (exact)
int i = value.to_int();           // → 1 (truncated, loses 0.5)
auto raw = value.raw();           // → 98304 (internal scaled integer)
                                  //   (1.5 × 65536)

From Raw Values (Advanced/Rare)

cpp

// If you need to pack/unpack binary data:
auto value = fl::sfixed_integer<16, 16>::from_raw(0x10000);  // 1.0
// 0x10000 (65,536) = 1.0 in s16x16 because 2^16 is the scale

Auto-Promotion (Smaller → Larger, Automatic)

cpp

fl::ufixed_integer<8, 8> small(1.5f);       // 8+8 = 16 bits
fl::ufixed_integer<16, 16> large = small;   // ✅ Auto-promotes!
// Compiler shifts bits to expand range and precision

// Promotion rules (must ALL be true):
// ✅ u8x8 → u16x16  (more int bits + more frac bits)
// ✅ s8x24 → s16x16 (more int bits, same or fewer frac bits)
// ❌ u8x8 → s16x16  (sign mismatch: unsigned → signed)
// ❌ s16x16 → s8x24 (int bits shrink: 16 → 8)

Math API: Free-Function Style (Like std::cmath)

Rounding & Decomposition

cpp

auto x = fl::sfixed_integer<16, 16>(2.7f);

fl::floor(x);   // 2.0
fl::ceil(x);    // 3.0
fl::fract(x);   // 0.7
fl::abs(x);     // Absolute value

Interpolation & Clamping

cpp

auto a = fl::sfixed_integer<16, 16>(0.0f);
auto b = fl::sfixed_integer<16, 16>(10.0f);
auto t = fl::sfixed_integer<16, 16>(0.3f);

fl::lerp(a, b, t);           // Linear interpolation: 3.0
fl::clamp(fl::sfixed_integer<16, 16>(15.0f), a, b);  // → 10.0
fl::smoothstep(a, b, t);     // Smooth: 0→1
fl::step(a, t);              // Step function

Trigonometry (Ultra-Fast Lookup Tables)

cpp

auto angle = fl::sfixed_integer<16, 16>(1.5708f);  // π/2

// **Use sincos() instead of separate calls (30% faster)**
auto sin_val = fl::sfixed_integer<16, 16>(0.0f);
auto cos_val = fl::sfixed_integer<16, 16>(0.0f);
fl::sincos(angle, sin_val, cos_val);

// Individual functions
fl::sin(angle);      // ~1.0
fl::cos(angle);      // ~0.0
fl::atan(0.7f);
fl::atan2(1.0f, 0.7f);  // Angle from (x, y)
fl::asin(0.7f);
fl::acos(0.7f);

Roots & Powers

cpp

auto x = fl::sfixed_integer<16, 16>(4.0f);

fl::sqrt(x);         // ~2.0
fl::rsqrt(x);        // ~0.707 (1/√x)
fl::pow(fl::sfixed_integer<16, 16>(2.0f), x);  // 2^4 = 16.0

Arithmetic Operators

cpp

auto a = fl::sfixed_integer<16, 16>(2.0f);
auto b = fl::sfixed_integer<16, 16>(0.5f);

a + b;          // 2.5
a - b;          // 1.5
a * b;          // 1.0 (fixed-point multiply)
a / b;          // 4.0 (fixed-point divide)
-a;             // -2.0

// Fast power-of-2 operations
a >> 1;         // Divide by 2
a << 2;         // Multiply by 4

// Comparisons
a < b;
a == b;
a >= b;

Modulo

cpp

auto a = fl::sfixed_integer<16, 16>(7.5f);
auto b = fl::sfixed_integer<16, 16>(2.0f);

fl::mod(a, b);  // ≈ 1.5

Member Method API (Alternative)

You can also call methods directly on values (both styles work):

cpp

auto x = fl::sfixed_integer<16, 16>(2.7f);

x.floor();
x.ceil();
x.fract();
x.abs();
x.sqrt();
x.sin();
x.cos();

Use whichever is more natural for your code—free-function (fl::sin(x)) or member (x.sin()).

Choosing a Template Configuration

Decision tree (read top to bottom):

1. Is your value small (|x| < 128)?
   ├─ Need very high precision? → s8x24  (precision 1/16M, fits in 4 bytes)
   └─ Precision is OK? → s8x8 or u8x8   (precision 1/256, fits in 2 bytes)

2. Is your value medium (|x| < 32k)?  ⭐ MOST COMMON
   └─ → s16x16 or u16x16  (precision 1/65,536, fits in 4 bytes)

3. Is your value large (|x| < 8M)?
   └─ → s24x8  (precision 1/256, fits in 4 bytes)

4. Sign question: Can your value be negative?
   ├─ Yes → Use sfixed_integer (signed)
   └─ No  → Use ufixed_integer (unsigned, saves 1 bit range)

Quick lookup by use case:

Use Case	Type	Range	Precision	Storage
Brightness (0-255)	`u8x8`	0-256	1/256	2 bytes
Angles (0-2π radians)	`s16x16`	±32k	1/65k	4 bytes
Smooth fade (0.0-1.0)	`s16x16`	±32k	1/65k	4 bytes
High precision small (±1.0)	`s8x24`	±128	1/16M	4 bytes
Spatial coordinates	`s16x16`	±32k	1/65k	4 bytes
Large numbers (±1M)	`s24x8`	±8M	1/256	4 bytes

Convenience Type Aliases

If the full template syntax is too verbose, short aliases are available:

Alias	Expands To	Use Case
`s16x16`	`sfixed_integer<16, 16>`	General signed
`u8x8`	`ufixed_integer<8, 8>`	Brightness
`s8x24`	`sfixed_integer<8, 24>`	High precision, small range
`s24x8`	`sfixed_integer<24, 8>`	Large values, low precision

Full list: s0x32, s4x12, s8x8, s8x24, s12x4, s16x16, s24x8, u0x32, u4x12, u8x8, u8x24, u12x4, u16x16, u24x8

Performance Characteristics

On embedded systems (ARM Cortex-M), fixed-point is 5-100x faster:

Addition: 5-10x faster (native integer)
Multiplication: 10-50x faster (no FPU pipeline stalls)
sin/cos: 50-100x faster (lookup table vs approximation)
sqrt: 5-10x faster (integer algorithm)

Why? Embedded CPUs lack FPU, so floats use slow software emulation. Fixed-point uses native integer operations.

Memory: Highly efficient—s16x16 is 4 bytes, u8x8 is 2 bytes.

Common Pitfalls and Solutions

Problem	What Happens	Solution
Overflow	Value exceeds range (e.g., 50,000 in `s16x16` which maxes at ±32,767)	Use wider template: `s24x8` instead of `s16x16`
Division by zero	Undefined behavior / crash	Always check: `if (divisor != 0) { result = a / b; }`
Wrong precision	Result is too coarse (e.g., 0.004 steps instead of needed 0.001)	Choose FracBits carefully. `s16x16` gives 0.0000153 precision; `s8x24` gives 0.00000006
Type mismatch	Won't compile: `u8x8 + s16x16` (unsigned + signed)	Cast smaller to larger: `s16x16(small) + large` (or use `auto` to promote)
Precision loss	`.to_int()` truncates decimals: `2.7.to_int()` → `2`	Use `.to_float()` if you need decimals; or just keep as fixed-point
Slow operations	`x / 2` is slower than it needs to be for powers of 2	Use bit shifts: `x >> 1` (÷2), `x << 2` (×4) — 5-10x faster
Lost decimals	Assigning to `uint8_t` directly: `uint8_t val = faded;` (no conversion)	Use `.to_int()`: `uint8_t val = faded.to_int();`

Real FastLED Usage

Easing Functions (`fl/ease.h`)

Smooth animations using fixed-point internally for speed:

cpp

auto t = fl::sfixed_integer<16, 16>(0.5f);  // Time parameter

auto eased = fl::smoothstep(
    fl::sfixed_integer<16, 16>(0.0f),
    fl::sfixed_integer<16, 16>(1.0f),
    t);

uint8_t brightness = (eased * 255.0f).to_int();

Animartrix 2D Effects (`src/fl/fx/2d/animartrix_detail/`)

Stores geometry as fixed-point for fast operations:

cpp

struct Geometry {
    fl::sfixed_integer<16, 16> distance;   // Polar distance
    fl::sfixed_integer<16, 16> angle;      // Polar angle (radians)
    fl::sfixed_integer<16, 16> x, y;       // Cartesian coordinates
};

// Fast rotation with precomputed sin/cos
fl::sfixed_integer<16, 16> sin_a, cos_a;
fl::sincos(angle, sin_a, cos_a);

auto rotated_x = cos_a * x - sin_a * y;
auto rotated_y = sin_a * x + cos_a * y;

Perlin Noise (2D Patterns)

Smooth terrain-like patterns for animations:

cpp

auto noise = perlin_s16x16::pnoise2d(x, y, fade_lut, perm);
// Returns [-1, 1], converted to LED brightness

SIMD Versions (4x Parallel Processing)

Fixed-point SIMD types (s0x32x4, s16x16x4) are fully implemented with complete arithmetic and math operations. Float SIMD is not available on embedded targets.

What is SIMD?

SIMD = "Single Instruction, Multiple Data" — process 4 values simultaneously with one CPU operation.

Instead of:

Loop 4 times: value[0], value[1], value[2], value[3]  ← Serial

SIMD does:

[value0, value1, value2, value3]  ← One operation on 4 lanes!

Available SIMD Types

Currently implemented:

s0x32x4 - Normalized values (Q31 format, for [-1, 1] range)
s16x16x4 - General fixed-point (Q16.16 format, most common)

Not yet available: u8x8x4, s8x24x4, etc. (scalar versions are recommended for other types)

When to Use SIMD

✅ Processing 4+ values with identical operations
✅ Hot loops where arithmetic and math functions dominate
✅ Load/store operations on aligned arrays of fixed-point values
✅ Batch sin/cos/lerp/clamp on 4 angles or values simultaneously
❌ Processing single values (overhead not worth it)

SIMD Types and Creation

cpp

#include "fl/stl/fixed_point/s16x16x4.h"
#include "fl/stl/fixed_point/s0x32x4.h"

// Broadcast: all 4 lanes get same value
s16x16 val(1.57f);  // π/2
auto angles = s16x16x4::set1(val);
// Result: [1.57, 1.57, 1.57, 1.57]

// Load from memory (4 consecutive s16x16 values)
s16x16 array[4] = {1.0f, 2.0f, 3.0f, 4.0f};
auto vec = s16x16x4::load(&array[0]);

// Store back to memory
s16x16 output[4];
vec.store(&output[0]);

Currently Available Operations

Arithmetic

cpp

auto a = s16x16x4::set1(s16x16(2.0f));
auto b = s16x16x4::set1(s16x16(0.5f));

auto sum = a + b;       // [2.5, 2.5, 2.5, 2.5]
auto diff = a - b;      // [1.5, 1.5, 1.5, 1.5]
auto prod = a * b;      // [1.0, 1.0, 1.0, 1.0]
auto neg = -a;          // [-2.0, -2.0, -2.0, -2.0]
auto shifted = a >> 1;  // [1.0, 1.0, 1.0, 1.0]  (arithmetic shift right)

// Multiply: s0x32x4 × s16x16x4 → s16x16x4 (Q31 × Q16)
auto normalized = s0x32x4::set1(s0x32(0.5f));  // 0.5 normalized
auto scaled = normalized * a;  // Cross-type multiply

Comparison and Selection

cpp

auto min_val = a.min(b);    // Element-wise minimum
auto max_val = a.max(b);    // Element-wise maximum
auto clamped = a.clamp(s16x16x4::set1(s16x16(0.0f)),  // Clamp to [0, 2]
                       s16x16x4::set1(s16x16(2.0f)));
auto abs_val = a.abs();     // Absolute value (branchless)

Math Functions

cpp

// Trigonometry
auto sines = a.sin();       // sin() of 4 angles (in radians)
auto cosines = a.cos();     // cos() of 4 angles (in radians)

// For separate sin and cos (more efficient if you need both)
s16x16x4 sin_out, cos_out;
a.sincos(sin_out, cos_out);  // Returns both simultaneously

// Linear interpolation
auto t = s16x16x4::set1(s16x16(0.5f));
auto interpolated = a.lerp(b, s16x16(0.5f));  // Midpoint between a and b

Load/Store

cpp

// Load 4 values from array (unaligned access OK)
s16x16 data[4] = {1.0f, 2.0f, 3.0f, 4.0f};
auto vec = s16x16x4::load(&data[0]);

// Store 4 values back
s16x16 output[4];
vec.store(&output[0]);

Fixed-Point SIMD Operations (Fully Implemented)

All operations for s0x32x4 and s16x16x4 are fully implemented:

Operation	Description
load/store	Transfer data to/from SIMD registers
set1	Broadcast a scalar to all 4 lanes
*+, -, /	Element-wise arithmetic (add, subtract, multiply)
- (unary)	Negate all lanes
>>/<<<<	Arithmetic/logical shifts
abs	Absolute value (branchless)
min/max	Element-wise min/max
clamp	Clamp to range
lerp	Linear interpolation
sin/cos	Trigonometric functions
sincos	Combined sin/cos (more efficient)

See test file for comprehensive coverage: tests/fl/simd.cpp (30+ test cases)

Example: SIMD Array Processing

cpp

// ✅ Good: Process array of coordinates with SIMD arithmetic
struct Point {
    s16x16 x, y;
};

Point scale_points_simd(const Point* points, s16x16 scale_factor) {
    // Load 4 points' x coordinates
    s16x16 x_coords[4] = {
        points[0].x, points[1].x, points[2].x, points[3].x
    };
    auto x_vec = s16x16x4::load(&x_coords[0]);

    // Scale all 4 at once (broadcast scalar to SIMD)
    auto scale_simd = s16x16x4::set1(scale_factor);
    auto scaled_x = x_vec * scale_simd;

    // Store back
    s16x16 result[4];
    scaled_x.store(&result[0]);

    // Result: all 4 x values scaled
    return {result[0], result[1]};  // Example (incomplete)
}

When NOT to Use SIMD

cpp

// ❌ Bad: Using fixed-point SIMD for single values (overhead)
auto angle_simd = s16x16x4::set1(s16x16(1.57f));
auto sine = angle_simd.sin();   // Wasteful! Process 4 values, use 1
// Cost: 4-lane SIMD overhead for a single angle

// ✅ Good: Use scalar fixed-point for single values
auto angle = s16x16(1.57f);
auto sine = fl::sin(angle);  // Direct, no overhead

// ✅ Good: Use SIMD when processing 4+ values
s16x16 angles[4] = {0.0f, 1.57f, 3.14f, 4.71f};
auto angles_simd = s16x16x4::load(&angles[0]);
auto sines = angles_simd.sin();  // Efficient batch processing

API Quick Reference

Creation

cpp

fl::sfixed_integer<16, 16> x(3.14f);
fl::ufixed_integer<8, 8> y(200.0f);

// From raw
auto z = fl::sfixed_integer<16, 16>::from_raw(0x10000);

Conversion

cpp

float f = x.to_float();
int i = x.to_int();
auto raw = x.raw();

Free-Function Math

cpp

fl::sin(x), fl::cos(x), fl::sqrt(x)
fl::floor(x), fl::ceil(x), fl::fract(x)
fl::lerp(a, b, t), fl::clamp(x, lo, hi)
fl::smoothstep(e0, e1, x)
fl::sincos(angle, sin_out, cos_out)

Arithmetic

cpp

a + b, a - b, a * b, a / b, -a
a >> 1, a << 2
a < b, a == b, a >= b

Member Methods (Alternative)

cpp

x.sin(), x.cos(), x.sqrt()
x.floor(), x.ceil(), x.fract()
x.abs()

Getting Started (Beginner Checklist)

✅ Step 1: Use the default configuration

Start with fl::sfixed_integer<16, 16> or its alias fl::s16x16
It works for 95% of use cases (angles, brightness, coordinates, easing)

✅ Step 2: Copy an example above

Pick Example 1 or 2 and try it in your code
Replace the floats with fixed-point variables
Compile and check that it works

✅ Step 3: Convert back to output types

Use .to_int() to convert to uint8_t for LED brightness
Use .to_float() only if you need to pass to a float-expecting function
Keep as fixed-point for intermediate calculations (faster!)

✅ Step 4: If you need different precision or range

Check the lookup table in "Choosing a Template Configuration"
Change <16, 16> to the appropriate type
That's it — API is identical

✅ Step 5: Test it

bash

bash test fixed_point

Advanced: Next Steps

Run the test suite: bash test fixed_point — validates all implementations
Look at real usage: Search for s16x16 in src/fl/fx/2d/animartrix_detail/ for production examples
Check accuracy bounds: tests/fl/fixed_point.cpp for type-specific precision guarantees
Benchmark your code: Use profiling if performance matters (fixed-point should be plenty fast)

Key Files

Header: fl/stl/fixed_point.h — Main template APIs and free-function math
Aliases: fl/stl/fixed_point/s16x16.h, u8x8.h, etc.
Tests: tests/fl/fixed_point.cpp — 197+ test groupings with accuracy bounds
Internals: fl/stl/fixed_point/base.h — CRTP implementation

Fixed-Point Arithmetic Library

Fixed-Point Arithmetic Library

What is Fixed-Point? (5-Minute Intro)

The Two Main APIs: sfixed_integer and ufixed_integer

Signed Fixed-Point Integer

Unsigned Fixed-Point Integer

Quick Examples (Start Here)

Example 1: Fade LED Brightness

Example 2: Smooth Animation

Example 3: Rotate a Point

Example 4: Perlin Noise (Animartrix)

Understanding Range vs Precision (Key Concept)

Creating and Converting Values

From Floats (Most Common)

Converting Back

From Raw Values (Advanced/Rare)

Auto-Promotion (Smaller → Larger, Automatic)

Math API: Free-Function Style (Like std::cmath)

Rounding & Decomposition

Interpolation & Clamping

Trigonometry (Ultra-Fast Lookup Tables)

Roots & Powers

Arithmetic Operators

Modulo

Member Method API (Alternative)

Choosing a Template Configuration

Convenience Type Aliases

Performance Characteristics

Common Pitfalls and Solutions

Real FastLED Usage

Easing Functions (fl/ease.h)

Animartrix 2D Effects (src/fl/fx/2d/animartrix_detail/)

Perlin Noise (2D Patterns)

SIMD Versions (4x Parallel Processing)

What is SIMD?

Available SIMD Types

When to Use SIMD

SIMD Types and Creation

Currently Available Operations

Arithmetic

Comparison and Selection

Math Functions

Load/Store

Fixed-Point SIMD Operations (Fully Implemented)

Example: SIMD Array Processing

When NOT to Use SIMD

API Quick Reference

Creation

Conversion

Free-Function Math

Arithmetic

Member Methods (Alternative)

Getting Started (Beginner Checklist)

Advanced: Next Steps

Key Files

The Two Main APIs: `sfixed_integer` and `ufixed_integer`

Easing Functions (`fl/ease.h`)

Animartrix 2D Effects (`src/fl/fx/2d/animartrix_detail/`)