@use-gpu/math 0.0.0-stage → 0.21.0

package/mjs/matrix.mjs

@@ -0,0 +1,237 @@
+import { sqr } from './number.mjs';
+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 += 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;
+};
+export const Matrix = {
+    dims,
+    fill,
+    identity,
+    add,
+    sub,
+    mul,
+    muls,
+    tmul,
+    transpose,
+    concat,
+    slice,
+    rank,
+    norm,
+    norm2,
+    determinant,
+    jordanNormal
+};
+
+//# sourceMappingURL=matrix.js.map

package/mjs/number.d.mts

@@ -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/mjs/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":["max","min","Math","π","PI","τ","clamp","x","a","b","cub","sqr","lerp","t","clerp","d","seq","n","start","step","Array","from","length","map","_","i"],"mappings":"AAkBA,MAAM,EAAEA,GAAG,EAAEC,GAAG,EAAE,GAAGC;AAErB,OAAO,MAAMC,IAAID,KAAKE,EAAE,CAAC;AACzB,OAAO,MAAMC,IAAI,IAAEF,EAAE;AAErB,OAAO,MAAMG,QAAQ,CAACC,GAAWC,GAAWC,IAAcT,IAAIQ,GAAGP,IAAIQ,GAAGF,IAAI;AAE5E,OAAO,MAAMG,MAAM,CAACH,IAAcA,IAAIA,IAAIA,EAAE;AAC5C,OAAO,MAAMI,MAAM,CAACJ,IAAcA,IAAIA,EAAE;AAExC,OAAO,MAAMK,OAAO,CAACJ,GAAWC,GAAWI,IAAcL,IAAK,CAAA,IAAIK,CAAAA,IAAKJ,IAAII,EAAE;AAC7E,OAAO,MAAMC,QAAQ,CAACN,GAAWC,GAAWI;IAC1C,MAAME,IAAI,AAAGN,CAAAA,IAAID,IAAIL,CAAA,IAAKE,IAAK,IAAKA,IAAIF;IACxC,OAAOS,KAAKJ,GAAGA,IAAIO,GAAGF;AACxB,EAAE;AAEF,OAAO,MAAMG,MAAM,CAACC,GAAWC,QAAgB,CAAC,EAAEC,OAAe,CAAC,GAAKC,MAAMC,IAAI,CAAC;QAACC,QAAQL;IAAC,GAAGM,GAAG,CAAC,CAACC,GAAGC,IAAMP,QAAQO,IAAIN,MAAM"}

package/mjs/number.mjs

@@ -0,0 +1,16 @@
+const { max, min } = Math;
+export const π = Math.PI;
+export const τ = 2 * π;
+export const clamp = (x, a, b)=>max(a, min(b, x));
+export const cub = (x)=>x * x * x;
+export const sqr = (x)=>x * x;
+export const lerp = (a, b, t)=>a * (1 - t) + b * t;
+export const clerp = (a, b, t)=>{
+    const d = (b - a + π) / τ % 1 * τ - π;
+    return lerp(a, a + d, t);
+};
+export const seq = (n, start = 0, step = 1)=>Array.from({
+        length: n
+    }).map((_, i)=>start + i * step);
+
+//# sourceMappingURL=number.js.map

package/mjs/polynomial.d.mts

@@ -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/mjs/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":["π","sqr","cub","acos","cbrt","cos","sign","sqrt","Math","solveQuadratic","a","b","c","d","x1","x2","solveCubic","o","p","q","solveDepressedCubic","map","x","p_3","q_2","p3_27","ds","r1","r2","w","cw","dp","theta","r","rs","i","cc","v","push","solveQuartic","e","aa","bb","length","solutions","q1","q2","solveDepressedQuartic","y","Infinity","u","ct","ul","w2","qw1","qw2","t1","t2","t3","t4","includes","t"],"mappings":"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"}

package/mjs/polynomial.mjs

@@ -0,0 +1,152 @@
+import { π, sqr, cub } from './number.mjs';
+const { acos, cbrt, cos, sign, sqrt } = Math;
+// Solve a quadratic a*x^2 + b*x + c = 0
+export 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
+    ];
+};
+// Solve a cubic a*x^3 + b*x^2 + c*x + d = 0
+export 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);
+};
+// Solve a depressed cubic t^3 + p*t + q = 0
+export const solveDepressedCubic = (p, q)=>{
+    const p_3 = p / 3;
+    const q_2 = q / 2;
+    const p3_27 = cub(p_3);
+    const ds = p3_27 + 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) * π);
+            const v = cc * r;
+            rs.push(v);
+        }
+        return rs;
+    }
+};
+// Solve a quartic a*x^4 + b*x^3 + c*x^2 + d*x + e = 0
+export const solveQuartic = (a, b, c, d, e)=>{
+    const o = -b / (4 * a);
+    const aa = -3 * sqr(b) / (8 * sqr(a)) + c / a;
+    const bb = cub(b) / (8 * cub(a)) - b * c / (2 * sqr(a)) + d / a;
+    const cc = -3 * sqr(sqr(b)) / (256 * sqr(sqr(a))) + c * sqr(b) / (16 * cub(a)) - b * d / (4 * 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);
+};
+// Solve a depressed quartic t^4 + a*t^2 + b*t + c = 0
+export const solveDepressedQuartic = (a, b, c)=>{
+    const p = -sqr(a) / 12 - c;
+    const q = -cub(a) / 108 + a * c / 3 - sqr(b) / 8;
+    const q_2 = q / 2;
+    const p_3 = p / 3;
+    const p3_27 = cub(p_3);
+    const ds = p3_27 + 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/mjs/vector.d.mts

@@ -0,0 +1,32 @@
+import type { VectorLike } from './number.d.mts';
+export declare const Vector: {
+    binary: (f: (a: number, b: number) => number) => <T extends VectorLike>(a: T, b: T) => T;
+    reduce: (f: (a: number, b: number, i: number) => number) => <T extends VectorLike>(v: T, accum?: number) => number;
+    reduce2: (f: (a: number, b: number, c: number, i: number) => number) => <T extends VectorLike>(a: T, b: T, accum?: number) => number;
+    add: <T extends VectorLike>(a: T, b: T) => T;
+    sub: <T extends VectorLike>(a: T, b: T) => T;
+    mul: <T extends VectorLike>(a: T, b: T) => T;
+    div: <T extends VectorLike>(a: T, b: T) => T;
+    dot: <T extends VectorLike>(a: T, b: T, accum?: number) => number;
+    adds: <T extends VectorLike>(a: T, s: number) => T;
+    subs: <T extends VectorLike>(a: T, s: number) => T;
+    muls: <T extends VectorLike>(a: T, s: number) => T;
+    mins: <T extends VectorLike>(a: T, b: number) => T;
+    maxs: <T extends VectorLike>(a: T, b: number) => T;
+    scale: <T extends VectorLike>(a: T, s: number) => T;
+    sum: <T extends VectorLike>(v: T, accum?: number) => number;
+    len2: <T extends VectorLike>(v: T, accum?: number) => number;
+    len: <T extends VectorLike>(a: T) => number;
+    dist2: <T extends VectorLike>(a: T, b: T, accum?: number) => number;
+    dist: <T extends VectorLike>(a: T, b: T) => number;
+    abs: <T extends VectorLike>(a: T) => T;
+    unit: <T extends VectorLike>(a: T) => T;
+    minEl: <T extends VectorLike>(a: T) => number;
+    maxEl: <T extends VectorLike>(a: T) => number;
+    min: <T extends VectorLike>(a: T, b: T) => T;
+    max: <T extends VectorLike>(a: T, b: T) => T;
+    clamp: <T extends VectorLike>(vector: T, a?: number, b?: number) => T;
+    lerp: <T extends VectorLike>(a: T, b: T, t: number) => T;
+    project: <T extends VectorLike>(a: T, n: T) => T;
+    select: <T extends VectorLike>(a: T, b: T, m: T) => T;
+};

package/mjs/vector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/vector.ts"],"sourcesContent":["import type { VectorLike } from './number';\n\n// Binary dot-like operator\nconst binary = (f: (a: number, b: number) => number) =>\n  <T extends VectorLike>(a: T, b: T): T => {\n    const {length} = a;\n    const c = a.slice() as T;\n    for (let i = 0; i < length; ++i) {\n      c[i] = f(a[i], b[i]);\n    }\n    return c;\n  }\n\n// Unary reduction operator\nconst reduce = (f: (a: number, b: number, i: number) => number) =>\n  <T extends VectorLike>(v: T, accum: number = 0): number => {\n    const {length} = v;\n    for (let i = 0; i < length; ++i) {\n      accum = f(accum, v[i], i);\n    }\n    return accum;\n  };\n\n// Binary reduction operator\nconst reduce2 = (f: (a: number, b: number, c: number, i: number) => number) =>\n  <T extends VectorLike>(a: T, b: T, accum: number = 0): number => {\n    const {length} = a;\n    for (let i = 0; i < length; ++i) {\n      accum = f(accum, a[i], b[i], i);\n    }\n    return accum;\n  };\n\n// Scalar operators\nconst plus     = (x: number, y: number) => x + y;\nconst minus    = (x: number, y: number) => x - y;\nconst multiply = (x: number, y: number) => x * y;\nconst divide   = (x: number, y: number) => x / y;\nconst minimum  = (x: number, y: number) => Math.min(x, y);\nconst maximum  = (x: number, y: number) => Math.max(x, y);\n\nconst plus2  = (x: number, y: number) => x + y*y;\nconst mad    = (x: number, y: number, z: number) => x + y*z;\nconst madl2  = (x: number, y: number, z: number) => x + (y - z) * (y - z);\n\n// Vector operators\nconst add    = binary(plus);\nconst sub    = binary(minus);\nconst mul    = binary(multiply);\nconst div    = binary(divide);\nconst dot    = reduce2(mad);\nconst adds   = <T extends VectorLike>(a: T, s: number) => a.map(x => x + s) as T;\nconst subs   = <T extends VectorLike>(a: T, s: number) => a.map(x => x - s) as T;\nconst muls   = <T extends VectorLike>(a: T, s: number) => a.map(x => x * s) as T;\nconst scale  = muls;\n\nconst sum    = reduce(plus);\nconst len2   = reduce(plus2);\nconst len    = <T extends VectorLike>(a: T): number => Math.sqrt(len2(a));\nconst dist2  = reduce2(madl2);\nconst dist   = <T extends VectorLike>(a: T, b: T): number => Math.sqrt(dist2(a, b));\n\nconst abs    = <T extends VectorLike>(a: T): T => a.map(x => Math.abs(x)) as T;\nconst unit   = <T extends VectorLike>(a: T): T => {\n  const l = len(a);\n  return scale(a, l ? 1/l : 0);\n};\n\nconst minEl  = <T extends VectorLike>(a: T)    => reduce(minimum)(a, Infinity);\nconst maxEl  = <T extends VectorLike>(a: T)    => reduce(maximum)(a, -Infinity);\n\nconst min    = <T extends VectorLike>(a: T, b: T): T => a.map((_, i) => Math.min(a[i], b[i])) as T;\nconst max    = <T extends VectorLike>(a: T, b: T): T => a.map((_, i) => Math.max(a[i], b[i])) as T;\nconst clamp  = <T extends VectorLike>(vector: T, a: number = 0, b: number = 1): T => vector.map(v => Math.max(a, Math.min(b, v))) as T;\n\nconst mins   = <T extends VectorLike>(a: T, b: number): T => a.map((_, i) => Math.min(a[i], b)) as T;\nconst maxs   = <T extends VectorLike>(a: T, b: number): T => a.map((_, i) => Math.max(a[i], b)) as T;\n\nconst lerp    = <T extends VectorLike>(a: T, b: T, t: number): T => add(a, scale(sub(b, a), t));\nconst project = <T extends VectorLike>(a: T, n: T): T => sub(a, scale(n, dot(a, n)));\nconst select  = <T extends VectorLike>(a: T, b: T, m: T): T => m.map((s, i) => s ? b[i] : a[i]) as T;\n\nexport const Vector = {\n  binary,\n  reduce,\n  reduce2,\n  add,\n  sub,\n  mul,\n  div,\n  dot,\n  adds,\n  subs,\n  muls,\n  mins,\n  maxs,\n  scale,\n  sum,\n  len2,\n  len,\n  dist2,\n  dist,\n  abs,\n  unit,\n  minEl,\n  maxEl,\n  min,\n  max,\n  clamp,\n  lerp,\n  project,\n  select,\n};\n"],"names":["binary","f","a","b","length","c","slice","i","reduce","v","accum","reduce2","plus","x","y","minus","multiply","divide","minimum","Math","min","maximum","max","plus2","mad","z","madl2","add","sub","mul","div","dot","adds","s","map","subs","muls","scale","sum","len2","len","sqrt","dist2","dist","abs","unit","l","minEl","Infinity","maxEl","_","clamp","vector","mins","maxs","lerp","t","project","n","select","m","Vector"],"mappings":"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"}

package/mjs/vector.mjs

@@ -0,0 +1,98 @@
+// 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]);
+export 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

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@use-gpu/math",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.21.0",
+  "main": "./cjs/index.cjs",
+  "author": "Steven Wittens <steven@acko.net>",
+  "type": "module",
+  "license": "MIT",
+  "scripts": {
+    "test": "vitest --watch",
+    "lint": "eslint src",
+    "coverage": "vitest --coverage",
+    "types": "tsc --noEmit",
+    "types:watch": "yarn run types -- --watch",
+    "build": "NPM_PACKAGE=math ../../scripts/build-mjs-cjs.sh"
+  },
+  "keywords": [
+    "use-gpu",
+    "use-gpu-library"
+  ],
+  "sideEffects": false,
+  "module": "./mjs/index.mjs"
 }