@woosh/meep-engine 3.63.3 → 3.64.0

package/CHANGELOG.md

@@ -2,6 +2,57 @@
 
 ## Unreleased
 
+### Colour grading in the tone-mapping LUT
+
+- **Added:** `ColorGrade`, as `renderer.tone_mapper.grade`, neutral by default and baked into the tone mapper's LUTs
+  ahead of the operator, so it costs nothing per pixel. Any change bakes both LUTs again; a LUT the user supplies is
+  not graded. In order:
+  - white balance: Unreal's temperature white balance (`white_temperature`, `white_tint`), Planckian and daylight
+    loci, Bradford to D65;
+  - primaries: Unreal's `ColorCorrectAll` in AP1, saturation, contrast, gamma, gain and offset for `global`,
+    `shadows`, `midtones` and `highlights` (`ColorGradeZone`, each a `Vector4` of RGB and master), blended by
+    `shadows_max`, `highlights_min` and `highlights_max`. Values from an Unreal project give the same result;
+  - hue curves: `hue_shift` (degrees), `hue_saturation` (chroma multiplier) and `hue_lightness` (stops), each an
+    `AnimationCurve` over the OkLCh hue in degrees. Lightness is exposure at the colour's chromaticity, weighted by
+    its saturation against the Rec.709 gamut's edge at its hue, so greys never move.
+- **Added:** `chunk_animation_curve_evaluate_keys`, `AnimationCurve.evaluate` on the GPU over a plain keyframe array;
+  `chunk_color_grade`; `chunk_CRM_REC709_AP1` (Rec.709↔AP1 and AP1 luminance, derived from the chromaticities);
+  `chunk_oklab_compute_max_saturation`; `m3_chromatic_adaptation_bradford`; `m3_white_balance_rec709`. The WGSL
+  emulator gains `degrees` and `radians`.
+- **Changed:** a bake reads the grade. On an RTX 4090 (volumetrics_froxel, 1258 × 646) the ACES bake at 32³ costs
+  4–6 µs neutral and 6–7 µs with a full grade on SDR, 10–14 µs and 12–14 µs on HDR at 1000 cd/m²; 9 and 13 µs at
+  64³ on SDR, 24 and 28 µs on HDR. The apply pass is unchanged.
+- **Changed:** a LUT's error against direct evaluation grows with the grade's detail. With three 20°-wide hue bands
+  and a full primary grade, ACES at 32³ has a p99 of 6.3 8-bit codes on SDR (2.5 neutral) and 15.5 10-bit PQ codes
+  on HDR (5.8 neutral); 64³ brings them to 2.4 and 5.4. Raise `lut_resolution` for such a grade.
+
+### Tone mapping through a baked 3D LUT
+
+- **Added:** `ToneMapper`, owned by the renderer as `renderer.tone_mapper`, made by `initialize`. It bakes its
+  `operator` into a 3D LUT per output, at `lut_resolution` (default 32, as in Unreal; at least 2, at most the
+  device's `maxTextureDimension3D`), and draws every frame through one trilinear fetch. A LUT is baked again only
+  when the operator, the resolution or, for HDR, the display's peak (`tone_mapper.display.peak_nits`) changes. A
+  LUT maps the PQ signal of exposed scene-linear Rec.709 to the PQ signal of linear Rec.2020 display light, 1 at
+  the paper white on both sides; scene colour past 10000 cd/m² (49.3 × SDR white) clamps there, as Unreal's does.
+- **Added:** `ToneMapOperator` (a `CodeChunk` defining `tone_map_operator(scene, peak_nits)`, plus `declare`
+  and `bind` for bindings of its own), and the built-ins `TONE_MAP_OPERATOR_ACES` (the default),
+  `TONE_MAP_OPERATOR_GT7`, `TONE_MAP_OPERATOR_PBR_NEUTRAL` and `TONE_MAP_OPERATOR_NONE`, unchanged in what
+  they compute.
+- **Added:** user LUTs: `set_lut_sdr(resolution, data)`, `set_lut_hdr(resolution, data, peak_nits)`,
+  `clear_lut_sdr()`, `clear_lut_hdr()`, and `build_lut_sdr_from_hdr()`, which maps the HDR LUT down to the paper
+  white through the BT.2390 EETF on the GPU, keeping hue. `chunk_bt2390_eetf` and `chunk_tonemap_lut`.
+- **Changed:** the ACES HDR pass cost 51–68 µs at 1258 × 646 on an RTX 4090 and now costs 7–12 µs; SDR 11–22 µs,
+  now 9–10 µs. A bake costs 7 µs at 32³ (ACES HDR, both ACES 2.0 transforms per texel), 20 µs at 64³. At 32³ the
+  picture moves by a mean of +0.13 8-bit codes on SDR, under the frame-to-frame noise of a live scene.
+- **Breaking:** `renderer.tone_mapping_mode` and `ShadeToneMappingMode` are removed. Set
+  `renderer.tone_mapper.operator` to one of the built-in operators instead.
+- **Breaking:** the eight `shader_tonemap_{LDR,HDR}[_aces|_none|_pbr_neutral]` passes are removed, replaced by
+  `shader_tonemap_LDR_lut` and `shader_tonemap_HDR_lut`. `chunk_tonemap_hdr_bt2390` is removed;
+  `chunk_bt2390_eetf` is the EETF itself. `TonemapDisplaySettings` keeps only the Rec.2020 columns, and
+  `TONEMAP_SETTINGS_REC709`, `TONEMAP_SETTINGS_REC709_PEAK`, `TONEMAP_SETTINGS_REC2020` and
+  `TONEMAP_SETTINGS_REC2020_PEAK` become `TONEMAP_SETTINGS`. `TonemapAces2Tables` holds the tables only; the
+  operator uploads them when it bakes.
+
 ### Outlines: a spec per entity, drawn where the entity is hidden too
 
 - **Added:** `Outline` (`visible`, `hidden`, each an `OutlineSpec`, by default the frozen `OutlineSpec.NONE`, which

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.63.3",
+  "version": "3.64.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/color/xyz/m3_chromatic_adaptation_bradford.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The von Kries adaptation in Bradford cone space that takes the `source` white to the `destination` white, as a
+ * matrix on CIE XYZ. Row-major. A colour seen under the source white maps to the colour that looks the same under the
+ * destination white.
+ *
+ * @param {Float64Array|number[]} out 9 elements, row-major
+ * @param {number} source_x chromaticity of the source white
+ * @param {number} source_y
+ * @param {number} destination_x chromaticity of the destination white
+ * @param {number} destination_y
+ * @see http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html
+ */
+export function m3_chromatic_adaptation_bradford(out: Float64Array | number[], source_x: number, source_y: number, destination_x: number, destination_y: number): void;
+//# sourceMappingURL=m3_chromatic_adaptation_bradford.d.ts.map

package/src/core/color/xyz/m3_chromatic_adaptation_bradford.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m3_chromatic_adaptation_bradford.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/xyz/m3_chromatic_adaptation_bradford.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH,sDAPW,YAAY,GAAC,MAAM,EAAE,YACrB,MAAM,YACN,MAAM,iBACN,MAAM,iBACN,MAAM,QAuBhB"}

package/src/core/color/xyz/m3_chromatic_adaptation_bradford.js

@@ -0,0 +1,51 @@
+import { m3_invert } from "../../geom/mat3/m3_invert.js";
+import { m3_multiply } from "../../geom/mat3/m3_multiply.js";
+
+/**
+ * Bradford cone response, XYZ to LMS. Row-major.
+ * @type {number[]}
+ */
+const BRADFORD = [
+    0.8951, 0.2664, -0.1614,
+    -0.7502, 1.7135, 0.0367,
+    0.0389, -0.0685, 1.0296,
+];
+
+const BRADFORD_INVERSE = new Float64Array(9);
+m3_invert(BRADFORD_INVERSE, BRADFORD);
+
+const scratch = new Float64Array(9);
+
+/**
+ * The von Kries adaptation in Bradford cone space that takes the `source` white to the `destination` white, as a
+ * matrix on CIE XYZ. Row-major. A colour seen under the source white maps to the colour that looks the same under the
+ * destination white.
+ *
+ * @param {Float64Array|number[]} out 9 elements, row-major
+ * @param {number} source_x chromaticity of the source white
+ * @param {number} source_y
+ * @param {number} destination_x chromaticity of the destination white
+ * @param {number} destination_y
+ * @see http://www.brucelindbloom.com/index.html?Eqn_ChromAdapt.html
+ */
+export function m3_chromatic_adaptation_bradford(out, source_x, source_y, destination_x, destination_y) {
+    // each white's cone response, at Y = 1
+    const sX = source_x / source_y;
+    const sZ = (1 - source_x - source_y) / source_y;
+    const dX = destination_x / destination_y;
+    const dZ = (1 - destination_x - destination_y) / destination_y;
+
+    for (let row = 0; row < 3; row++) {
+        const r0 = BRADFORD[row * 3];
+        const r1 = BRADFORD[row * 3 + 1];
+        const r2 = BRADFORD[row * 3 + 2];
+
+        const gain = (r0 * dX + r1 + r2 * dZ) / (r0 * sX + r1 + r2 * sZ);
+
+        scratch[row * 3] = r0 * gain;
+        scratch[row * 3 + 1] = r1 * gain;
+        scratch[row * 3 + 2] = r2 * gain;
+    }
+
+    m3_multiply(out, BRADFORD_INVERSE, scratch);
+}

package/src/core/math/linalg/eigen/matrix_symmetric_3x3_eigen.d.ts

@@ -4,7 +4,8 @@
  * Only the upper triangle of `m` is read (the matrix is assumed symmetric);
  * the input is not modified. Eigenpairs are emitted sorted by **ascending
  * eigenvalue**, so index 0 is the smallest — convenient for proxy-plane fits,
- * where the plane normal is the eigenvector of the smallest variance.
+ * where the plane normal is the eigenvector of the smallest variance. Equal
+ * eigenvalues keep their column order.
  *
  * Eigenvector sign is arbitrary (an eigenvector and its negation are both
  * valid); callers that need a consistent orientation must fix the sign

package/src/core/math/linalg/eigen/matrix_symmetric_3x3_eigen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix_symmetric_3x3_eigen.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_symmetric_3x3_eigen.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;;;GAgBG;AACH,uDALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAElC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QAuC5C"}
+{"version":3,"file":"matrix_symmetric_3x3_eigen.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_symmetric_3x3_eigen.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;GAiBG;AACH,uDALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAElC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QAqD5C"}

package/src/core/math/linalg/eigen/matrix_symmetric_3x3_eigen.js

@@ -1,3 +1,5 @@
+import { matrix_symmetric_jacobi_rotate_in_place } from "./matrix_symmetric_jacobi_rotate_in_place.js";
+
 /**
  * Maximum number of cyclic Jacobi sweeps. A symmetric 3x3 reaches full double
  * precision in ~5-6 sweeps (Jacobi converges quadratically); 50 is a generous
@@ -7,58 +9,22 @@
 const MAX_SWEEPS = 50;
 
 /**
- * One Jacobi rotation in the (p, q) plane that zeroes the off-diagonal entry
- * a[p][q]. `a` and `v` are 3x3 matrices stored row-major (index = row*3 + col).
- * `a` is the symmetric working matrix; `v` accumulates the rotations so its
- * columns become the eigenvectors.
- *
- * @param {number[]} a symmetric 3x3, mutated in place
- * @param {number[]} v 3x3 rotation accumulator, mutated in place
- * @param {number} p
- * @param {number} q
+ * Working copy of the input, row-major (index = row*3 + col).
+ * @type {Float64Array}
  */
-function jacobi_rotate(a, v, p, q) {
-    const apq = a[p * 3 + q];
-
-    if (apq === 0) {
-        return;
-    }
-
-    const app = a[p * 3 + p];
-    const aqq = a[q * 3 + q];
-
-    // tan of the rotation angle (Numerical Recipes form, |angle| <= pi/4).
-    const theta = (aqq - app) / (2 * apq);
-    const t = (theta >= 0)
-        ? 1 / (theta + Math.sqrt(theta * theta + 1))
-        : -1 / (-theta + Math.sqrt(theta * theta + 1));
-    const c = 1 / Math.sqrt(t * t + 1);
-    const s = t * c;
-
-    // The third (untouched) index.
-    const r = 3 - p - q;
-    const arp = a[r * 3 + p];
-    const arq = a[r * 3 + q];
+const scratch_a = new Float64Array(9);
 
-    a[p * 3 + p] = app - t * apq;
-    a[q * 3 + q] = aqq + t * apq;
-    a[p * 3 + q] = 0;
-    a[q * 3 + p] = 0;
-
-    const new_rp = c * arp - s * arq;
-    const new_rq = s * arp + c * arq;
-    a[r * 3 + p] = new_rp;
-    a[p * 3 + r] = new_rp;
-    a[r * 3 + q] = new_rq;
-    a[q * 3 + r] = new_rq;
+/**
+ * Rotation accumulator, row-major; its columns become the eigenvectors.
+ * @type {Float64Array}
+ */
+const scratch_v = new Float64Array(9);
 
-    for (let row = 0; row < 3; row++) {
-        const vrp = v[row * 3 + p];
-        const vrq = v[row * 3 + q];
-        v[row * 3 + p] = c * vrp - s * vrq;
-        v[row * 3 + q] = s * vrp + c * vrq;
-    }
-}
+/**
+ * Column index of each eigenpair, sorted by ascending eigenvalue.
+ * @type {Uint8Array}
+ */
+const scratch_order = new Uint8Array(3);
 
 /**
  * Eigendecomposition of a symmetric 3x3 matrix via cyclic Jacobi rotations.
@@ -66,7 +32,8 @@ function jacobi_rotate(a, v, p, q) {
  * Only the upper triangle of `m` is read (the matrix is assumed symmetric);
  * the input is not modified. Eigenpairs are emitted sorted by **ascending
  * eigenvalue**, so index 0 is the smallest — convenient for proxy-plane fits,
- * where the plane normal is the eigenvector of the smallest variance.
+ * where the plane normal is the eigenvector of the smallest variance. Equal
+ * eigenvalues keep their column order.
  *
  * Eigenvector sign is arbitrary (an eigenvector and its negation are both
  * valid); callers that need a consistent orientation must fix the sign
@@ -78,16 +45,19 @@ function jacobi_rotate(a, v, p, q) {
  * @param {Float64Array|Float32Array|number[]} m symmetric 3x3, row-major (index = row*3 + col)
  */
 export function matrix_symmetric_3x3_eigen(out_values, out_vectors, m) {
-    const a = [
-        m[0], m[1], m[2],
-        m[1], m[4], m[5],
-        m[2], m[5], m[8],
-    ];
-    const v = [
-        1, 0, 0,
-        0, 1, 0,
-        0, 0, 1,
-    ];
+    const a = scratch_a;
+    const v = scratch_v;
+
+    for (let row = 0; row < 3; row++) {
+        for (let col = row; col < 3; col++) {
+            const value = m[row * 3 + col];
+            a[row * 3 + col] = value;
+            a[col * 3 + row] = value;
+
+            v[row * 3 + col] = row === col ? 1 : 0;
+            v[col * 3 + row] = row === col ? 1 : 0;
+        }
+    }
 
     for (let sweep = 0; sweep < MAX_SWEEPS; sweep++) {
         const scale = Math.abs(a[0]) + Math.abs(a[4]) + Math.abs(a[8]);
@@ -97,21 +67,32 @@ export function matrix_symmetric_3x3_eigen(out_values, out_vectors, m) {
             break;
         }
 
-        jacobi_rotate(a, v, 0, 1);
-        jacobi_rotate(a, v, 0, 2);
-        jacobi_rotate(a, v, 1, 2);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 0, 1, 3);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 0, 2, 3);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 1, 2, 3);
     }
 
     // Eigenvalues live on the diagonal; eigenvector k is column k of V.
-    const eig = [a[0], a[4], a[8]];
-    const order = [0, 1, 2];
-    order.sort((i, j) => eig[i] - eig[j]);
+    // Stable insertion sort of the three column indices by eigenvalue.
+    const order = scratch_order;
+
+    for (let k = 0; k < 3; k++) {
+        const value = a[k * 4];
+        let slot = k;
+
+        while (slot > 0 && a[order[slot - 1] * 4] > value) {
+            order[slot] = order[slot - 1];
+            slot--;
+        }
+
+        order[slot] = k;
+    }
 
     for (let k = 0; k < 3; k++) {
         const col = order[k];
-        out_values[k] = eig[col];
-        out_vectors[k * 3 + 0] = v[0 * 3 + col];
-        out_vectors[k * 3 + 1] = v[1 * 3 + col];
-        out_vectors[k * 3 + 2] = v[2 * 3 + col];
+        out_values[k] = a[col * 4];
+        out_vectors[k * 3] = v[col];
+        out_vectors[k * 3 + 1] = v[3 + col];
+        out_vectors[k * 3 + 2] = v[6 + col];
     }
 }

package/src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix_symmetric_4x4_eigen.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uDALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAElC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QA0D5C"}
+{"version":3,"file":"matrix_symmetric_4x4_eigen.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uDALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAElC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QA0D5C"}

package/src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.js

@@ -1,3 +1,5 @@
+import { matrix_symmetric_jacobi_rotate_in_place } from "./matrix_symmetric_jacobi_rotate_in_place.js";
+
 /**
  * Maximum number of cyclic Jacobi sweeps. A symmetric 4x4 reaches full double
  * precision in 3-6 sweeps (Jacobi converges quadratically, whatever the gaps
@@ -26,64 +28,6 @@ const scratch_v = new Float64Array(16);
  */
 const scratch_order = new Uint8Array(4);
 
-/**
- * One Jacobi rotation in the (p, q) plane that zeroes the off-diagonal entry
- * a[p][q]. `a` and `v` are 4x4 matrices stored row-major (index = row*4 + col).
- * `a` is the symmetric working matrix; `v` accumulates the rotations so its
- * columns become the eigenvectors.
- *
- * @param {Float64Array} a symmetric 4x4, mutated in place
- * @param {Float64Array} v 4x4 rotation accumulator, mutated in place
- * @param {number} p
- * @param {number} q
- */
-function jacobi_rotate(a, v, p, q) {
-    const apq = a[p * 4 + q];
-
-    if (apq === 0) {
-        return;
-    }
-
-    const app = a[p * 4 + p];
-    const aqq = a[q * 4 + q];
-
-    // tan of the rotation angle (Numerical Recipes form, |angle| <= pi/4).
-    const theta = (aqq - app) / (2 * apq);
-    const t = (theta >= 0)
-        ? 1 / (theta + Math.sqrt(theta * theta + 1))
-        : -1 / (-theta + Math.sqrt(theta * theta + 1));
-    const c = 1 / Math.sqrt(t * t + 1);
-    const s = t * c;
-
-    a[p * 4 + p] = app - t * apq;
-    a[q * 4 + q] = aqq + t * apq;
-    a[p * 4 + q] = 0;
-    a[q * 4 + p] = 0;
-
-    for (let r = 0; r < 4; r++) {
-        if (r === p || r === q) {
-            continue;
-        }
-
-        const arp = a[r * 4 + p];
-        const arq = a[r * 4 + q];
-
-        const new_rp = c * arp - s * arq;
-        const new_rq = s * arp + c * arq;
-        a[r * 4 + p] = new_rp;
-        a[p * 4 + r] = new_rp;
-        a[r * 4 + q] = new_rq;
-        a[q * 4 + r] = new_rq;
-    }
-
-    for (let row = 0; row < 4; row++) {
-        const vrp = v[row * 4 + p];
-        const vrq = v[row * 4 + q];
-        v[row * 4 + p] = c * vrp - s * vrq;
-        v[row * 4 + q] = s * vrp + c * vrq;
-    }
-}
-
 /**
  * Eigendecomposition of a symmetric 4x4 matrix via cyclic Jacobi rotations.
  *
@@ -131,12 +75,12 @@ export function matrix_symmetric_4x4_eigen(out_values, out_vectors, m) {
             break;
         }
 
-        jacobi_rotate(a, v, 0, 1);
-        jacobi_rotate(a, v, 0, 2);
-        jacobi_rotate(a, v, 0, 3);
-        jacobi_rotate(a, v, 1, 2);
-        jacobi_rotate(a, v, 1, 3);
-        jacobi_rotate(a, v, 2, 3);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 0, 1, 4);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 0, 2, 4);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 0, 3, 4);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 1, 2, 4);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 1, 3, 4);
+        matrix_symmetric_jacobi_rotate_in_place(a, v, 2, 3, 4);
     }
 
     // Eigenvalues live on the diagonal; eigenvector k is column k of V.

package/src/core/math/linalg/eigen/matrix_symmetric_jacobi_rotate_in_place.d.ts

@@ -0,0 +1,17 @@
+/**
+ * One Jacobi rotation in the (p, q) plane that zeroes the off-diagonal entry
+ * a[p][q]. `a` and `v` are d x d matrices stored row-major (index = row*d + col).
+ * `a` is the symmetric working matrix; `v` accumulates the rotations so its
+ * columns become the eigenvectors.
+ *
+ * Callers pass `d` as a literal from an unrolled sweep, so the index arithmetic
+ * folds once this is inlined.
+ *
+ * @param {Float64Array|number[]} a symmetric d x d, mutated in place
+ * @param {Float64Array|number[]} v d x d rotation accumulator, mutated in place
+ * @param {number} p row of the entry to zero, p < q
+ * @param {number} q column of the entry to zero
+ * @param {number} d dimension of the square matrices
+ */
+export function matrix_symmetric_jacobi_rotate_in_place(a: Float64Array | number[], v: Float64Array | number[], p: number, q: number, d: number): void;
+//# sourceMappingURL=matrix_symmetric_jacobi_rotate_in_place.d.ts.map

package/src/core/math/linalg/eigen/matrix_symmetric_jacobi_rotate_in_place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_symmetric_jacobi_rotate_in_place.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_symmetric_jacobi_rotate_in_place.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,2DANW,YAAY,GAAC,MAAM,EAAE,KACrB,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,QAkDhB"}

package/src/core/math/linalg/eigen/matrix_symmetric_jacobi_rotate_in_place.js

@@ -0,0 +1,64 @@
+/**
+ * One Jacobi rotation in the (p, q) plane that zeroes the off-diagonal entry
+ * a[p][q]. `a` and `v` are d x d matrices stored row-major (index = row*d + col).
+ * `a` is the symmetric working matrix; `v` accumulates the rotations so its
+ * columns become the eigenvectors.
+ *
+ * Callers pass `d` as a literal from an unrolled sweep, so the index arithmetic
+ * folds once this is inlined.
+ *
+ * @param {Float64Array|number[]} a symmetric d x d, mutated in place
+ * @param {Float64Array|number[]} v d x d rotation accumulator, mutated in place
+ * @param {number} p row of the entry to zero, p < q
+ * @param {number} q column of the entry to zero
+ * @param {number} d dimension of the square matrices
+ */
+export function matrix_symmetric_jacobi_rotate_in_place(a, v, p, q, d) {
+    const pd = p * d;
+    const qd = q * d;
+    const apq = a[pd + q];
+
+    if (apq === 0) {
+        return;
+    }
+
+    const app = a[pd + p];
+    const aqq = a[qd + q];
+
+    // tan of the rotation angle (Numerical Recipes form, |angle| <= pi/4).
+    const theta = (aqq - app) / (2 * apq);
+    const t = (theta >= 0)
+        ? 1 / (theta + Math.sqrt(theta * theta + 1))
+        : -1 / (-theta + Math.sqrt(theta * theta + 1));
+    const c = 1 / Math.sqrt(t * t + 1);
+    const s = t * c;
+
+    a[pd + p] = app - t * apq;
+    a[qd + q] = aqq + t * apq;
+    a[pd + q] = 0;
+    a[qd + p] = 0;
+
+    for (let r = 0; r < d; r++) {
+        if (r === p || r === q) {
+            continue;
+        }
+
+        const rd = r * d;
+        const arp = a[rd + p];
+        const arq = a[rd + q];
+
+        const new_rp = c * arp - s * arq;
+        const new_rq = s * arp + c * arq;
+        a[rd + p] = new_rp;
+        a[pd + r] = new_rp;
+        a[rd + q] = new_rq;
+        a[qd + r] = new_rq;
+    }
+
+    for (let rd = 0; rd < d * d; rd += d) {
+        const vrp = v[rd + p];
+        const vrq = v[rd + q];
+        v[rd + p] = c * vrp - s * vrq;
+        v[rd + q] = s * vrp + c * vrq;
+    }
+}

package/src/core/math/linalg/solve_box_constrained_qp.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Solve the bound-constrained quadratic program
+ *
+ *     minimise  ½·xᵀ·A·x − bᵀ·x   subject to   lo ≤ x ≤ hi
+ *
+ * for a symmetric positive-definite `A`; equivalently the box LCP: `x` within `[lo, hi]` where
+ * `w = A·x − b` is zero for every `x_i` strictly between its bounds, non-negative where `x_i = lo_i`
+ * and non-positive where `x_i = hi_i`. The solution is unique.
+ *
+ * Primal active-set method (Nocedal & Wright, *Numerical Optimization*, 2nd ed., §16.5). It starts
+ * from the point of the box nearest the origin, with every variable free. Each pass solves for the
+ * free variables with the held ones at their bounds, and steps toward that solution as far as the box
+ * allows; a variable that cuts the step short is held at the bound it reached. A full step is the
+ * minimum over the variables currently free: then the held variable whose `w` has the wrong sign by
+ * the most is freed, or, when none has, `x` is the solution. The objective falls from each such
+ * minimum to the next, so no set of held variables repeats and the search ends; it also ends where
+ * rounding stops the objective falling. When no bound is reached it is one factorisation of `A`.
+ *
+ * @param {ArrayLike<number>} A n×n, column-major (`A[j·n + i]` is row `i`, column `j`); being symmetric,
+ *   row-major reads the same. Not modified.
+ * @param {ArrayLike<number>} b length n
+ * @param {ArrayLike<number>} lo lower bounds, length n; `-Infinity` where there is none
+ * @param {ArrayLike<number>} hi upper bounds, length n, none below its `lo`; `Infinity` where there is none
+ * @param {Float64Array|number[]} x receives the solution, length n
+ * @param {number} n
+ * @returns {boolean} true when solved; false when `A` did not factor as positive definite, `x` then
+ *   holding the last point reached, within the bounds
+ */
+export function solve_box_constrained_qp(A: ArrayLike<number>, b: ArrayLike<number>, lo: ArrayLike<number>, hi: ArrayLike<number>, x: Float64Array | number[], n: number): boolean;
+//# sourceMappingURL=solve_box_constrained_qp.d.ts.map

package/src/core/math/linalg/solve_box_constrained_qp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve_box_constrained_qp.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/solve_box_constrained_qp.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAVW,UAAU,MAAM,CAAC,KAEjB,UAAU,MAAM,CAAC,MACjB,UAAU,MAAM,CAAC,MACjB,UAAU,MAAM,CAAC,KACjB,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,GACJ,OAAO,CAkKnB"}