update()

void fl::WaveSimulation1D_Real::update

(

)

Definition at line 130 of file wave_simulation_real.cpp.hpp.

                                                {
    i16 *curr = (whichGrid == 0) ? grid1.data() : grid2.data();
    i16 *next = (whichGrid == 0) ? grid2.data() : grid1.data();
 
    // Update boundaries with a Neumann (zero-gradient) condition:
    curr[0] = curr[1];
    curr[length + 1] = curr[length];
 
    i32 mCourantSq32 = static_cast<i32>(mCourantSq);
    // Hoist the lower-saturation bound: in half-duplex mode the new value
    // must be >= 0 (negative parts of the wave are clipped); in full-duplex
    // mode the full Q15 negative range is allowed. Folding this into the
    // per-cell clamp via fl::clamp lets us drop the dedicated second pass
    // that used to walk the whole grid after the update loop.
    const i32 q15_min = mHalfDuplex ? 0 : -32768;
    // Iterate over each inner cell.
    for (fl::size i = 1; i < length + 1; i++) {
        // Compute the 1D Laplacian:
        // lap = curr[i+1] - 2 * curr[i] + curr[i-1]
        i32 lap =
            (i32)curr[i + 1] - (i32)curr[i] * 2 + curr[i - 1];
 
        // Multiply the Laplacian by the simulation speed using Q15 arithmetic.
        // Promote to i64 before the multiply. With the 1D CFL clamp at 1.0,
        // max |mCourantSq32| = 32767 and max |lap| ~131,070 (saturated
        // alternating cells) give a worst-case product of ~4.3e9 — past
        // i32 max (2.15e9). The i64 promote also acts as a safety net if
        // the clamp is ever regressed; pre-clamp the same product could
        // already reach ~4.3e9 in 1D and ~8.6e9 in 2D.
        i32 term = static_cast<i32>(
            (static_cast<i64>(mCourantSq32) * lap) >> 15);
 
        // Compute the new value:
        // f = -next[i] + 2 * curr[i] + term
        i32 f = -(i32)next[i] + (i32)curr[i] * 2 + term;
 
        // Apply damping: use a precomputed Q15 multiplier in place of the
        // arithmetic shift. Functionally equivalent for power-of-two damp
        // (modulo 1-LSB rounding) but generalizes cleanly to non-power-of-
        // two damping if the public API ever needs it. On Cortex-M4+ this
        // lowers to a single smmlsr/smulwb; on AVR it's a 16x32 multiply
        // (~30 cycles) — same ballpark as the shift but cleaner semantics.
        f = static_cast<i32>(
            (static_cast<i64>(f) * mDampDecayQ15) >> 15);
 
        // Clamp f into [q15_min, 32767] in a single step. q15_min is 0 when
        // half-duplex is on, -32768 otherwise. This subsumes both the Q15
        // saturation clamp and the post-pass that used to zero negatives.
        next[i] = static_cast<i16>(fl::clamp(f, q15_min, static_cast<i32>(32767)));
    }
 
    // Toggle the active grid.
    whichGrid ^= 1;
}

References fl::clamp(), fl::FL_NO_EXCEPT, grid1, grid2, length, mCourantSq, mDampDecayQ15, mHalfDuplex, and whichGrid.

Here is the call graph for this function: