@woosh/meep-engine 2.155.0 → 2.156.0

package/src/core/math/physics/mie/lorenz_mie_coefs.js

@@ -5,47 +5,52 @@ import { complex_div } from "../../complex/complex_div.js";
 import { complex_mul } from "../../complex/complex_mul.js";
 import { complex_sub } from "../../complex/complex_sub.js";
 
+// Kept for compute_mie_phase.js. The complex algebra below is allocation-free (it calls the meep
+// complex primitives directly into reused scratch), so the old allocating cadd/cmult/cdiv wrappers
+// are gone.
 export function vec2(x, y) {
     return new Float64Array([x, y]);
 }
 
-function vec4(x, y, z, w) {
-    return new Float64Array([x, y, z, w]);
-}
-
-export function cadd(a, b) {
-    const r = vec2(0, 0);
-
-    complex_add(r, a, b);
-
-    return r;
-}
-
-function csub(a, b) {
-    const r = vec2(0, 0);
-
-
-    complex_sub(r, a, b);
-
-    return r;
-}
-
-export function cmult(a, b) {
-    const r = vec2(0, 0);
-
-
-    complex_mul(r, a, b);
-
-    return r;
-}
-
-export function cdiv(a, b) {
-    const r = vec2(0, 0);
-
-
-    complex_div(r, a, b);
-
-    return r;
+// ---------------------------------------------------------------------------------------------
+// Allocation-free complex algebra.
+//
+// The recurrences below call the non-allocating meep complex primitives (complex_add/sub/mul/div,
+// which write their result into a caller-provided 2-vector) directly, routing every temporary
+// through these module-static scratch buffers instead of allocating a fresh result per operation.
+// lorenz_mie_coefs is single-threaded and non-reentrant (no await, no recursion), so reusing the
+// scratch across the whole computation is safe. Only the returned coefficient array is allocated.
+//
+// IMPORTANT: complex_mul / complex_div are NOT aliasing-safe (they write result[0] then read it
+// when computing result[1]). Their output buffer must therefore differ from both inputs. (add/sub
+// are aliasing-safe.) Every call below respects this.
+// ---------------------------------------------------------------------------------------------
+const _t0 = new Float64Array(2);
+const _t1 = new Float64Array(2);
+const _t2 = new Float64Array(2);
+const _t3 = new Float64Array(2);
+const _t4 = new Float64Array(2);
+const _t5 = new Float64Array(2);
+const _t6 = new Float64Array(2);
+
+const _x = new Float64Array(2);            // size parameter in the host medium
+const _y = new Float64Array(2);            // size parameter in the particle
+const _prev_psi_zeta = new Float64Array(2);
+const _prev_B = new Float64Array(2);
+const _prev_R = new Float64Array(2);
+const _cur_psi_zeta = new Float64Array(2);
+const _cur_B = new Float64Array(2);
+const _cur_R = new Float64Array(2);
+
+// Reused pools for the log-derivative arrays A_n(x) and A_n(y); grown on demand. They are alive
+// at the same time (medium vs particle), hence two separate pools.
+const _A_med = [];
+const _A_p = [];
+
+function ensure_vec2_pool(pool, count) {
+    for (let i = pool.length; i < count; ++i) {
+        pool.push(new Float64Array(2));
+    }
 }
 
 // Number of terms to include in infinite sums (truncation)
@@ -54,108 +59,83 @@ function terms_to_sum(z) {
     return Math.ceil(size + 4.3 * Math.cbrt(size) + 1.0);
 }
 
-// Downward recurrence for A
-function A_all_n(z, M) {
-    const A = new Array(M + 2);
-    A[M + 1] = vec2(0.0, 0.0);
+// Downward recurrence for A_n(z) = psi'_n(z)/psi_n(z). Fills A[0..M+1] (A is a reused vec2 pool).
+function A_all_n(z, M, A) {
+    A[M + 1][0] = 0.0;
+    A[M + 1][1] = 0.0;
     for (let n = M; n >= 0; --n) {
-        const tmp = cdiv(vec2(n + 1.0, 0.0), z);
-        A[n] = csub(tmp, cdiv(vec2(1.0, 0.0), cadd(tmp, A[n + 1])));
+        // tmp = (n + 1) / z
+        _t0[0] = n + 1.0;
+        _t0[1] = 0.0;
+        complex_div(_t1, _t0, z);
+        // A[n] = tmp - 1 / (tmp + A[n + 1])
+        complex_add(_t2, _t1, A[n + 1]);
+        _t0[0] = 1.0;
+        _t0[1] = 0.0;
+        complex_div(_t3, _t0, _t2);
+        complex_sub(A[n], _t1, _t3);
     }
-    return A;
 }
 
-// Upward recurrences for B, psi_zeta, and R
-function psi_zeta(n, z, A, old_B, old_psi_zeta) {
-    if (n > 0) {
-        const n_z = cdiv(vec2(n, 0.0), z);
-        const tmp = cmult(csub(n_z, A[n - 1]), csub(n_z, old_B));
-        old_psi_zeta = cmult(old_psi_zeta, tmp);
-    }
-    return old_psi_zeta;
+// Upward recurrence (Frisvad et al. 2007, Eq. 17) for psi_n(z)*zeta_n(z), n > 0. Writes into out.
+function psi_zeta_step(n, z, A, old_B, old_psi_zeta, out) {
+    // n_z = n / z
+    _t0[0] = n;
+    _t0[1] = 0.0;
+    complex_div(_t1, _t0, z);
+    // tmp = (n_z - A[n-1]) * (n_z - old_B)
+    complex_sub(_t2, _t1, A[n - 1]);
+    complex_sub(_t3, _t1, old_B);
+    complex_mul(_t0, _t2, _t3);
+    // out = old_psi_zeta * tmp
+    complex_mul(out, old_psi_zeta, _t0);
 }
 
-/**
- * Calculates the B_n(z) coefficient for term 'n' via upward recurrence.
- * This is a helper function for LorenzMie_ab.
- *
- * @param {number} n - The current recurrence term index (n >= 0).
- * @param {vec2} z - The complex size parameter (x or y).
- * @param {Array<vec2>} A - Pre-computed log-derivatives A_n(z).
- * @param {vec2} old_B - The previous B coefficient (B_{n-1}).
- * @param {vec2} old_psi_zeta - The previous psi_zeta product term.
- * @returns {vec2} The new B_n coefficient (complex number).
- * @ignore
- */
-function B(n, z, A, old_B, old_psi_zeta) {
-
-    if (n > 0) {
-        old_B.psi_zeta = psi_zeta(n, z, A, old_B, old_psi_zeta);
-        old_B = cadd(A[n], cdiv(vec2(0.0, 1.0), old_B.psi_zeta));
-    }
-
-    return old_B;
+// B_n(z) = A_n(z) + i / (psi_n(z)*zeta_n(z))   (Mackowski, Eq. 16), n > 0. Writes into out.
+function B_step(A_n, psi_zeta_n, out) {
+    _t0[0] = 0.0;
+    _t0[1] = 1.0;
+    complex_div(_t1, _t0, psi_zeta_n);
+    complex_add(out, A_n, _t1);
 }
 
-/**
- * Calculates the R_n(z) coefficient (ratio psi_n / zeta_n) for term 'n'.
- * This is a helper function for LorenzMie_ab.
- *
- * @param {number} n - The current recurrence term index (n >= 0).
- * @param {vec2} z - The complex size parameter (x).
- * @param {Array<vec2>} A - Pre-computed log-derivatives A_n(z).
- * @param {vec2} B_n - The current B_n(z) coefficient.
- * @param {vec2} old_R - The previous R coefficient (R_{n-1}).
- * @returns {vec2} The new R_n coefficient (complex number).
- * @ignore
- */
-function R(n, z, A, B_n, old_R) {
-    if (n > 0) {
-        const n_z = cdiv(vec2(n, 0.0), z);
-        const tmp = cdiv(cadd(B_n, n_z), cadd(A[n], n_z));
-        old_R = cmult(old_R, tmp);
-    }
-    return old_R;
+// R_n(z) = psi_n(z)/zeta_n(z) via upward recurrence (Eq. 18), n > 0. Writes into out.
+function R_step(n, z, A_n, B_n, old_R, out) {
+    // n_z = n / z
+    _t0[0] = n;
+    _t0[1] = 0.0;
+    complex_div(_t1, _t0, z);
+    // ratio = (B_n + n_z) / (A_n + n_z)
+    complex_add(_t2, B_n, _t1);
+    complex_add(_t3, A_n, _t1);
+    complex_div(_t0, _t2, _t3);
+    // out = old_R * ratio
+    complex_mul(out, old_R, _t0);
 }
 
-/**
- * Calculates the Lorenz-Mie scattering coefficients a_n and b_n for a single term 'n'.
- * This implements the formulas from Figure 3 of Frisvad et al. 2007.
- *
- * @param {number} n - The current recurrence term index (n >= 0).
- * @param {number} size - Unitless size parameter x_vac = 2*pi*r / lambda_vac.
- * @param {vec2} n_p - Complex refractive index of the particle.
- * @param {vec2} n_med - Complex refractive index of the medium.
- * @param {Array<vec2>} A_p - Pre-computed log-derivatives A_n(y) for the particle.
- * @param {Array<vec2>} A_med - Pre-computed log-derivatives A_n(x) for the medium.
- * @param {vec2} old_B - The previous B_{n-1}(x) coefficient.
- * @param {vec2} old_R - The previous R_{n-1}(x) coefficient.
- * @param {vec2} old_psi_zeta - The previous psi_zeta product.
- * @returns {vec4} A vec4 [Re(a_n), Im(a_n), Re(b_n), Im(b_n)] with state properties (.old_B, .old_R, .old_psi_zeta) attached for the next iteration.
- * @ignore
- */
-function LorenzMie_ab(n, size, n_p, n_med, A_p, A_med, old_B, old_R, old_psi_zeta) {
-
-    const x = vec2(size * n_med[0], size * n_med[1]);
-    const B_n = B(n, x, A_med, old_B, old_psi_zeta);
-    const R_n = R(n, x, A_med, B_n, old_R);
-    const n_med_A_p = cmult(n_med, A_p[n]);
-    const n_p_A_med = cmult(n_p, A_med[n]);
-    const n_p_A_p = cmult(n_p, A_p[n]);
-    const n_med_A_med = cmult(n_med, A_med[n]);
-    const n_p_B_n = cmult(n_p, B_n);
-    const n_med_B_n = cmult(n_med, B_n);
-    const a = cmult(R_n, cdiv(csub(n_med_A_p, n_p_A_med), csub(n_med_A_p, n_p_B_n)));
-    const b = cmult(R_n, cdiv(csub(n_p_A_p, n_med_A_med), csub(n_p_A_p, n_med_B_n)));
-
-
-    const ab = vec4(a[0], a[1], b[0], b[1]);
-
-    ab.old_psi_zeta = n > 0 ? old_B.psi_zeta : old_psi_zeta;
-    ab.old_B = B_n;
-    ab.old_R = R_n;
-
-    return ab;
+// Lorenz-Mie coefficients a_n, b_n (Frisvad et al. 2007, Eq. 12-13). Writes 4 doubles at ab[off..].
+function ab_step(ab, off, n_p, n_med, A_p_n, A_med_n, B_n, R_n) {
+    // a_n = R_n * (n_med*A_p - n_p*A_med) / (n_med*A_p - n_p*B_n)
+    complex_mul(_t0, n_med, A_p_n);    // n_med * A_p
+    complex_mul(_t1, n_p, A_med_n);    // n_p   * A_med
+    complex_mul(_t2, n_p, B_n);        // n_p   * B_n
+    complex_sub(_t3, _t0, _t1);        // numerator
+    complex_sub(_t4, _t0, _t2);        // denominator
+    complex_div(_t5, _t3, _t4);
+    complex_mul(_t6, R_n, _t5);
+    ab[off] = _t6[0];
+    ab[off + 1] = _t6[1];
+
+    // b_n = R_n * (n_p*A_p - n_med*A_med) / (n_p*A_p - n_med*B_n)
+    complex_mul(_t0, n_p, A_p_n);      // n_p   * A_p
+    complex_mul(_t1, n_med, A_med_n);  // n_med * A_med
+    complex_mul(_t2, n_med, B_n);      // n_med * B_n
+    complex_sub(_t3, _t0, _t1);        // numerator
+    complex_sub(_t4, _t0, _t2);        // denominator
+    complex_div(_t5, _t3, _t4);
+    complex_mul(_t6, R_n, _t5);
+    ab[off + 2] = _t6[0];
+    ab[off + 3] = _t6[1];
 }
 
 /**
@@ -164,8 +144,8 @@ function LorenzMie_ab(n, size, n_p, n_med, A_p, A_med, old_B, old_R, old_psi_zet
  *
  * @param {number} radius_m - Particle radius (in meters).
  * @param {number} wavelength_m - Wavelength of light in vacuum (in meters).
- * @param {vec2} n_p - Complex refractive index of the particle
- * @param {vec2} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
+ * @param {number[]|Float32Array|Float64Array} n_p - Complex refractive index of the particle
+ * @param {number[]|Float32Array|Float64Array} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
  * @returns {Float64Array} Mie coefficients a_n and b_n in form [a_n0.r, a_n0.i, b_n0.r, b_n0.i, ... a_nN.r, a_nN.i, b_nN.r, b_nN.i]
  *
  * @see "Computing the Scattering Properties of Participating Media Using Lorenz-Mie Theory", SIGGRAPH 2007 by Frisvad et al.
@@ -187,40 +167,83 @@ export function lorenz_mie_coefs(
     assert.isFinite(radius_m, 'radius_m');
     assert.greaterThan(radius_m, 0, 'radius_m');
 
-    const psize = 2.0 * Math.PI * radius_m / wavelength_m;
+    let psize = 2.0 * Math.PI * radius_m / wavelength_m;
+
+    // Remove the removable singularity at x0 = k*pi (k >= 1), where x0 = psize*Re(n_med).
+    // The recurrence initialisation (Frisvad et al. 2007, Eq. 20) seeds
+    //   psi_0/zeta_0 = 0.5*(1 - e^{-i2x0})   and   psi_0*zeta_0 = 0.5*(1 - e^{i2x0}),
+    // both of which vanish when x0 is an integer multiple of pi (psi_0 = sin(x0) = 0). That
+    // zeroes every a_n,b_n and collapses the cross sections. The true cross sections are smooth
+    // across x0 = k*pi, so we step the size parameter just off the singular grid by NUDGE radians.
+    // NUDGE sits far outside the ill-conditioned zone (|x0 - k*pi| < ~1e-8) yet far below the
+    // method's far-field accuracy, so the value returned is the correct smooth one (validated to
+    // <1e-4 relative against the OMLC benchmark, which lands exactly on x0 = 10*pi). k = 0 (the
+    // r -> 0 limit) is intentionally excluded: there the vanishing seed yields the physically
+    // correct ~0 cross section. Inputs not within NUDGE of k*pi are left bit-for-bit unchanged.
+    {
+        const reMed = n_med[0];
+        const x0 = psize * reMed;
+        const k = Math.round(x0 / Math.PI);
+        if (k >= 1) {
+            const NUDGE = 1e-4; // radians, in x0 units
+            const rem = x0 - k * Math.PI;
+            if (Math.abs(rem) < NUDGE) {
+                psize = (k * Math.PI + (rem < 0 ? -NUDGE : NUDGE)) / reMed;
+            }
+        }
+    }
 
-    const x = vec2(psize * n_med[0], psize * n_med[1]);
-    const y = vec2(psize * n_p[0], psize * n_p[1]);
-    const M = terms_to_sum(x);
-    const A_med = A_all_n(x, M);
-    const A_p = A_all_n(y, M);
+    _x[0] = psize * n_med[0];
+    _x[1] = psize * n_med[1];
+    _y[0] = psize * n_p[0];
+    _y[1] = psize * n_p[1];
 
-    const e_term = Math.exp(2.0 * x[1]);
+    const M = terms_to_sum(_x);
 
-    let prev_psi_zeta = vec2(0.5 * (1.0 - Math.cos(2.0 * x[0]) / e_term), -0.5 * Math.sin(2.0 * x[0]) / e_term);
-    let prev_B = vec2(0.0, 1.0);
-    let prev_R = vec2(0.5 * (1.0 - Math.cos(2.0 * x[0]) * e_term), 0.5 * Math.sin(2.0 * x[0]) * e_term);
+    ensure_vec2_pool(_A_med, M + 2);
+    ensure_vec2_pool(_A_p, M + 2);
+    A_all_n(_x, M, _A_med);
+    A_all_n(_y, M, _A_p);
 
-    const ab = new Float64Array(M * 4);
+    const e_term = Math.exp(2.0 * _x[1]);
 
-    for (let n = 0; n < M; ++n) {
-
-        const ab_n = LorenzMie_ab(
-            n, psize, n_p, n_med, A_p, A_med,
-            prev_B, prev_R, prev_psi_zeta
-        );
+    _prev_psi_zeta[0] = 0.5 * (1.0 - Math.cos(2.0 * _x[0]) / e_term);
+    _prev_psi_zeta[1] = -0.5 * Math.sin(2.0 * _x[0]) / e_term;
+    _prev_B[0] = 0.0;
+    _prev_B[1] = 1.0;
+    _prev_R[0] = 0.5 * (1.0 - Math.cos(2.0 * _x[0]) * e_term);
+    _prev_R[1] = 0.5 * Math.sin(2.0 * _x[0]) * e_term;
 
-        prev_psi_zeta = ab_n.old_psi_zeta;
-        prev_B = ab_n.old_B;
-        prev_R = ab_n.old_R;
+    const ab = new Float64Array(M * 4);
 
-        // plug the data in
-        ab[4 * n] = ab_n[0];
-        ab[4 * n + 1] = ab_n[1];
-        ab[4 * n + 2] = ab_n[2];
-        ab[4 * n + 3] = ab_n[3];
+    for (let n = 0; n < M; ++n) {
 
+        // For n = 0 the upward recurrences return their seed unchanged, so B_n/R_n are the seeds
+        // and the state is left untouched (matching the original termwise formulation).
+        let B_n;
+        let R_n;
+        if (n === 0) {
+            B_n = _prev_B;
+            R_n = _prev_R;
+        } else {
+            psi_zeta_step(n, _x, _A_med, _prev_B, _prev_psi_zeta, _cur_psi_zeta);
+            B_step(_A_med[n], _cur_psi_zeta, _cur_B);
+            R_step(n, _x, _A_med[n], _cur_B, _prev_R, _cur_R);
+            B_n = _cur_B;
+            R_n = _cur_R;
+        }
+
+        ab_step(ab, 4 * n, n_p, n_med, _A_p[n], _A_med[n], B_n, R_n);
+
+        if (n > 0) {
+            _prev_psi_zeta[0] = _cur_psi_zeta[0];
+            _prev_psi_zeta[1] = _cur_psi_zeta[1];
+            _prev_B[0] = _cur_B[0];
+            _prev_B[1] = _cur_B[1];
+            _prev_R[0] = _cur_R[0];
+            _prev_R[1] = _cur_R[1];
+        }
     }
 
     return ab;
-}
+}

package/src/core/math/physics/mie/mie_ab_to_optical_properties.d.ts

@@ -3,12 +3,11 @@
  * This function implements Equations (2) and (3) from the 2007 paper
  * "Computing the Scattering Properties of Participating Media..."
  *
- * @param {Float32Array} ab - The flat array of a_n, b_n coefficients from LorenzMie_coefs.
+ * @param {number[]|Float32Array|Float64Array} ab - The flat array of a_n, b_n coefficients from LorenzMie_coefs.
  * @param {number} radius - Particle radius (in meters).
  * @param {number} wavelength - Wavelength of light in vacuum (in meters).
- * @param {vec2} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
+ * @param {number[]|Float32Array|Float64Array} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
  * @returns {object} An object with Q_e, Q_s, albedo, C_ext, and C_sca.
  */
-export function mie_ab_to_optical_properties(ab: Float32Array, wavelength: number, radius: number, n_med: typeof vec2): object;
-import { vec2 } from "./lorenz_mie_coefs.js";
+export function mie_ab_to_optical_properties(ab: number[] | Float32Array | Float64Array, wavelength: number, radius: number, n_med: number[] | Float32Array | Float64Array): object;
 //# sourceMappingURL=mie_ab_to_optical_properties.d.ts.map

package/src/core/math/physics/mie/mie_ab_to_optical_properties.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mie_ab_to_optical_properties.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/mie_ab_to_optical_properties.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,iDANW,YAAY,cAEZ,MAAM,UADN,MAAM,uBAGJ,MAAM,CAgGlB;qBA3GuC,uBAAuB"}
+{"version":3,"file":"mie_ab_to_optical_properties.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/mie_ab_to_optical_properties.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH,iDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAElC,MAAM,UADN,MAAM,SAEN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CA0GlB"}

package/src/core/math/physics/mie/mie_ab_to_optical_properties.js

@@ -1,15 +1,31 @@
 import { v2_dot } from "../../../geom/vec2/v2_dot.js";
-import { cadd, cdiv, cmult, vec2 } from "./lorenz_mie_coefs.js";
+import { complex_add } from "../../complex/complex_add.js";
+import { complex_div } from "../../complex/complex_div.js";
+import { complex_mul } from "../../complex/complex_mul.js";
+
+// Allocation-free complex scratch (see lorenz_mie_coefs.js for the rationale): mie_ab is
+// single-threaded and non-reentrant, so the extinction sum routes its complex temporaries through
+// these reused buffers instead of allocating a fresh result per operation. complex_add is
+// aliasing-safe (used for the in-place accumulation of _sum_t); complex_mul/div are not, so their
+// output buffers differ from their inputs.
+const _an = new Float64Array(2);
+const _bn = new Float64Array(2);
+const _n_med_sq = new Float64Array(2);
+const _apb = new Float64Array(2);
+const _term_t = new Float64Array(2);
+const _mult = new Float64Array(2);
+const _scaled = new Float64Array(2);
+const _sum_t = new Float64Array(2);
 
 /**
  * Calculates the final optical properties by summing the Mie coefficients.
  * This function implements Equations (2) and (3) from the 2007 paper
  * "Computing the Scattering Properties of Participating Media..."
  *
- * @param {Float32Array} ab - The flat array of a_n, b_n coefficients from LorenzMie_coefs.
+ * @param {number[]|Float32Array|Float64Array} ab - The flat array of a_n, b_n coefficients from LorenzMie_coefs.
  * @param {number} radius - Particle radius (in meters).
  * @param {number} wavelength - Wavelength of light in vacuum (in meters).
- * @param {vec2} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
+ * @param {number[]|Float32Array|Float64Array} n_med - Complex refractive index of the medium (e.g., [1.0, 0.0] for air).
  * @returns {object} An object with Q_e, Q_s, albedo, C_ext, and C_sca.
  */
 export function mie_ab_to_optical_properties(
@@ -20,7 +36,11 @@ export function mie_ab_to_optical_properties(
 ) {
     const M = ab.length / 4;
 
-    let sum_t = vec2(0, 0); // Complex sum for Ct
+    // n_med^2 is loop-invariant; compute it once.
+    complex_mul(_n_med_sq, n_med, n_med);
+
+    _sum_t[0] = 0.0; // Complex sum for Ct
+    _sum_t[1] = 0.0;
     let sum_s = 0; // Real sum for Cs
     let sum_g = 0;          // Real sum for Asymmetry (g)
 
@@ -29,26 +49,29 @@ export function mie_ab_to_optical_properties(
         const multiplier = 2 * n + 1;
 
         // Get an and bn from your flat array
-        const an = vec2(ab[4 * n], ab[4 * n + 1]);
-        const bn = vec2(ab[4 * n + 2], ab[4 * n + 3]);
-
-        // 1. For Extinction (Ct)
-        const an_plus_bn = cadd(an, bn);
-        // You need complex math functions cadd, cdiv
-        const n_med_sq = cmult(n_med, n_med);
-        const term_t = cdiv(an_plus_bn, n_med_sq);
-        sum_t = cadd(sum_t, cmult(vec2(multiplier, 0), term_t));
+        _an[0] = ab[4 * n];
+        _an[1] = ab[4 * n + 1];
+        _bn[0] = ab[4 * n + 2];
+        _bn[1] = ab[4 * n + 3];
+
+        // 1. For Extinction (Ct): sum_t += (2n+1) * (an + bn) / n_med^2
+        complex_add(_apb, _an, _bn);
+        complex_div(_term_t, _apb, _n_med_sq);
+        _mult[0] = multiplier;
+        _mult[1] = 0.0;
+        complex_mul(_scaled, _mult, _term_t);
+        complex_add(_sum_t, _sum_t, _scaled);
 
         // 2. For Scattering (Cs)
-        const an_mag_sq = an[0] * an[0] + an[1] * an[1];
-        const bn_mag_sq = bn[0] * bn[0] + bn[1] * bn[1];
+        const an_mag_sq = _an[0] * _an[0] + _an[1] * _an[1];
+        const bn_mag_sq = _bn[0] * _bn[0] + _bn[1] * _bn[1];
         sum_s += multiplier * (an_mag_sq + bn_mag_sq);
 
         // 3. Asymmetry Accumulation (New)
         // Term A: Interference of an and bn
         // Formula: (2n+1) / (n(n+1)) * Re(an * bn*)
         const factor_A = (2 * n + 1) / (n * (n + 1));
-        sum_g += factor_A * v2_dot(an[0], an[1], bn[0], bn[1]);
+        sum_g += factor_A * v2_dot(_an[0], _an[1], _bn[0], _bn[1]);
 
         // Term B: Interference of n and n+1
         // Formula: (n(n+2)) / (n+1) * Re(an * an+1* + bn * bn+1*)
@@ -61,8 +84,8 @@ export function mie_ab_to_optical_properties(
 
             const factor_B = (n * (n + 2)) / (n + 1);
 
-            const term_an_an1 = v2_dot(an[0], an[1], an1_r, an1_i);
-            const term_bn_bn1 = v2_dot(bn[0], bn[1], bn1_r, bn1_i);
+            const term_an_an1 = v2_dot(_an[0], _an[1], an1_r, an1_i);
+            const term_bn_bn1 = v2_dot(_bn[0], _bn[1], bn1_r, bn1_i);
 
             sum_g += factor_B * (term_an_an1 + term_bn_bn1);
         }
@@ -78,7 +101,7 @@ export function mie_ab_to_optical_properties(
     }
 
     // Extinction (Ct from Eq. 22)
-    const C_t = (Math.pow(wavelength, 2) / (2 * Math.PI)) * sum_t[0]; //
+    const C_t = (Math.pow(wavelength, 2) / (2 * Math.PI)) * _sum_t[0]; //
 
     // Scattering (Cs from Eq. 23)
     const alpha = (4 * Math.PI * radius * n_med[1]) / wavelength;
@@ -87,7 +110,10 @@ export function mie_ab_to_optical_properties(
         // avoid division by 0
         gamma = 1;
     } else {
-        gamma = (2 * (1 + (alpha - 1) * Math.exp(alpha))) / Math.pow(alpha, 2);
+        // Algebraically identical to 2*(1 + (alpha-1)*exp(alpha))/alpha^2, but using expm1 removes the
+        // catastrophic cancellation in `1 + (alpha-1)*exp(alpha)` for small alpha (which otherwise loses all
+        // precision and can yield a wrong C_sca or Infinity).
+        gamma = (2 * (alpha + (alpha - 1) * Math.expm1(alpha))) / (alpha * alpha);
     }
     const n_med_mag_sq = n_med[0] * n_med[0] + n_med[1] * n_med[1];
     const C_s_factor = (Math.pow(wavelength, 2) * Math.exp(-alpha)) / (2 * Math.PI * gamma * n_med_mag_sq);
@@ -106,4 +132,4 @@ export function mie_ab_to_optical_properties(
         C_sca: C_s,
         g, // Anisotropy parameter
     }
-}
+}

package/src/core/math/random/randomIntegerBetween.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomIntegerBetween.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/randomIntegerBetween.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4DAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAclB"}
+{"version":3,"file":"randomIntegerBetween.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/random/randomIntegerBetween.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4DAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAiBlB"}

package/src/core/math/random/randomIntegerBetween.js

@@ -18,5 +18,8 @@ export function randomIntegerBetween(random, min, max) {
     assert.greaterThanOrEqual(roll, 0, 'random should return value between 0 and 1');
     assert.lessThanOrEqual(roll, 1, 'random should return value between 0 and 1');
 
-    return Math.round(roll * span) + min;
+    // Inclusive AND uniform: give each of the (span + 1) integers an equal-width slice of [0, 1).
+    // Math.round(roll * span) would halve the probability of the two endpoints. random() may return
+    // exactly 1.0, which would overshoot by one, so clamp the top.
+    return Math.min(max, min + Math.floor(roll * (span + 1)));
 }

package/src/core/math/solveCubic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solveCubic.d.ts","sourceRoot":"","sources":["../../../../src/core/math/solveCubic.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH,mCARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA+DlB"}
+{"version":3,"file":"solveCubic.d.ts","sourceRoot":"","sources":["../../../../src/core/math/solveCubic.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH,mCARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA4ElB"}