@use-gpu/math 0.0.0-stage → 0.21.0

package/cjs/matrix.cjs

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Matrix", {
+    enumerable: true,
+    get: function() {
+        return Matrix;
+    }
+});
+const _number = require("./number.cjs");
+const { sqrt } = Math;
+// Get matrix dimensions
+const dims = (m)=>[
+        m.length,
+        m[0].length
+    ];
+const size = ([a, b])=>`${a}x${b}`;
+// Fill an NxM matrix using a given expression
+const fill = (n, m, f = ()=>0)=>{
+    const out = [];
+    for(let j = 0; j < n; ++j){
+        const row = [];
+        for(let i = 0; i < m; ++i){
+            row[i] = f(i, j);
+        }
+        out.push(row);
+    }
+    return out;
+};
+// Identity matrix
+const identity = (n)=>fill(n, n, (i, j)=>+(i == j));
+// Add two matrices
+const add = (a, b)=>{
+    const [na, ma] = dims(a);
+    const [nb, mb] = dims(b);
+    if (ma !== mb || na !== nb) {
+        console.error("Incompatible matrices", a, b, size(dims(a)), size(dims(b)));
+        throw new Error("Matrix error");
+    }
+    return fill(na, ma, (i, j)=>a[j][i] + b[j][i]);
+};
+// Subtract two matrices
+const sub = (a, b)=>{
+    const [na, ma] = dims(a);
+    const [nb, mb] = dims(b);
+    if (ma !== mb || na !== nb) {
+        console.error("Incompatible matrices", a, b, size(dims(a)), size(dims(b)));
+        throw new Error("Matrix error");
+    }
+    return fill(na, ma, (i, j)=>a[j][i] - b[j][i]);
+};
+// Scale matrix by a scalar
+const muls = (a, s)=>{
+    const [na, ma] = dims(a);
+    return fill(na, ma, (i, j)=>a[j][i] * s);
+};
+// Multiply two matrices
+const mul = (a, b)=>{
+    const [na, ma] = dims(a);
+    const [nb, mb] = dims(b);
+    if (ma !== nb) {
+        console.error("Incompatible matrices", a, b, size(dims(a)), size(dims(b)));
+        throw new Error("Matrix error");
+    }
+    return fill(na, mb, (i, j)=>{
+        let v = 0;
+        for(let k = 0; k < ma; ++k)v += a[j][k] * b[k][i];
+        return v;
+    });
+};
+// Multiply two matrices while transposing the second
+const tmul = (a, b)=>{
+    const [na, ma] = dims(a);
+    const [nb, mb] = dims(b);
+    if (ma !== mb) {
+        console.error("Incompatible matrices", a, b, size(dims(a)), size(dims(b)));
+        throw new Error("Matrix error");
+    }
+    return fill(na, nb, (i, j)=>{
+        let v = 0;
+        for(let k = 0; k < ma; ++k)v += a[j][k] * b[i][k];
+        return v;
+    });
+};
+// Transpose a matrix
+const transpose = (x)=>{
+    const [n, m] = dims(x);
+    return fill(m, n, (i, j)=>x[i][j]);
+};
+// Concatenate two matrices horizontally
+const concat = (a, b)=>{
+    const [na] = dims(a);
+    const nb = b.length;
+    if (na !== nb) {
+        console.error("Incompatible matrices", a, b, size(dims(a)), nb);
+        throw "Matrix error";
+    }
+    return a.map((_, i)=>a[i].concat(b[i]));
+};
+// Extract a submatrix from index (a,b) to (c,d) exclusive
+const slice = (M, a, b, c, d)=>{
+    const [n, m] = dims(M);
+    a = Math.min(a, m);
+    b = Math.min(b, n);
+    if (c === undefined) c = m;
+    if (d === undefined) d = n;
+    c = Math.max(a, Math.min(m, c < 0 ? m + c : c));
+    d = Math.max(b, Math.min(n, d < 0 ? n + d : d));
+    return fill(d - b, c - a, (i, j)=>M[j][i]);
+};
+// Get matrix rank
+const rank = (A)=>{
+    const G = jordanNormal(A);
+    return diagonalRank(G);
+};
+// Calculate frobenius norm squared
+const norm2 = (x)=>{
+    const [n, m] = dims(x);
+    let v = 0;
+    for(let j = 0; j < m; ++j){
+        for(let i = 0; i < n; ++i){
+            v += (0, _number.sqr)(x[j][i]);
+        }
+    }
+    return v;
+};
+// Calculate frobenius norm
+const norm = (x)=>sqrt(norm2(x));
+// Swap a later row to make (i,j) non-zero
+const swapZero = (x, i, j)=>{
+    const [n] = dims(x);
+    for(let k = j + 1; k < n; ++k){
+        if (x[k][i] !== 0) {
+            [x[k], x[j]] = [
+                x[j],
+                x[k]
+            ];
+            return true;
+        }
+    }
+    return false;
+};
+// In-place vector ops to spare the GC
+// Scale a row by a constant
+const scaleRow = (a, s)=>{
+    const { length } = a;
+    for(let i = 0; i < length; ++i)a[i] *= s;
+};
+// Multiply and add one row to another
+const madRow = (a, b, s)=>{
+    const { length } = a;
+    for(let i = 0; i < length; ++i)a[i] += b[i] * s;
+};
+// Get determinant
+const determinant = (x)=>{
+    const [n, m] = dims(x);
+    let offset = 0;
+    x = structuredClone(x);
+    let det = 1;
+    for(let i = 0; i < Math.min(n, m); ++i){
+        // Find next pivot element
+        const pivot = x[i][i + offset];
+        if (pivot == 0) {
+            // Unsuitable, find other row to swap with
+            if (!swapZero(x, i + offset, i)) {
+                // All zeros, move one column over until out of bounds
+                if (offset++ >= m - n) {
+                    return 0;
+                }
+            }
+            // Repeat iteration
+            i--;
+            continue;
+        }
+        // Scale pivot row
+        scaleRow(x[i], 1 / pivot);
+        det *= pivot;
+        // Subtract from other rows
+        for(let j = 0; j < n; ++j)if (i !== j) {
+            const pivot = x[j][i + offset];
+            madRow(x[j], x[i], -pivot);
+        }
+    }
+    return det;
+};
+// Convert matrix into jordan normal form if possible
+const jordanNormal = (x)=>{
+    const [n, m] = dims(x);
+    let offset = 0;
+    // Don't modify argument
+    x = structuredClone(x);
+    for(let i = 0; i < Math.min(n, m); ++i){
+        // Find next pivot element
+        const pivot = x[i][i + offset];
+        if (pivot == 0) {
+            // Unsuitable, find other row to swap with
+            if (!swapZero(x, i + offset, i)) {
+                // All zeros, move one column over until out of bounds
+                if (offset++ >= m - n) {
+                    return x;
+                }
+            }
+            // Repeat iteration
+            i--;
+            continue;
+        }
+        // Scale pivot row
+        scaleRow(x[i], 1 / pivot);
+        // Subtract from other rows
+        for(let j = 0; j < n; ++j)if (i !== j) {
+            const pivot = x[j][i + offset];
+            madRow(x[j], x[i], -pivot);
+        }
+    }
+    return x;
+};
+// Verify if matrix has uninterrupted non-zero diagonal
+const diagonalRank = (x)=>{
+    const [n, m] = dims(x);
+    const l = Math.min(n, m);
+    let i = 0;
+    for(; i < l; ++i){
+        if (x[i][i] == 0) break;
+    }
+    return i;
+};
+const Matrix = {
+    dims,
+    fill,
+    identity,
+    add,
+    sub,
+    mul,
+    muls,
+    tmul,
+    transpose,
+    concat,
+    slice,
+    rank,
+    norm,
+    norm2,
+    determinant,
+    jordanNormal
+};
+
+//# sourceMappingURL=matrix.js.map

package/cjs/matrix.d.cts

@@ -0,0 +1,18 @@
+export declare const Matrix: {
+    dims: (m: number[][]) => number[];
+    fill: (n: number, m: number, f?: (i: number, j: number) => number) => number[][];
+    identity: (n: number) => number[][];
+    add: (a: number[][], b: number[][]) => number[][];
+    sub: (a: number[][], b: number[][]) => number[][];
+    mul: (a: number[][], b: number[][]) => number[][];
+    muls: (a: number[][], s: number) => number[][];
+    tmul: (a: number[][], b: number[][]) => number[][];
+    transpose: (x: number[][]) => number[][];
+    concat: (a: number[][], b: number[] | number[][]) => number[][];
+    slice: (M: number[][], a: number, b: number, c: number, d: number) => number[][];
+    rank: (A: number[][]) => number;
+    norm: (x: number[][]) => number;
+    norm2: (x: number[][]) => number;
+    determinant: (x: number[][]) => number;
+    jordanNormal: (x: number[][]) => number[][];
+};

package/cjs/matrix.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/matrix.ts"],"sourcesContent":["import { sqr } from './number';\n\nconst { sqrt } = Math;\n\n// Get matrix dimensions\nconst dims = (m: number[][]) => [m.length, m[0].length];\nconst size = ([a, b]: number[]) => `${a}x${b}`;\n\n// Fill an NxM matrix using a given expression\nconst fill = (n: number, m: number, f: (i: number, j: number) => number = () => 0) => {\n  const out = [];\n  for (let j = 0; j < n; ++j) {\n    const row = [];\n    for (let i = 0; i < m; ++i) {\n      row[i] = f(i, j);\n    }\n    out.push(row);\n  }\n  return out;\n}\n\n// Identity matrix\nconst identity = (n: number) => fill(n, n, (i, j) => +(i == j));\n\n// Add two matrices\nconst add = (a: number[][], b: number[][]) => {\n  const [na, ma] = dims(a);\n  const [nb, mb] = dims(b);\n  if (ma !== mb || na !== nb) {\n    console.error(\"Incompatible matrices\", a, b, size(dims(a)), size(dims(b)));\n    throw new Error(\"Matrix error\");\n  }\n  return fill(na, ma, (i, j) => a[j][i] + b[j][i]);\n}\n\n// Subtract two matrices\nconst sub = (a: number[][], b: number[][]) => {\n  const [na, ma] = dims(a);\n  const [nb, mb] = dims(b);\n  if (ma !== mb || na !== nb) {\n    console.error(\"Incompatible matrices\", a, b, size(dims(a)), size(dims(b)));\n    throw new Error(\"Matrix error\");\n  }\n  return fill(na, ma, (i, j) => a[j][i] - b[j][i]);\n}\n\n// Scale matrix by a scalar\nconst muls = (a: number[][], s: number) => {\n  const [na, ma] = dims(a);\n  return fill(na, ma, (i, j) => a[j][i] * s);\n}\n\n// Multiply two matrices\nconst mul = (a: number[][], b: number[][]) => {\n  const [na, ma] = dims(a);\n  const [nb, mb] = dims(b);\n  if (ma !== nb) {\n    console.error(\"Incompatible matrices\", a, b, size(dims(a)), size(dims(b)));\n    throw new Error(\"Matrix error\");\n  }\n  return fill(na, mb, (i, j) => {\n    let v = 0;\n    for (let k = 0; k < ma; ++k) v += a[j][k] * b[k][i];\n    return v;\n  });\n}\n\n// Multiply two matrices while transposing the second\nconst tmul = (a: number[][], b: number[][]) => {\n  const [na, ma] = dims(a);\n  const [nb, mb] = dims(b);\n  if (ma !== mb) {\n    console.error(\"Incompatible matrices\", a, b, size(dims(a)), size(dims(b)));\n    throw new Error(\"Matrix error\");\n  }\n  return fill(na, nb, (i, j) => {\n    let v = 0;\n    for (let k = 0; k < ma; ++k) v += a[j][k] * b[i][k];\n    return v;\n  });\n}\n\n// Transpose a matrix\nconst transpose = (x: number[][]) => {\n  const [n, m] = dims(x);\n  return fill(m, n, (i, j) => x[i][j]);\n}\n\n// Concatenate two matrices horizontally\nconst concat = (a: number[][], b: number[] | number[][]) => {\n  const [na] = dims(a);\n  const nb = b.length;\n  if (na !== nb) {\n    console.error(\"Incompatible matrices\", a, b, size(dims(a)), nb);\n    throw \"Matrix error\";\n  }\n  return a.map((_,i) => a[i].concat(b[i]));\n}\n\n// Extract a submatrix from index (a,b) to (c,d) exclusive\nconst slice = (M: number[][], a: number, b: number, c: number, d: number) => {\n  const [n, m] = dims(M);\n\n  a = Math.min(a, m);\n  b = Math.min(b, n);\n\n  if (c === undefined) c = m;\n  if (d === undefined) d = n;\n\n  c = Math.max(a, Math.min(m, c < 0 ? m + c : c));\n  d = Math.max(b, Math.min(n, d < 0 ? n + d : d));\n\n  return fill(d - b, c - a, (i, j) => M[j][i]);\n}\n\n// Get matrix rank\nconst rank = (A: number[][]) => {\n  const G = jordanNormal(A);\n  return diagonalRank(G);\n}\n\n// Calculate frobenius norm squared\nconst norm2 = (x: number[][]) => {\n  const [n, m] = dims(x);\n\n  let v = 0;\n  for (let j = 0; j < m; ++j) {\n    for (let i = 0; i < n; ++i) {\n      v += sqr(x[j][i]);\n    }\n  }\n  return v;\n};\n\n// Calculate frobenius norm\nconst norm = (x: number[][]) => sqrt(norm2(x));\n\n// Swap a later row to make (i,j) non-zero\nconst swapZero = (x: number[][], i: number, j: number) => {\n  const [n] = dims(x);\n  for (let k = j + 1; k < n; ++k) {\n    if (x[k][i] !== 0) {\n      [x[k], x[j]] = [x[j], x[k]];\n      return true;\n    }\n  }\n  return false;\n}\n\n// In-place vector ops to spare the GC\n\n// Scale a row by a constant\nconst scaleRow = (a: number[], s: number) => {\n  const {length} = a;\n  for (let i = 0; i < length; ++i) a[i] *= s;\n}\n\n// Multiply and add one row to another\nconst madRow = (a: number[], b: number[], s: number) => {\n  const {length} = a;\n  for (let i = 0; i < length; ++i) a[i] += b[i] * s;\n}\n\n// Get determinant\nconst determinant = (x: number[][]) => {\n  const [n, m] = dims(x);\n  let offset = 0;\n\n  x = structuredClone(x);\n\n  let det = 1;\n\n  for (let i = 0; i < Math.min(n, m); ++i) {\n    // Find next pivot element\n    const pivot = x[i][i + offset];\n\n    if (pivot == 0) {\n      // Unsuitable, find other row to swap with\n      if (!swapZero(x, i + offset, i)) {\n\n        // All zeros, move one column over until out of bounds\n        if (offset++ >= (m - n)) {\n          return 0;\n        }\n      }\n\n      // Repeat iteration\n      i--;\n      continue;\n    }\n\n    // Scale pivot row\n    scaleRow(x[i], 1 / pivot);\n\n    det *= pivot;\n\n    // Subtract from other rows\n    for (let j = 0; j < n; ++j) if (i !== j) {\n      const pivot = x[j][i + offset];\n      madRow(x[j], x[i], -pivot);\n    }\n  }\n\n  return det;\n}\n\n// Convert matrix into jordan normal form if possible\nconst jordanNormal = (x: number[][]) => {\n  const [n, m] = dims(x);\n  let offset = 0;\n\n  // Don't modify argument\n  x = structuredClone(x);\n\n  for (let i = 0; i < Math.min(n, m); ++i) {\n    // Find next pivot element\n    const pivot = x[i][i + offset];\n\n    if (pivot == 0) {\n      // Unsuitable, find other row to swap with\n      if (!swapZero(x, i + offset, i)) {\n\n        // All zeros, move one column over until out of bounds\n        if (offset++ >= (m - n)) {\n          return x;\n        }\n      }\n\n      // Repeat iteration\n      i--;\n      continue;\n    }\n\n    // Scale pivot row\n    scaleRow(x[i], 1 / pivot);\n\n    // Subtract from other rows\n    for (let j = 0; j < n; ++j) if (i !== j) {\n      const pivot = x[j][i + offset];\n      madRow(x[j], x[i], -pivot);\n    }\n  }\n  return x;\n}\n\n// Verify if matrix has uninterrupted non-zero diagonal\nconst diagonalRank = (x: number[][]) => {\n  const [n, m] = dims(x);\n  const l = Math.min(n, m);\n\n  let i = 0;\n  for (; i < l; ++i) {\n    if (x[i][i] == 0) break;\n  }\n  return i;\n}\n\nexport const Matrix = {\n  dims,\n  fill,\n  identity,\n  add,\n  sub,\n  mul,\n  muls,\n  tmul,\n  transpose,\n  concat,\n  slice,\n  rank,\n  norm,\n  norm2,\n  determinant,\n  jordanNormal,\n};\n"],"names":["Matrix","sqrt","Math","dims","m","length","size","a","b","fill","n","f","out","j","row","i","push","identity","add","na","ma","nb","mb","console","error","Error","sub","muls","s","mul","v","k","tmul","transpose","x","concat","map","_","slice","M","c","d","min","undefined","max","rank","A","G","jordanNormal","diagonalRank","norm2","sqr","norm","swapZero","scaleRow","madRow","determinant","offset","structuredClone","det","pivot","l"],"mappings":"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"}

package/cjs/number.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get clamp () {
+        return clamp;
+    },
+    get clerp () {
+        return clerp;
+    },
+    get cub () {
+        return cub;
+    },
+    get lerp () {
+        return lerp;
+    },
+    get seq () {
+        return seq;
+    },
+    get sqr () {
+        return sqr;
+    },
+    get π () {
+        return π;
+    },
+    get τ () {
+        return τ;
+    }
+});
+const { max, min } = Math;
+const π = Math.PI;
+const τ = 2 * π;
+const clamp = (x, a, b)=>max(a, min(b, x));
+const cub = (x)=>x * x * x;
+const sqr = (x)=>x * x;
+const lerp = (a, b, t)=>a * (1 - t) + b * t;
+const clerp = (a, b, t)=>{
+    const d = (b - a + π) / τ % 1 * τ - π;
+    return lerp(a, a + d, t);
+};
+const seq = (n, start = 0, step = 1)=>Array.from({
+        length: n
+    }).map((_, i)=>start + i * step);
+
+//# sourceMappingURL=number.js.map

package/cjs/number.d.cts

@@ -0,0 +1,13 @@
+export type XY = [number, number];
+export type XYZ = [number, number, number];
+export type XYZW = [number, number, number, number];
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;
+export type VectorLike = TypedArray | number[];
+export declare const π: number;
+export declare const τ: number;
+export declare const clamp: (x: number, a: number, b: number) => number;
+export declare const cub: (x: number) => number;
+export declare const sqr: (x: number) => number;
+export declare const lerp: (a: number, b: number, t: number) => number;
+export declare const clerp: (a: number, b: number, t: number) => number;
+export declare const seq: (n: number, start?: number, step?: number) => number[];

package/cjs/number.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/number.ts"],"sourcesContent":["export type XY = [number, number];\nexport type XYZ = [number, number, number];\nexport type XYZW = [number, number, number, number];\n\nexport type TypedArray =\n  Int8Array |\n  Uint8Array |\n  Int16Array |\n  Uint16Array |\n  Int32Array |\n  Uint32Array |\n  Uint8ClampedArray |\n  //Float16Array |\n  Float32Array |\n  Float64Array;\n\nexport type VectorLike = TypedArray | number[];\n\nconst { max, min } = Math;\n\nexport const π = Math.PI;\nexport const τ = 2*π;\n\nexport const clamp = (x: number, a: number, b: number) => max(a, min(b, x));\n\nexport const cub = (x: number) => x * x * x;\nexport const sqr = (x: number) => x * x;\n\nexport const lerp = (a: number, b: number, t: number) => a * (1 - t) + b * t;\nexport const clerp = (a: number, b: number, t: number) => {\n  const d = (((b - a + π) / τ) % 1) * τ - π;\n  return lerp(a, a + d, t);\n};\n\nexport const seq = (n: number, start: number = 0, step: number = 1) => Array.from({length: n}).map((_, i) => start + i * step);\n"],"names":["clamp","clerp","cub","lerp","seq","sqr","π","τ","max","min","Math","PI","x","a","b","t","d","n","start","step","Array","from","length","map","_","i"],"mappings":";;;;;;;;;;;QAuBaA;eAAAA;;QAMAC;eAAAA;;QAJAC;eAAAA;;QAGAC;eAAAA;;QAMAC;eAAAA;;QARAC;eAAAA;;QANAC;eAAAA;;QACAC;eAAAA;;;AAHb,MAAM,EAAEC,GAAG,EAAEC,GAAG,EAAE,GAAGC;AAEd,MAAMJ,IAAII,KAAKC,EAAE;AACjB,MAAMJ,IAAI,IAAED;AAEZ,MAAMN,QAAQ,CAACY,GAAWC,GAAWC,IAAcN,IAAIK,GAAGJ,IAAIK,GAAGF;AAEjE,MAAMV,MAAM,CAACU,IAAcA,IAAIA,IAAIA;AACnC,MAAMP,MAAM,CAACO,IAAcA,IAAIA;AAE/B,MAAMT,OAAO,CAACU,GAAWC,GAAWC,IAAcF,IAAK,CAAA,IAAIE,CAAAA,IAAKD,IAAIC;AACpE,MAAMd,QAAQ,CAACY,GAAWC,GAAWC;IAC1C,MAAMC,IAAI,AAAGF,CAAAA,IAAID,IAAIP,CAAA,IAAKC,IAAK,IAAKA,IAAID;IACxC,OAAOH,KAAKU,GAAGA,IAAIG,GAAGD;AACxB;AAEO,MAAMX,MAAM,CAACa,GAAWC,QAAgB,CAAC,EAAEC,OAAe,CAAC,GAAKC,MAAMC,IAAI,CAAC;QAACC,QAAQL;IAAC,GAAGM,GAAG,CAAC,CAACC,GAAGC,IAAMP,QAAQO,IAAIN"}

package/cjs/polynomial.cjs

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get solveCubic () {
+        return solveCubic;
+    },
+    get solveDepressedCubic () {
+        return solveDepressedCubic;
+    },
+    get solveDepressedQuartic () {
+        return solveDepressedQuartic;
+    },
+    get solveQuadratic () {
+        return solveQuadratic;
+    },
+    get solveQuartic () {
+        return solveQuartic;
+    }
+});
+const _number = require("./number.cjs");
+const { acos, cbrt, cos, sign, sqrt } = Math;
+const solveQuadratic = (a, b, c)=>{
+    const d = b * b - 4 * a * c;
+    if (d < 0) return [];
+    if (d === 0) return [
+        -b / (2 * a)
+    ];
+    const x1 = (-b - sqrt(d)) / (2 * a);
+    const x2 = (-b + sqrt(d)) / (2 * a);
+    return [
+        x1,
+        x2
+    ];
+};
+const solveCubic = (a, b, c, d)=>{
+    const o = -b / (3 * a);
+    const p = (3 * a * c - b * b) / (3 * a * a);
+    const q = (2 * b * b * b - 9 * a * b * c + 27 * a * a * d) / (27 * a * a * a);
+    return solveDepressedCubic(p, q).map((x)=>x + o);
+};
+const solveDepressedCubic = (p, q)=>{
+    const p_3 = p / 3;
+    const q_2 = q / 2;
+    const p3_27 = (0, _number.cub)(p_3);
+    const ds = p3_27 + (0, _number.sqr)(q_2);
+    if (ds === 0) {
+        // Multiple root
+        if (p) {
+            // Double root
+            const r1 = q / p_3;
+            const r2 = -q_2 / p_3;
+            return [
+                r1,
+                r2
+            ];
+        } else {
+            return [
+                0
+            ];
+        }
+    } else if (ds > 0) {
+        // Single real root
+        // Vieta's substitution. Pick matching sign for better precision.
+        const w = -q_2 - sqrt(ds) * sign(q);
+        const cw = cbrt(w);
+        return [
+            cw - p_3 / cw
+        ];
+    } else {
+        // Three distinct real roots
+        // Imaginary sqrt(ds)
+        const dp = sqrt(-p3_27);
+        const theta = acos(-q_2 / dp) / 3;
+        const cw = cbrt(dp);
+        const r = cw - p_3 / cw;
+        const rs = [];
+        for(let i = 0; i < 3; ++i){
+            const cc = cos(theta - i * (2 / 3) * _number.π);
+            const v = cc * r;
+            rs.push(v);
+        }
+        return rs;
+    }
+};
+const solveQuartic = (a, b, c, d, e)=>{
+    const o = -b / (4 * a);
+    const aa = -3 * (0, _number.sqr)(b) / (8 * (0, _number.sqr)(a)) + c / a;
+    const bb = (0, _number.cub)(b) / (8 * (0, _number.cub)(a)) - b * c / (2 * (0, _number.sqr)(a)) + d / a;
+    const cc = -3 * (0, _number.sqr)((0, _number.sqr)(b)) / (256 * (0, _number.sqr)((0, _number.sqr)(a))) + c * (0, _number.sqr)(b) / (16 * (0, _number.cub)(a)) - b * d / (4 * (0, _number.sqr)(a)) + e / a;
+    if (bb === 0) {
+        // Biquadratic case
+        const q = solveQuadratic(1, aa, cc);
+        if (!q.length) return q;
+        const solutions = [];
+        const [q1, q2] = q;
+        if (q1 > 0) {
+            solutions.push(sqrt(q1) + o);
+            solutions.push(-sqrt(q1) + o);
+        }
+        if (q2 > 0) {
+            solutions.push(sqrt(q2) + o);
+            solutions.push(-sqrt(q2) + o);
+        }
+        if (q1 === 0) {
+            solutions.push(o);
+        }
+        if (q2 === 0) {
+            solutions.push(o);
+        }
+        return solutions;
+    }
+    // Quartic case
+    return solveDepressedQuartic(aa, bb, cc).map((x)=>x + o);
+};
+const solveDepressedQuartic = (a, b, c)=>{
+    const p = -(0, _number.sqr)(a) / 12 - c;
+    const q = -(0, _number.cub)(a) / 108 + a * c / 3 - (0, _number.sqr)(b) / 8;
+    const q_2 = q / 2;
+    const p_3 = p / 3;
+    const p3_27 = (0, _number.cub)(p_3);
+    const ds = p3_27 + (0, _number.sqr)(q_2);
+    const solutions = [];
+    let y = -Infinity;
+    if (ds >= 0) {
+        // Real R
+        const r = -q_2 - sqrt(ds) * sign(ds);
+        const u = cbrt(r);
+        y = -5 / 6 * a + (u ? u - p / (3 * u) : -cbrt(q));
+    } else {
+        // Complex R
+        const dp = sqrt(-p3_27);
+        const theta = acos(-q_2 / dp) / 3;
+        const ct = cos(theta);
+        const ul = cbrt(dp);
+        // U - P/(3U) is always real
+        y = -5 / 6 * a + (ul ? ct * (ul - p_3 / ul) : -cbrt(q));
+    }
+    const w2 = a + 2 * y;
+    const w = sqrt(w2);
+    if (w2 < 0) {
+        return solutions;
+    }
+    const qw1 = -(3 * a + 2 * y + 2 * b / w);
+    const qw2 = -(3 * a + 2 * y - 2 * b / w);
+    if (qw1 > 0) {
+        const t1 = (w + sqrt(qw1)) / 2;
+        const t2 = (w - sqrt(qw1)) / 2;
+        solutions.push(t1, t2);
+    }
+    if (qw1 === 0) {
+        solutions.push(w / 2);
+    }
+    if (qw2 > 0) {
+        const t3 = (-w + sqrt(qw2)) / 2;
+        const t4 = (-w - sqrt(qw2)) / 2;
+        if (!solutions.includes(t3)) solutions.push(t3);
+        if (!solutions.includes(t4)) solutions.push(t4);
+    }
+    if (qw2 === 0) {
+        const t = -w / 2;
+        if (!solutions.includes(t)) solutions.push(t);
+    }
+    return solutions;
+};
+
+//# sourceMappingURL=polynomial.js.map

package/cjs/polynomial.d.cts

@@ -0,0 +1,5 @@
+export declare const solveQuadratic: (a: number, b: number, c: number) => number[];
+export declare const solveCubic: (a: number, b: number, c: number, d: number) => number[];
+export declare const solveDepressedCubic: (p: number, q: number) => number[];
+export declare const solveQuartic: (a: number, b: number, c: number, d: number, e: number) => number[];
+export declare const solveDepressedQuartic: (a: number, b: number, c: number) => number[];

package/cjs/polynomial.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/polynomial.ts"],"sourcesContent":["import { π, sqr, cub } from './number';\n\nconst { acos, cbrt, cos, sign, sqrt } = Math;\n\n// Solve a quadratic a*x^2 + b*x + c = 0\nexport const solveQuadratic = (a: number, b: number, c: number): number[] => {\n  const d = b*b - 4*a*c;\n  if (d < 0) return [];\n  if (d === 0) return [-b / (2*a)];\n\n  const x1 = (-b - sqrt(d)) / (2*a);\n  const x2 = (-b + sqrt(d)) / (2*a);\n  return [x1, x2];\n}\n\n// Solve a cubic a*x^3 + b*x^2 + c*x + d = 0\nexport const solveCubic = (a: number, b: number, c: number, d: number): number[] => {\n  const o = -b / (3 * a);\n  const p = (3 * a * c - b * b) / (3 * a * a);\n  const q = (2 * b * b * b - 9 * a * b * c + 27 * a * a * d) / (27 * a * a * a);\n  \n  return solveDepressedCubic(p, q).map(x => x + o);\n};\n\n// Solve a depressed cubic t^3 + p*t + q = 0\nexport const solveDepressedCubic = (p: number, q: number): number[] => {\n  const p_3 = p / 3;\n  const q_2 = q / 2;\n\n  const p3_27 = cub(p_3);\n  const ds = p3_27 + sqr(q_2);\n\n  if (ds === 0) {\n    // Multiple root\n    if (p) {\n      // Double root\n      const r1 = q / p_3;\n      const r2 = -q_2 / p_3;\n      return [r1, r2];\n    }\n    // Triple root\n    else {\n      return [0];\n    }\n  }\n  else if (ds > 0) {\n    // Single real root\n    // Vieta's substitution. Pick matching sign for better precision.\n    const w = -q_2 - sqrt(ds) * sign(q);\n    const cw = cbrt(w);\n    return [cw - p_3 / cw];\n  }\n  else {\n    // Three distinct real roots\n    // Imaginary sqrt(ds)\n    const dp = sqrt(-p3_27);\n    const theta = acos(-q_2 / dp) / 3;\n    const cw = cbrt(dp);\n    const r = cw - p_3 / cw;\n\n    const rs = [];\n    for (let i = 0; i < 3; ++i) {\n      const cc = cos(theta - i * (2/3) * π);\n      const v = cc * r;\n      rs.push(v);\n    }\n\n    return rs;\n  }\n};\n\n// Solve a quartic a*x^4 + b*x^3 + c*x^2 + d*x + e = 0\nexport const solveQuartic = (a: number, b: number, c: number, d: number, e: number): number[] => {\n  const o = -b / (4 * a);\n  const aa = -3 * sqr(b) / (8 * sqr(a)) + c / a;\n  const bb = cub(b) / (8 * cub(a)) - b * c / (2 * sqr(a)) + d / a;\n  const cc = -3 * sqr(sqr(b)) / (256 * sqr(sqr(a))) + c * sqr(b) / (16 * cub(a)) - b * d / (4 * sqr(a)) + e / a;\n\n  if (bb === 0) {\n    // Biquadratic case\n    const q = solveQuadratic(1, aa, cc);\n    if (!q.length) return q;\n\n    const solutions = [];\n    const [q1, q2] = q;\n    if (q1 > 0) {\n      solutions.push(sqrt(q1) + o);\n      solutions.push(-sqrt(q1) + o);\n    }\n    if (q2 > 0) {\n      solutions.push(sqrt(q2) + o);\n      solutions.push(-sqrt(q2) + o);\n    }\n    if (q1 === 0) {\n      solutions.push(o);\n    }\n    if (q2 === 0) {\n      solutions.push(o);\n    }\n    return solutions;\n  }\n\n  // Quartic case\n  return solveDepressedQuartic(aa, bb, cc).map(x => x + o);\n};\n\n// Solve a depressed quartic t^4 + a*t^2 + b*t + c = 0\nexport const solveDepressedQuartic = (a: number, b: number, c: number): number[] => {\n  const p = -sqr(a) / 12 - c;\n  const q = -cub(a) / 108 + a * c / 3 - sqr(b) / 8;\n\n  const q_2 = q / 2;\n  const p_3 = p / 3;\n\n  const p3_27 = cub(p_3);\n  const ds = p3_27 + sqr(q_2);\n\n  const solutions: number[] = [];\n\n  let y = -Infinity;\n  if (ds >= 0) {\n    // Real R\n    const r = -q_2 - sqrt(ds) * sign(ds);\n    const u = cbrt(r);\n\n    y = -5/6 * a + (u ? u - p / (3 * u) : -cbrt(q));\n  }\n  else {\n    // Complex R\n    const dp = sqrt(-p3_27);\n    const theta = acos(-q_2 / dp) / 3;\n    const ct = cos(theta);\n    const ul = cbrt(dp);\n\n    // U - P/(3U) is always real\n    y = -5/6 * a + (ul ? ct * (ul - p_3 / ul) : -cbrt(q));\n  }\n\n  const w2 = a + 2 * y;\n  const w = sqrt(w2);\n  if (w2 < 0) {\n    return solutions;\n  }\n\n  const qw1 = -(3 * a + 2 * y + 2 * b / w);\n  const qw2 = -(3 * a + 2 * y - 2 * b / w);\n\n  if (qw1 > 0) {\n    const t1 = (w + sqrt(qw1)) / 2;\n    const t2 = (w - sqrt(qw1)) / 2;\n    solutions.push(t1, t2);\n  }\n  if (qw1 === 0) {\n    solutions.push(w / 2);\n  }\n  if (qw2 > 0) {\n    const t3 = (-w + sqrt(qw2)) / 2;\n    const t4 = (-w - sqrt(qw2)) / 2;\n    if (!solutions.includes(t3)) solutions.push(t3);\n    if (!solutions.includes(t4)) solutions.push(t4);\n  }\n  if (qw2 === 0) {\n    const t = -w / 2;\n    if (!solutions.includes(t)) solutions.push(t);\n  }\n  \n  return solutions;\n};\n"],"names":["solveCubic","solveDepressedCubic","solveDepressedQuartic","solveQuadratic","solveQuartic","acos","cbrt","cos","sign","sqrt","Math","a","b","c","d","x1","x2","o","p","q","map","x","p_3","q_2","p3_27","cub","ds","sqr","r1","r2","w","cw","dp","theta","r","rs","i","cc","π","v","push","e","aa","bb","length","solutions","q1","q2","y","Infinity","u","ct","ul","w2","qw1","qw2","t1","t2","t3","t4","includes","t"],"mappings":"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"}

package/cjs/vector.cjs

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Vector", {
+    enumerable: true,
+    get: function() {
+        return Vector;
+    }
+});
+// Binary dot-like operator
+const binary = (f)=>(a, b)=>{
+        const { length } = a;
+        const c = a.slice();
+        for(let i = 0; i < length; ++i){
+            c[i] = f(a[i], b[i]);
+        }
+        return c;
+    };
+// Unary reduction operator
+const reduce = (f)=>(v, accum = 0)=>{
+        const { length } = v;
+        for(let i = 0; i < length; ++i){
+            accum = f(accum, v[i], i);
+        }
+        return accum;
+    };
+// Binary reduction operator
+const reduce2 = (f)=>(a, b, accum = 0)=>{
+        const { length } = a;
+        for(let i = 0; i < length; ++i){
+            accum = f(accum, a[i], b[i], i);
+        }
+        return accum;
+    };
+// Scalar operators
+const plus = (x, y)=>x + y;
+const minus = (x, y)=>x - y;
+const multiply = (x, y)=>x * y;
+const divide = (x, y)=>x / y;
+const minimum = (x, y)=>Math.min(x, y);
+const maximum = (x, y)=>Math.max(x, y);
+const plus2 = (x, y)=>x + y * y;
+const mad = (x, y, z)=>x + y * z;
+const madl2 = (x, y, z)=>x + (y - z) * (y - z);
+// Vector operators
+const add = binary(plus);
+const sub = binary(minus);
+const mul = binary(multiply);
+const div = binary(divide);
+const dot = reduce2(mad);
+const adds = (a, s)=>a.map((x)=>x + s);
+const subs = (a, s)=>a.map((x)=>x - s);
+const muls = (a, s)=>a.map((x)=>x * s);
+const scale = muls;
+const sum = reduce(plus);
+const len2 = reduce(plus2);
+const len = (a)=>Math.sqrt(len2(a));
+const dist2 = reduce2(madl2);
+const dist = (a, b)=>Math.sqrt(dist2(a, b));
+const abs = (a)=>a.map((x)=>Math.abs(x));
+const unit = (a)=>{
+    const l = len(a);
+    return scale(a, l ? 1 / l : 0);
+};
+const minEl = (a)=>reduce(minimum)(a, Infinity);
+const maxEl = (a)=>reduce(maximum)(a, -Infinity);
+const min = (a, b)=>a.map((_, i)=>Math.min(a[i], b[i]));
+const max = (a, b)=>a.map((_, i)=>Math.max(a[i], b[i]));
+const clamp = (vector, a = 0, b = 1)=>vector.map((v)=>Math.max(a, Math.min(b, v)));
+const mins = (a, b)=>a.map((_, i)=>Math.min(a[i], b));
+const maxs = (a, b)=>a.map((_, i)=>Math.max(a[i], b));
+const lerp = (a, b, t)=>add(a, scale(sub(b, a), t));
+const project = (a, n)=>sub(a, scale(n, dot(a, n)));
+const select = (a, b, m)=>m.map((s, i)=>s ? b[i] : a[i]);
+const Vector = {
+    binary,
+    reduce,
+    reduce2,
+    add,
+    sub,
+    mul,
+    div,
+    dot,
+    adds,
+    subs,
+    muls,
+    mins,
+    maxs,
+    scale,
+    sum,
+    len2,
+    len,
+    dist2,
+    dist,
+    abs,
+    unit,
+    minEl,
+    maxEl,
+    min,
+    max,
+    clamp,
+    lerp,
+    project,
+    select
+};
+
+//# sourceMappingURL=vector.js.map