@woosh/meep-engine 2.155.0 → 2.157.0

package/src/core/math/noise/sdnoise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAmDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAiIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CA+OlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA6RlB"}
+{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAmDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAkIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CA+OlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA+RlB"}

package/src/core/math/noise/sdnoise.js

@@ -304,9 +304,10 @@ export function sdnoise2(derivatives, x, y) {
     x2 = x0 - 1.0 + 2.0 * G2; /* Offsets for last corner in (x,y) unskewed coords */
     y2 = y0 - 1.0 + 2.0 * G2;
 
-    /* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
-    ii = i % 256;
-    jj = j % 256;
+    /* Wrap the integer indices into [0,255]. Use & 255 (not % 256): for negative i/j the modulo gives a
+       negative index into perm[], whereas the bitwise AND wraps correctly, matching the 3D/4D code. */
+    ii = i & 0xff;
+    jj = j & 0xff;
 
     /* Calculate the contribution from the three corners */
     t0 = 0.5 - x0 * x0 - y0 * y0;
@@ -723,12 +724,14 @@ export function sdnoise4(derivatives, x, y, z, w) {
     // impossible. Only the 24 indices which have non-zero entries make any sense.
     // We use a thresholding to set the coordinates in turn from the largest magnitude.
     // The number 3 in the "simplex" array is at the position of the largest coordinate.
-    const simplex_c = simplex[c];
-
-    const simplex_c_0 = simplex_c[0];
-    const simplex_c_1 = simplex_c[1];
-    const simplex_c_2 = simplex_c[2];
-    const simplex_c_3 = simplex_c[3];
+    // `simplex` is a flat Uint8Array of 64 rows x 4 columns; row c starts at c*4. Indexing it as simplex[c][k]
+    // read a number then a non-existent property (always undefined), zeroing every corner offset.
+    const simplex_base = c * 4;
+
+    const simplex_c_0 = simplex[simplex_base];
+    const simplex_c_1 = simplex[simplex_base + 1];
+    const simplex_c_2 = simplex[simplex_base + 2];
+    const simplex_c_3 = simplex[simplex_base + 3];
 
     i1 = simplex_c_0 >= 3 ? 1 : 0;
     j1 = simplex_c_1 >= 3 ? 1 : 0;

package/src/core/math/physics/kinematics/computeInterceptPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeInterceptPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/kinematics/computeInterceptPoint.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,+HAHW,MAAM,GACL,OAAO,CA8DlB"}

package/src/{engine/physics → core/math/physics/kinematics}/computeInterceptPoint.js

@@ -1,80 +1,80 @@
-import { v3_dot } from "../../core/geom/vec3/v3_dot.js";
-import { solveQuadratic } from "../../core/math/solveQuadratic.js";
-
-/**
- *
- * @type {number[]}
- */
-const q_roots = [];
-
-/**
- * Given position of the source point, and target moving at a constant velocity, compute intercept.
- * Simple example would be {@link target} being enemy running, and {@link source} being position of our archer, given that the arrow speed is {@link sourceSpeed}, where should the archer aim at in order to hit the moving target?
- * @param {Vector3} result This is where the intercept point will be written if solution is found
- * @param {Vector3} source Where to launch a projectile from
- * @param {Vector3} target Where the target currently is
- * @param {Vector3} targetVelocity Target's current velocity vector
- * @param {number} sourceSpeed Speed of the projectile in question
- * @return {boolean} true iff there is at least one real solution
- */
-export function computeInterceptPoint(
-    result,
-    source,
-    target,
-    targetVelocity,
-    sourceSpeed
-) {
-
-    if (sourceSpeed < 0) {
-        // negative speed is invalid
-        return false;
-    }
-
-    const d_ts_x = target.x - source.x;
-    const d_ts_y = target.y - source.y;
-    const d_ts_z = target.z - source.z;
-
-    // Get quadratic equation components
-    const a = targetVelocity.dot(targetVelocity) - sourceSpeed * sourceSpeed;
-    const b = 2 * v3_dot(targetVelocity.x, targetVelocity.y, targetVelocity.z, d_ts_x, d_ts_y, d_ts_z);
-
-    const c = v3_dot(
-        d_ts_x, d_ts_y, d_ts_z,
-        d_ts_x, d_ts_y, d_ts_z
-    );
-
-    // Solve quadratic
-    const root_count = solveQuadratic(q_roots, 0, a, b, c); // See quad(), below
-
-    // Find smallest positive solution
-    if (root_count > 0) {
-        const root_0 = q_roots[0];
-        const root_1 = q_roots[1];
-
-        let t = Math.min(root_0, root_1);
-
-        if (t < 0) {
-            // one of the roots is negative, which would produce imaginary solution, so let's try to pick the other one
-            t = Math.max(root_0, root_1);
-        }
-
-        if (t >= 0) {
-
-            // Single write, computed from the inputs up front, so it is correct
-            // even when `result` aliases `target` (a copy-then-add would read
-            // `target` after overwriting it, doubling the velocity term).
-            result.set(
-                target.x + targetVelocity.x * t,
-                target.y + targetVelocity.y * t,
-                target.z + targetVelocity.z * t,
-            );
-
-            return true;
-
-        }
-
-        // if we got to this point, that means that both roots are imaginary, so there is no real solution
-
-    }
-    return false;
+import { v3_dot } from "../../../geom/vec3/v3_dot.js";
+import { solveQuadratic } from "../../solveQuadratic.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const q_roots = [];
+
+/**
+ * Given position of the source point, and target moving at a constant velocity, compute intercept.
+ * Simple example would be {@link target} being enemy running, and {@link source} being position of our archer, given that the arrow speed is {@link sourceSpeed}, where should the archer aim at in order to hit the moving target?
+ * @param {Vector3} result This is where the intercept point will be written if solution is found
+ * @param {Vector3} source Where to launch a projectile from
+ * @param {Vector3} target Where the target currently is
+ * @param {Vector3} targetVelocity Target's current velocity vector
+ * @param {number} sourceSpeed Speed of the projectile in question
+ * @return {boolean} true iff there is at least one real solution
+ */
+export function computeInterceptPoint(
+    result,
+    source,
+    target,
+    targetVelocity,
+    sourceSpeed
+) {
+
+    if (sourceSpeed < 0) {
+        // negative speed is invalid
+        return false;
+    }
+
+    const d_ts_x = target.x - source.x;
+    const d_ts_y = target.y - source.y;
+    const d_ts_z = target.z - source.z;
+
+    // Get quadratic equation components
+    const a = targetVelocity.dot(targetVelocity) - sourceSpeed * sourceSpeed;
+    const b = 2 * v3_dot(targetVelocity.x, targetVelocity.y, targetVelocity.z, d_ts_x, d_ts_y, d_ts_z);
+
+    const c = v3_dot(
+        d_ts_x, d_ts_y, d_ts_z,
+        d_ts_x, d_ts_y, d_ts_z
+    );
+
+    // Solve quadratic
+    const root_count = solveQuadratic(q_roots, 0, a, b, c); // See quad(), below
+
+    // Find smallest positive solution
+    if (root_count > 0) {
+        const root_0 = q_roots[0];
+        const root_1 = q_roots[1];
+
+        let t = Math.min(root_0, root_1);
+
+        if (t < 0) {
+            // one of the roots is negative, which would produce imaginary solution, so let's try to pick the other one
+            t = Math.max(root_0, root_1);
+        }
+
+        if (t >= 0) {
+
+            // Single write, computed from the inputs up front, so it is correct
+            // even when `result` aliases `target` (a copy-then-add would read
+            // `target` after overwriting it, doubling the velocity term).
+            result.set(
+                target.x + targetVelocity.x * t,
+                target.y + targetVelocity.y * t,
+                target.z + targetVelocity.z * t,
+            );
+
+            return true;
+
+        }
+
+        // if we got to this point, that means that both roots are imaginary, so there is no real solution
+
+    }
+    return false;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"compute_bhmie_optical_properties.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_bhmie_optical_properties.js"],"names":[],"mappings":"AAUA;;;;;;;;;;GAUG;AACH,6DANW,MAAM,UACN,MAAM,OACN,CAAC,MAAM,EAAC,MAAM,CAAC,SACf,CAAC,MAAM,EAAC,MAAM,CAAC;iBACA,MAAM;WAAQ,MAAM;WAAQ,MAAM;OAAI,MAAM;EAmIrE"}
+{"version":3,"file":"compute_bhmie_optical_properties.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_bhmie_optical_properties.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;GAUG;AACH,6DANW,MAAM,UACN,MAAM,OACN,CAAC,MAAM,EAAC,MAAM,CAAC,SACf,CAAC,MAAM,EAAC,MAAM,CAAC;iBACA,MAAM;WAAQ,MAAM;WAAQ,MAAM;OAAI,MAAM;EA+IrE"}

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

@@ -1,12 +1,44 @@
+import { complex_add } from "../../complex/complex_add.js";
+import { complex_div } from "../../complex/complex_div.js";
+import { complex_mul } from "../../complex/complex_mul.js";
+import { complex_sub } from "../../complex/complex_sub.js";
 
-// Complex arithmetic helpers (a,b represent a + i b)
-function cadd(a, b) { return [a[0] + b[0], a[1] + b[1]]; }
-function csub(a, b) { return [a[0] - b[0], a[1] - b[1]]; }
-function cmul(a, b) { return [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]]; }
-function cdiv(a, b) { const d = b[0]*b[0] + b[1]*b[1]; return [(a[0]*b[0] + a[1]*b[1]) / d, (a[1]*b[0] - a[0]*b[1]) / d]; }
+// Real accessors on a complex (a + i b) stored as [re, im]. Non-allocating.
 function creal(a) { return a[0]; }
-function cabs2(a) { return a[0]*a[0] + a[1]*a[1]; }
-
+function cabs2(a) { return a[0] * a[0] + a[1] * a[1]; }
+
+// ---------------------------------------------------------------------------------------------
+// Allocation-free complex algebra (see lorenz_mie_coefs.js for the rationale): the recurrences
+// below call the meep complex primitives (complex_add/sub/mul/div) directly into these reused
+// module-static buffers instead of allocating a fresh [re,im] per operation. The function is
+// single-threaded and non-reentrant, so reusing the scratch is safe.
+//
+// complex_add/sub are aliasing-safe; complex_mul/div are NOT (they write result[0] then read it
+// for result[1]), so their output buffer always differs from both inputs.
+// ---------------------------------------------------------------------------------------------
+const _m = new Float64Array(2);        // relative refractive index n_p / n_med
+const _mx = new Float64Array(2);       // m * x
+const _xi_nm1 = new Float64Array(2);   // xi_{n-1}(x)
+const _xi_n = new Float64Array(2);     // xi_n(x)
+const _xi_np1 = new Float64Array(2);   // xi_{n+1}(x)
+const _xi_prime = new Float64Array(2); // xi'_n(x)
+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);
+
+// Reused pools: D_n(mx) (log-derivative) and the stored a_n, b_n (needed by the asymmetry sum).
+const _D = [];
+const _a = [];
+const _b = [];
+
+function ensure_vec2_pool(pool, count) {
+    for (let i = pool.length; i < count; ++i) {
+        pool.push(new Float64Array(2));
+    }
+}
 
 /**
  * Canonical Bohren–Huffman Mie solver (reference implementation)
@@ -29,23 +61,31 @@ export function compute_bhmie_optical_properties(wavelength, radius, n_p, n_med)
     return { sigma_a_med: 4 * Math.PI * n_med[1] / wavelength, C_ext: 0, C_sca: 0, g: 0 };
   }
 
-  // Relative refractive index m = n_p / n_med
-  const m = cdiv([n_p[0], n_p[1]], [n_med[0], n_med[1]]);
-  // mx is complex (m * x)
-  const mx = [m[0] * x, m[1] * x];
+  // Relative refractive index m = n_p / n_med, and mx = m * x (complex)
+  complex_div(_m, n_p, n_med);
+  _mx[0] = _m[0] * x;
+  _mx[1] = _m[1] * x;
 
   // Truncation for series
   const nstop = Math.max(2, Math.round(x + 4.0 * Math.cbrt(x) + 2));
 
+  ensure_vec2_pool(_D, nstop + 1);
+  ensure_vec2_pool(_a, nstop + 1);
+  ensure_vec2_pool(_b, nstop + 1);
+
   // Downward recurrence for D_n(mx) = ψ'_n(mx)/ψ_n(mx), complex n from nstop..1
-  const D = new Array(nstop + 1);
-  D[nstop] = [0, 0];
+  _D[nstop][0] = 0;
+  _D[nstop][1] = 0;
   for (let n = nstop; n >= 1; --n) {
     // D_{n-1} = n/(mx) - 1 / (D_n + n/(mx))
-    const n_over_mx = cdiv([n, 0], mx);
-    const denom = cadd(D[n], n_over_mx);
-    const invDen = cdiv([1, 0], denom);
-    D[n - 1] = csub(n_over_mx, invDen);
+    _t3[0] = n;
+    _t3[1] = 0;
+    complex_div(_t0, _t3, _mx);        // n_over_mx
+    complex_add(_t1, _D[n], _t0);      // denom = D_n + n_over_mx
+    _t3[0] = 1;
+    _t3[1] = 0;
+    complex_div(_t2, _t3, _t1);        // invDen
+    complex_sub(_D[n - 1], _t0, _t2);  // D_{n-1} = n_over_mx - invDen
   }
 
   // Upward recurrence for real ψ_n(x) and complex ξ_n(x) at real x
@@ -55,50 +95,53 @@ export function compute_bhmie_optical_properties(wavelength, radius, n_p, n_med)
   let psi_nm1 = sx;                      // ψ_0
   let psi_n = sx / x - cx;               // ψ_1
   // ξ_0, ξ_1 (complex): ξ_n = ψ_n + i χ_n, with χ_0 = -cos x, χ_1 = -cos x / x - sin x
-  let xi_nm1 = [sx, -cx];                // ξ_0
-  let xi_n = [psi_n, -(cx / x + sx)];    // ξ_1
+  _xi_nm1[0] = sx; _xi_nm1[1] = -cx;             // ξ_0
+  _xi_n[0] = psi_n; _xi_n[1] = -(cx / x + sx);   // ξ_1
 
   // Sums
   let sum_ext = 0; // Σ (2n+1) Re(a_n + b_n)
   let sum_sca = 0; // Σ (2n+1) (|a_n|^2 + |b_n|^2)
 
-  const a = new Array(nstop + 1); // 1..nstop
-  const b = new Array(nstop + 1);
-
   for (let n = 1; n <= nstop; ++n) {
     // Next ψ and ξ (prepare ψ_{n+1}, ξ_{n+1}) using recurrence
     const two_n_plus_1 = 2 * n + 1;
     const psi_np1 = two_n_plus_1 * psi_n / x - psi_nm1; // ψ_{n+1}
-    const xi_np1 = [ (two_n_plus_1 / x) * xi_n[0] - xi_nm1[0], (two_n_plus_1 / x) * xi_n[1] - xi_nm1[1] ]; // ξ_{n+1}
+    _xi_np1[0] = (two_n_plus_1 / x) * _xi_n[0] - _xi_nm1[0];
+    _xi_np1[1] = (two_n_plus_1 / x) * _xi_n[1] - _xi_nm1[1];
 
     // Derivatives at x (real x): ψ'_n = ψ_{n-1} - n/x ψ_n ; ξ'_n = ξ_{n-1} - n/x ξ_n
     const n_over_x = n / x;
     const psi_prime = psi_nm1 - n_over_x * psi_n;
-    const xi_prime = [xi_nm1[0] - n_over_x * xi_n[0], xi_nm1[1] - n_over_x * xi_n[1]];
+    _xi_prime[0] = _xi_nm1[0] - n_over_x * _xi_n[0];
+    _xi_prime[1] = _xi_nm1[1] - n_over_x * _xi_n[1];
 
     // Log-derivative at mx
-    const Dn = D[n];
+    const Dn = _D[n];
 
-    // Compute a_n and b_n using D-forms (no ψ_n(mx) factors)
     // a_n = [m ψ'_n(x) − D(mx) ψ_n(x)] / [m ξ'_n(x) − D(mx) ξ_n(x)]
-    const m_psi_prime = [m[0] * psi_prime, m[1] * psi_prime];
-    const Dn_psi_n = [Dn[0] * psi_n, Dn[1] * psi_n];
-    const num_a = csub(m_psi_prime, Dn_psi_n);
-    const m_xi_prime = cmul(m, xi_prime);
-    const Dn_xi_n = cmul(Dn, xi_n);
-    const den_a = csub(m_xi_prime, Dn_xi_n);
-    const a_n = cdiv(num_a, den_a);
+    _t0[0] = _m[0] * psi_prime;        // m * ψ'_n (real scalar scaling)
+    _t0[1] = _m[1] * psi_prime;
+    _t1[0] = Dn[0] * psi_n;            // D_n * ψ_n
+    _t1[1] = Dn[1] * psi_n;
+    complex_sub(_t2, _t0, _t1);        // num_a
+    complex_mul(_t3, _m, _xi_prime);   // m * ξ'_n
+    complex_mul(_t4, Dn, _xi_n);       // D_n * ξ_n
+    complex_sub(_t5, _t3, _t4);        // den_a
+    complex_div(_a[n], _t2, _t5);      // a_n
 
     // b_n = [ψ'_n(x) − m D(mx) ψ_n(x)] / [ξ'_n(x) − m D(mx) ξ_n(x)]
-    const mDn = cmul(m, Dn);
-    const mDn_psi_n = [mDn[0] * psi_n, mDn[1] * psi_n];
-    const num_b = csub([psi_prime, 0], mDn_psi_n);
-    const mDn_xi_n = cmul(mDn, xi_n);
-    const den_b = csub(xi_prime, mDn_xi_n);
-    const b_n = cdiv(num_b, den_b);
-
-    a[n] = a_n;
-    b[n] = b_n;
+    complex_mul(_t0, _m, Dn);          // mDn
+    _t1[0] = _t0[0] * psi_n;           // mDn * ψ_n
+    _t1[1] = _t0[1] * psi_n;
+    _t5[0] = psi_prime;                // [ψ'_n, 0]
+    _t5[1] = 0;
+    complex_sub(_t2, _t5, _t1);        // num_b
+    complex_mul(_t3, _t0, _xi_n);      // mDn * ξ_n
+    complex_sub(_t4, _xi_prime, _t3);  // den_b
+    complex_div(_b[n], _t2, _t4);      // b_n
+
+    const a_n = _a[n];
+    const b_n = _b[n];
 
     const weight = 2 * n + 1;
     sum_ext += weight * (creal(a_n) + creal(b_n));
@@ -107,8 +150,8 @@ export function compute_bhmie_optical_properties(wavelength, radius, n_p, n_med)
     // Shift recurrences (n→n+1)
     psi_nm1 = psi_n;
     psi_n = psi_np1;
-    xi_nm1 = xi_n;
-    xi_n = xi_np1;
+    _xi_nm1[0] = _xi_n[0]; _xi_nm1[1] = _xi_n[1];
+    _xi_n[0] = _xi_np1[0]; _xi_n[1] = _xi_np1[1];
   }
 
   const x2 = x * x;
@@ -120,16 +163,17 @@ export function compute_bhmie_optical_properties(wavelength, radius, n_p, n_med)
   //  Σ (2n+1)/(n(n+1)) Re(a_n b_n*) + Σ n(n+2)/(n+1) Re(a_n a_{n+1}* + b_n b_{n+1}*)
   let sum_g = 0;
   for (let n = 1; n <= nstop; ++n) {
-    const a_n = a[n];
-    const b_n = b[n];
+    const a_n = _a[n];
+    const b_n = _b[n];
     const re_ab = a_n[0]*b_n[0] + a_n[1]*b_n[1]; // Re(a_n b_n*)
     sum_g += ((2*n + 1) / (n * (n + 1))) * re_ab;
   }
   for (let n = 1; n <= nstop - 1; ++n) {
-    const a_n = a[n], a_np1 = a[n+1];
-    const b_n = b[n], b_np1 = b[n+1];
-    const re_aa1 = a_n[0]*a_np1[0] + a_n[1]*(-a_np1[1]); // Re(a_n a_{n+1}*)
-    const re_bb1 = b_n[0]*b_np1[0] + b_n[1]*(-b_np1[1]); // Re(b_n b_{n+1}*)
+    const a_n = _a[n], a_np1 = _a[n+1];
+    const b_n = _b[n], b_np1 = _b[n+1];
+    // Re(a_n conj(a_{n+1})) = a_re*a'_re + a_im*a'_im (same conjugate convention as the Re(a_n b_n*) loop above)
+    const re_aa1 = a_n[0]*a_np1[0] + a_n[1]*a_np1[1]; // Re(a_n a_{n+1}*)
+    const re_bb1 = b_n[0]*b_np1[0] + b_n[1]*b_np1[1]; // Re(b_n b_{n+1}*)
     sum_g += (n * (n + 2)) / (n + 1) * (re_aa1 + re_bb1);
   }
 

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

@@ -1,20 +1,17 @@
 export function vec2(x: any, y: any): Float64Array;
-export function cadd(a: any, b: any): Float64Array;
-export function cmult(a: any, b: any): Float64Array;
-export function cdiv(a: any, b: any): Float64Array;
 /**
  * Implementation of Lorenz-Mie theory.
  * Useful for calculating physically correct radiation scattering events for particles in a medium.
  *
  * @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.
  * @see https://en.wikipedia.org/wiki/Mie_scattering
  * @author Alexander Goldring (c) 2025
  */
-export function lorenz_mie_coefs(wavelength_m: number, radius_m: number, n_p: typeof vec2, n_med: typeof vec2): Float64Array;
+export function lorenz_mie_coefs(wavelength_m: number, radius_m: number, n_p: number[] | Float32Array | Float64Array, n_med: number[] | Float32Array | Float64Array): Float64Array;
 //# sourceMappingURL=lorenz_mie_coefs.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"lorenz_mie_coefs.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/lorenz_mie_coefs.js"],"names":[],"mappings":"AAOA,mDAEC;AAMD,mDAMC;AAWD,oDAOC;AAED,mDAOC;AAgHD;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,YADN,MAAM,yCAIJ,YAAY,CAyDxB"}
+{"version":3,"file":"lorenz_mie_coefs.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/lorenz_mie_coefs.js"],"names":[],"mappings":"AAUA,mDAEC;AAgID;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,YADN,MAAM,OAEN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,YAAY,CAoGxB"}