@use-gpu/math 0.0.0-stage → 0.21.0

package/LICENSE.md

@@ -0,0 +1,28 @@
+Live/Use.GPU - MIT+NMLA
+
+Copyright (c) 2021-2026 Steven Wittens
+https://acko.net/
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+- The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+- This Software may not be used as source material to train
+machine learning systems of any kind.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# @use-gpu/math
+
+```sh
+npm install --save @use-gpu/math
+```
+
+```sh
+yarn add @use-gpu/math
+```
+
+**Docs**: https://usegpu.live/docs/reference-library-@use-gpu-math
+
+# Use.GPU - Math
+
+Pure math helpers in JS for:
+- Linear algebra solving
+- Polynomial solving
+- Bezier & Catmull-Rom splines
+- Animation easing
+- Arbitrary-size vectors and matrices
+
+## Colofon
+
+Made by [Steven Wittens](https://acko.net). Part of `@use-gpu`.
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.

package/cjs/ease.cjs

@@ -0,0 +1,285 @@
+"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 bezierEase () {
+        return bezierEase;
+    },
+    get catmullRom () {
+        return catmullRom;
+    },
+    get catmullRomDual () {
+        return catmullRomDual;
+    },
+    get catmullRomWeighted () {
+        return catmullRomWeighted;
+    },
+    get catmullRomWeightedDual () {
+        return catmullRomWeightedDual;
+    },
+    get cubicBezier () {
+        return cubicBezier;
+    },
+    get cubicBezier01 () {
+        return cubicBezier01;
+    },
+    get cubicBezierDt () {
+        return cubicBezierDt;
+    },
+    get cubicBezierDt2 () {
+        return cubicBezierDt2;
+    },
+    get cubicBezierInverse01 () {
+        return cubicBezierInverse01;
+    },
+    get makeArcLengthMap () {
+        return makeArcLengthMap;
+    },
+    get queryArcLengthMap () {
+        return queryArcLengthMap;
+    },
+    get sampleToCubicBezier () {
+        return sampleToCubicBezier;
+    },
+    get velocityToBezierEase () {
+        return velocityToBezierEase;
+    }
+});
+const _number = require("./number.cjs");
+const { abs, acos, cbrt, ceil, cos, log2, min, pow, sign, sqrt } = Math;
+const cubicBezier = (t, a, b, c, d)=>(a + (3 * b - a) * t) * (0, _number.sqr)(1 - t) + (d + (3 * c - d) * (1 - t)) * (0, _number.sqr)(t);
+const cubicBezierDt = (t, a, b, c, d)=>a * (-3 * (0, _number.sqr)(1 - t)) + b * ((9 * t - 12) * t + 3) + c * (6 - 9 * t) * t + d * 3 * (0, _number.sqr)(t);
+const cubicBezierDt2 = (t, a, b, c, d)=>a * (3 * 2 * (1 - t)) + b * (18 * t - 12) + c * (6 - 18 * t) + d * 3 * 2 * t;
+const cubicBezier01 = (t, b, c)=>3 * b * t * (0, _number.sqr)(1 - t) + (3 * c * (1 - t) + t) * (0, _number.sqr)(t);
+const cubicBezierInverse01 = (v, b, c)=>{
+    // Bezier over x=[-1..1] y=[-1..1] with symmetric basis functions
+    const y = v * 2 - 1;
+    // Sum and difference of middle two bezier bands relative to f(x) = x
+    const s = 3 / 4 * (b + c - 1);
+    const d = 3 / 4 * (b - c + 1 / 3);
+    if (abs(d) < 1e-5) {
+        if (abs(s) < 1e-5) return v;
+        return solveQuadraticBezier(s, y) * .5 + .5;
+    }
+    // Construct cubic basis
+    // y = (d x^3 - s x^2 - d x + s) + x
+    // Deflate cubic
+    // t = x - o
+    // t^3 + pt + q = 0
+    const id = 1 / d;
+    const s2 = s * s;
+    const d2 = d * d;
+    const id2 = id * id;
+    const o = 1 / 3 * s * id;
+    const p = (d - d2 + -1 / 3 * s2) * id2;
+    const q = ((-2 / 27 * s2 + 1 / 3 * (d - d2) + d2) * s - y * d2) * (id2 * id);
+    return (solveDepressedCubicBezier(p, q, s, d) + o) * .5 + .5;
+};
+// Helper for quadratic inverse (d=0)
+const solveQuadraticBezier = (s, y)=>{
+    const d = 1 - 4 * s * (y - s);
+    const v = (1 - sqrt(d)) / (2 * s);
+    return v;
+};
+// Helper for cubic inverse, solve depressed cubic p/q using s/d to pick roots
+const solveDepressedCubicBezier = (p, q, s, d)=>{
+    const p_3 = p / 3;
+    const q_2 = q / 2;
+    const p3_27 = p_3 * p_3 * p_3;
+    const ds = p3_27 + q_2 * q_2;
+    if (ds === 0) {
+        // Multiple root
+        if (p) return -q_2 / p_3;
+        else return 0;
+    } else if (ds > 0) {
+        // 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 {
+        // 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 i = +(d < 0) || +(s * d > 0) * 2;
+        const cc = cos(theta - i * (2 / 3) * _number.π);
+        const v = cc * r;
+        return v;
+    }
+};
+const bezierEase = (t, x1, y1, x2, y2)=>{
+    if (t === 0 || t === 1) return t;
+    const s = cubicBezierInverse01(t, x1, x2);
+    const value = cubicBezier01(s, y1, y2);
+    return value;
+};
+const velocityToBezierEase = (duration, arcLength, v1, v2, w1 = 1 / 3, w2 = 1 / 3)=>{
+    const slope1 = arcLength ? v1 * duration / arcLength : 0;
+    const slope2 = arcLength ? v2 * duration / arcLength : 0;
+    const x1 = min(w1, 1 / slope1);
+    const x2 = min(w2, 1 / slope2);
+    const y1 = x1 * slope1;
+    const y2 = x2 * slope2;
+    return [
+        x1,
+        y1,
+        1 - x2,
+        1 - y2
+    ];
+};
+const catmullRom = (t, t0, t1, t2, t3, a, b, c, d)=>{
+    const d0t = t0 - t;
+    const d10 = t1 - t0;
+    const d1t = t1 - t;
+    const d20 = t2 - t0;
+    const d21 = t2 - t1;
+    const d2t = t2 - t;
+    const d31 = t3 - t1;
+    const d32 = t3 - t2;
+    const d3t = t3 - t;
+    const a1 = d10 !== 0 ? a * (d1t / d10) + b * (-d0t / d10) : (a + b) / 2;
+    const a2 = d21 !== 0 ? b * (d2t / d21) + c * (-d1t / d21) : (b + c) / 2;
+    const a3 = d32 !== 0 ? c * (d3t / d32) + d * (-d2t / d32) : (c + d) / 2;
+    const b1 = d20 !== 0 ? a1 * (d2t / d20) + a2 * (-d0t / d20) : (a1 + a2) / 2;
+    const b2 = d31 !== 0 ? a2 * (d3t / d31) + a3 * (-d1t / d31) : (a2 + a3) / 2;
+    const v = d21 !== 0 ? b1 * (d2t / d21) + b2 * (-d1t / d21) : (b1 + b2) / 2;
+    return v;
+};
+const catmullRomDual = (t, t0, t1, t2, t3, a, b, c, d)=>{
+    const d0t = t0 - t;
+    const d10 = t1 - t0;
+    const d1t = t1 - t;
+    const d20 = t2 - t0;
+    const d21 = t2 - t1;
+    const d2t = t2 - t;
+    const d31 = t3 - t1;
+    const d32 = t3 - t2;
+    const d3t = t3 - t;
+    const a1 = d10 !== 0 ? a * (d1t / d10) + b * (-d0t / d10) : (a + b) / 2;
+    const a2 = d21 !== 0 ? b * (d2t / d21) + c * (-d1t / d21) : (b + c) / 2;
+    const a3 = d32 !== 0 ? c * (d3t / d32) + d * (-d2t / d32) : (c + d) / 2;
+    const b1 = d20 !== 0 ? a1 * (d2t / d20) + a2 * (-d0t / d20) : (a1 + a2) / 2;
+    const b2 = d31 !== 0 ? a2 * (d3t / d31) + a3 * (-d1t / d31) : (a2 + a3) / 2;
+    const v = d21 !== 0 ? b1 * (d2t / d21) + b2 * (-d1t / d21) : (b1 + b2) / 2;
+    const da1dt = d10 !== 0 ? a * (-1 / d10) + b * (1 / d10) : 0;
+    const da2dt = d21 !== 0 ? b * (-1 / d21) + c * (1 / d21) : 0;
+    const da3dt = d32 !== 0 ? c * (-1 / d32) + d * (1 / d32) : 0;
+    const db1dt = d20 !== 0 ? a1 * (-1 / d20) + da1dt * (d2t / d20) + a2 * (1 / d20) + da2dt * (-d0t / d20) : 0;
+    const db2dt = d31 !== 0 ? a2 * (-1 / d31) + da2dt * (d3t / d31) + a3 * (1 / d31) + da3dt * (-d1t / d31) : 0;
+    const dvdt = d21 !== 0 ? b1 * (-1 / d21) + db1dt * (d2t / d21) + b2 * (1 / d21) + db2dt * (-d1t / d21) : 0;
+    return [
+        v,
+        dvdt
+    ];
+};
+const catmullRomWeighted = (fraction, a, b, c, d, ab, bc, cd, power = 1 / 2)=>{
+    const d1 = pow(ab, power);
+    const d2 = pow(bc, power);
+    const d3 = pow(cd, power);
+    const t0 = -d1;
+    const t1 = 0;
+    const t2 = d2;
+    const t3 = d2 + d3;
+    return catmullRom(fraction * d2, t0, t1, t2, t3, a, b, c, d);
+};
+const catmullRomWeightedDual = (fraction, a, b, c, d, ab, bc, cd, power = 1 / 2)=>{
+    const d1 = pow(ab, power);
+    const d2 = pow(bc, power);
+    const d3 = pow(cd, power);
+    const t0 = -d1;
+    const t1 = 0;
+    const t2 = d2;
+    const t3 = d2 + d3;
+    const [v, dvdt] = catmullRomDual(fraction * d2, t0, t1, t2, t3, a, b, c, d);
+    return [
+        v,
+        dvdt * d2
+    ];
+};
+const sampleToCubicBezier = (sampleDual)=>{
+    const [b0, v0] = sampleDual(0);
+    const [b3, v3] = sampleDual(1);
+    const b1 = b0 + v0 / 3;
+    const b2 = b3 - v3 / 3;
+    return [
+        b0,
+        b1,
+        b2,
+        b3
+    ];
+};
+const makeArcLengthMap = (measure, tolerance = 0.005, evenness = 0.5, limit = 8)=>{
+    let n = 0;
+    let accum = 0;
+    const eps = pow(2, ceil(log2(tolerance)));
+    // Extra epsilon at start
+    const data = [
+        -measure(-eps, 0),
+        -eps,
+        0
+    ];
+    // Accumulate samples from 0..1
+    const range = (a, b, l, force, limit)=>{
+        const m = (a + b) / 2;
+        const l1 = measure(a, m);
+        const l2 = measure(m, b);
+        const d = l1 + l2;
+        const e = min(l1 / l2, l2 / l1);
+        if ((force > 0 || l / d < 1 - tolerance || e < evenness) && limit > 0) {
+            range(a, m, l1, force - 1, limit - 1);
+            range(m, b, l2, force - 1, limit - 1);
+        } else {
+            n++;
+            const r = l / d;
+            accum += d / (1 + r) * 2;
+            data.push(a);
+            data.push(accum);
+        }
+    };
+    range(0, 1, measure(0, 1), 2, limit);
+    data.push(1);
+    // Extra epsilon at end
+    data.push(accum + measure(1, 1 + eps));
+    data.push(1 + eps);
+    const count = n;
+    const length = accum;
+    const map = new Float32Array(data);
+    return {
+        map,
+        count,
+        length,
+        limit
+    };
+};
+const queryArcLengthMap = (am, value)=>{
+    const { map, count } = am;
+    let { limit } = am;
+    let a = 1;
+    let b = count;
+    while(b > a && limit-- > 0){
+        const m = b - (b - a >> 1);
+        const d = map[m * 2];
+        if (d > value) b = m - 1;
+        else a = m;
+    }
+    const a2 = a * 2;
+    const d0 = map[a2 - 2];
+    const t0 = map[a2 - 1];
+    const d1 = map[a2];
+    const t1 = map[a2 + 1];
+    const d2 = map[a2 + 2];
+    const t2 = map[a2 + 3];
+    const d3 = map[a2 + 4];
+    const t3 = map[a2 + 5];
+    return (0, _number.clamp)(catmullRom(value, d0, d1, d2, d3, t0, t1, t2, t3), 0, 1);
+};
+
+//# sourceMappingURL=ease.js.map

package/cjs/ease.d.cts

@@ -0,0 +1,25 @@
+export declare const cubicBezier: (t: number, a: number, b: number, c: number, d: number) => number;
+export declare const cubicBezierDt: (t: number, a: number, b: number, c: number, d: number) => number;
+export declare const cubicBezierDt2: (t: number, a: number, b: number, c: number, d: number) => number;
+export declare const cubicBezier01: (t: number, b: number, c: number) => number;
+export declare const cubicBezierInverse01: (v: number, b: number, c: number) => number;
+export declare const bezierEase: (t: number, x1: number, y1: number, x2: number, y2: number) => number;
+export declare const velocityToBezierEase: (duration: number, arcLength: number, v1: number, v2: number, w1?: number, w2?: number) => number[];
+export declare const catmullRom: (t: number, t0: number, t1: number, t2: number, t3: number, a: number, b: number, c: number, d: number) => number;
+export declare const catmullRomDual: (t: number, t0: number, t1: number, t2: number, t3: number, a: number, b: number, c: number, d: number) => [number, number];
+export declare const catmullRomWeighted: (fraction: number, a: number, b: number, c: number, d: number, ab: number, bc: number, cd: number, power?: number) => number;
+export declare const catmullRomWeightedDual: (fraction: number, a: number, b: number, c: number, d: number, ab: number, bc: number, cd: number, power?: number) => [number, number];
+export declare const sampleToCubicBezier: (sampleDual: (t: number) => [number, number]) => number[];
+export type ArcLengthMap = {
+    map: Float32Array;
+    count: number;
+    length: number;
+    limit: number;
+};
+export declare const makeArcLengthMap: (measure: (t1: number, t2: number) => number, tolerance?: number, evenness?: number, limit?: number) => {
+    map: Float32Array<ArrayBuffer>;
+    count: number;
+    length: number;
+    limit: number;
+};
+export declare const queryArcLengthMap: (am: ArcLengthMap, value: number) => number;

package/cjs/ease.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/ease.ts"],"sourcesContent":["import { π, clamp, sqr } from './number';\n\nconst { abs, acos, cbrt, ceil, cos, log2, min, pow, sign, sqrt } = Math;\n\n// Cubic bezier 1D\nexport const cubicBezier = (t: number, a: number, b: number, c: number, d: number) =>\n  (a + (3 * b - a) * t) * sqr(1 - t) + (d + (3 * c - d) * (1 - t)) * sqr(t);\n\n// Cubic bezier 1D derivative\nexport const cubicBezierDt = (t: number, a: number, b: number, c: number, d: number) =>\n  a * (- 3*sqr(1 - t)) +\n  b * ((9*t - 12)*t + 3) +\n  c * (6 - 9*t) * t +\n  d * 3*sqr(t);\n  \n// Cubic bezier 1D 2nd derivative\nexport const cubicBezierDt2 = (t: number, a: number, b: number, c: number, d: number) =>\n  a * (3*2*(1 - t)) +\n  b * (18*t - 12) +\n  c * (6 - 18*t) +\n  d * 3*2*t;\n\n// Cubic bezier 1D (a=0 d=1)\nexport const cubicBezier01 = (t: number, b: number, c: number) =>\n  (3 * b) * t * sqr(1 - t) + ((3 * c) * (1 - t) + t) * sqr(t);\n\n// Invert monotonous cubic bezier (a=0 d=1) (analytic)\nexport const cubicBezierInverse01 = (v: number, b: number, c: number) => {\n  // Bezier over x=[-1..1] y=[-1..1] with symmetric basis functions\n  const y = v * 2 - 1;\n\n  // Sum and difference of middle two bezier bands relative to f(x) = x\n  const s = (3/4) * (b + c - 1);\n  const d = (3/4) * (b - c + (1/3));\n  if (abs(d) < 1e-5) {\n    if (abs(s) < 1e-5) return v;\n    return solveQuadraticBezier(s, y) * .5 + .5;\n  }\n\n  // Construct cubic basis\n  // y = (d x^3 - s x^2 - d x + s) + x\n\n  // Deflate cubic\n  // t = x - o\n  // t^3 + pt + q = 0\n  const id = 1/d;\n  const s2 = s*s;\n  const d2 = d*d;\n  const id2 = id*id;\n\n  const o = (1/3) * s * id;\n  const p = (d - d2 + (-1/3) * s2) * id2;\n  const q = (((-2/27) * s2 + (1/3) * (d - d2) + d2) * s - y * d2) * (id2 * id);\n\n  return (solveDepressedCubicBezier(p, q, s, d) + o) * .5 + .5;\n};\n\n// Helper for quadratic inverse (d=0)\nconst solveQuadraticBezier = (s: number, y: number) => {\n  const d = 1 - 4 * s * (y - s);\n  const v = (1 - sqrt(d)) / (2*s);\n  return v;\n};\n\n// Helper for cubic inverse, solve depressed cubic p/q using s/d to pick roots\nconst solveDepressedCubicBezier = (p: number, q: number, s: number, d: number) => {\n  const p_3 = p / 3;\n  const q_2 = q / 2;\n\n  const p3_27 = p_3 * p_3 * p_3;\n  const ds = p3_27 + q_2 * q_2;\n\n  if (ds === 0) {\n    // Multiple root\n    if (p) return -q_2 / p_3;\n    else return 0;\n  }\n  else if (ds > 0) {\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    // 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 i = +(d < 0) || (+(s*d > 0) * 2);\n    const cc = cos(theta - i * (2/3) * π);\n    const v = cc * r;\n\n    return v;\n  }\n};\n\n// Cubic bezier ease, X = time / Y = value\n// Only control points (x1,y1) and (x2,y2) are adjustable (x = [0...1], y = any)\nexport const bezierEase = (t: number, x1: number, y1: number, x2: number, y2: number) => {\n  if (t === 0 || t === 1) return t;\n  const s = cubicBezierInverse01(t, x1, x2);\n  const value = cubicBezier01(s, y1, y2);\n  return value;\n};\n\n// Velocity helper for cubic bezier ease.\n// Ease across arcLength over duration, entering at speed v1 and exiting at speed v2.\nexport const velocityToBezierEase = (\n  duration: number,\n  arcLength: number,\n  v1: number,\n  v2: number,\n  w1: number = 1/3,\n  w2: number = 1/3,\n) => {\n  const slope1 = arcLength ? v1 * duration / arcLength : 0;\n  const slope2 = arcLength ? v2 * duration / arcLength : 0;\n\n  const x1 = min(w1, 1 / slope1);\n  const x2 = min(w2, 1 / slope2);\n  const y1 = x1 * slope1;\n  const y2 = x2 * slope2;\n\n  return [x1, y1, 1 - x2, 1 - y2];\n};\n\n// Catmull-rom spline with movable knots\nexport const catmullRom = (\n  t: number,\n  t0: number,\n  t1: number,\n  t2: number,\n  t3: number,\n  a: number,\n  b: number,\n  c: number,\n  d: number,\n) => {\n  const d0t = t0 - t;\n\n  const d10 = t1 - t0;\n  const d1t = t1 - t;\n  const d20 = t2 - t0;\n  const d21 = t2 - t1;\n  const d2t = t2 - t;\n  const d31 = t3 - t1;\n  const d32 = t3 - t2;\n  const d3t = t3 - t;\n\n  const a1 = (d10 !== 0) ? a * (d1t / d10) + b * (-d0t / d10) : (a + b) / 2;\n  const a2 = (d21 !== 0) ? b * (d2t / d21) + c * (-d1t / d21) : (b + c) / 2;\n  const a3 = (d32 !== 0) ? c * (d3t / d32) + d * (-d2t / d32) : (c + d) / 2;\n\n  const b1 = (d20 !== 0) ? a1 * (d2t / d20) + a2 * (-d0t / d20) : (a1 + a2) / 2;\n  const b2 = (d31 !== 0) ? a2 * (d3t / d31) + a3 * (-d1t / d31) : (a2 + a3) / 2;\n\n  const v  = (d21 !== 0) ? b1 * (d2t / d21) + b2 * (-d1t / d21) : (b1 + b2) / 2;\n\n  return v;\n};\n\n// Catmull-rom spline value+derivative with movable knots\nexport const catmullRomDual = (\n  t: number,\n  t0: number,\n  t1: number,\n  t2: number,\n  t3: number,\n  a: number,\n  b: number,\n  c: number,\n  d: number,\n): [number, number] => {\n  const d0t = t0 - t;\n\n  const d10 = t1 - t0;\n  const d1t = t1 - t;\n  const d20 = t2 - t0;\n  const d21 = t2 - t1;\n  const d2t = t2 - t;\n  const d31 = t3 - t1;\n  const d32 = t3 - t2;\n  const d3t = t3 - t;\n\n  const a1 = (d10 !== 0) ? a * (d1t / d10) + b * (-d0t / d10) : (a + b) / 2;\n  const a2 = (d21 !== 0) ? b * (d2t / d21) + c * (-d1t / d21) : (b + c) / 2;\n  const a3 = (d32 !== 0) ? c * (d3t / d32) + d * (-d2t / d32) : (c + d) / 2;\n\n  const b1 = (d20 !== 0) ? a1 * (d2t / d20) + a2 * (-d0t / d20) : (a1 + a2) / 2;\n  const b2 = (d31 !== 0) ? a2 * (d3t / d31) + a3 * (-d1t / d31) : (a2 + a3) / 2;\n\n  const v  = (d21 !== 0) ? b1 * (d2t / d21) + b2 * (-d1t / d21) : (b1 + b2) / 2;\n\n  const da1dt = (d10 !== 0) ? a * (-1 / d10) + b * (1 / d10) : 0;\n  const da2dt = (d21 !== 0) ? b * (-1 / d21) + c * (1 / d21) : 0;\n  const da3dt = (d32 !== 0) ? c * (-1 / d32) + d * (1 / d32) : 0;\n\n  const db1dt = (d20 !== 0) ? a1 * (-1 / d20) + da1dt * (d2t / d20) + a2 * (1 / d20) + da2dt * (-d0t / d20) : 0;\n  const db2dt = (d31 !== 0) ? a2 * (-1 / d31) + da2dt * (d3t / d31) + a3 * (1 / d31) + da3dt * (-d1t / d31) : 0;\n\n  const dvdt = (d21 !== 0) ? b1 * (-1 / d21) + db1dt * (d2t / d21) + b2 * (1 / d21) + db2dt * (-d1t / d21) : 0;\n\n  return [v, dvdt];\n};\n\n// Weighted catmull rom (chordal = 1, centripetal = 1/2)\nexport const catmullRomWeighted = (\n  fraction: number,\n  a: number,\n  b: number,\n  c: number,\n  d: number,\n  ab: number,\n  bc: number,\n  cd: number,\n  power: number = 1/2,\n) => {\n  const d1 = pow(ab, power);\n  const d2 = pow(bc, power);\n  const d3 = pow(cd, power);\n\n  const t0 = -d1;\n  const t1 = 0;\n  const t2 = d2;\n  const t3 = d2 + d3;\n\n  return catmullRom(fraction * d2, t0, t1, t2, t3, a, b, c, d);\n};\n\n// Weighted catmull rom value+derivative (chordal = 1, centripetal = 1/2)\nexport const catmullRomWeightedDual = (\n  fraction: number,\n  a: number,\n  b: number,\n  c: number,\n  d: number,\n  ab: number,\n  bc: number,\n  cd: number,\n  power: number = 1/2,\n): [number, number] => {\n  const d1 = pow(ab, power);\n  const d2 = pow(bc, power);\n  const d3 = pow(cd, power);\n\n  const t0 = -d1;\n  const t1 = 0;\n  const t2 = d2;\n  const t3 = d2 + d3;\n\n  const [v, dvdt] = catmullRomDual(fraction * d2, t0, t1, t2, t3, a, b, c, d);\n  return [v, dvdt * d2];\n};\n\n// Sample spline at endpoints (0..1) to make cubic bezier\nexport const sampleToCubicBezier = (\n  sampleDual: (t: number) => [number, number],\n) => {\n  const [b0, v0] = sampleDual(0);\n  const [b3, v3] = sampleDual(1);\n\n  const b1 = b0 + v0 / 3;\n  const b2 = b3 - v3 / 3;\n\n  return [b0, b1, b2, b3];\n};\n\n// Arc length map for a spline\nexport type ArcLengthMap = {\n  map: Float32Array,\n  count: number,\n  length: number,\n  limit: number,\n};\n\n// Make arc length map for a spline\nexport const makeArcLengthMap = (\n  measure: (t1: number, t2: number) => number,\n  tolerance: number = 0.005,\n  evenness: number = 0.5,\n  limit: number = 8,\n) => {\n\n  let n = 0;\n  let accum = 0;\n  const eps = pow(2, ceil(log2(tolerance)));\n\n  // Extra epsilon at start\n  const data: number[] = [-measure(-eps, 0), -eps, 0];\n\n  // Accumulate samples from 0..1\n  const range = (a: number, b: number, l: number, force: number, limit: number) => {\n    const m = (a + b) / 2;\n    const l1 = measure(a, m);\n    const l2 = measure(m, b);\n    const d = l1 + l2;\n    const e = min(l1 / l2, l2 / l1);\n\n    if ((force > 0 || (l / d < 1 - tolerance) || (e < evenness)) && (limit > 0)) {\n      range(a, m, l1, force - 1, limit - 1);\n      range(m, b, l2, force - 1, limit - 1);\n    }\n    else {\n      n++;\n      const r = l / d;\n      accum += d / (1 + r) * 2;\n      data.push(a);\n      data.push(accum);\n    }\n  };\n\n  range(0, 1, measure(0, 1), 2, limit);\n  data.push(1);\n\n  // Extra epsilon at end\n  data.push(accum + measure(1, 1 + eps));\n  data.push(1 + eps);\n\n  const count = n;\n  const length = accum;\n  const map = new Float32Array(data);\n\n  return {map, count, length, limit};\n};\n\n// Query value in arc length map\nexport const queryArcLengthMap = (am: ArcLengthMap, value: number) => {\n  const {map, count} = am;\n  let {limit} = am;\n\n  let a = 1;\n  let b = count;\n\n  while (b > a && limit-- > 0) {\n    const m = b - ((b - a) >> 1);\n    const d = map[m * 2];\n    if (d > value) b = m - 1;\n    else a = m;\n  }\n\n  const a2 = a * 2;\n\n  const d0 = map[a2 - 2];\n  const t0 = map[a2 - 1];\n\n  const d1 = map[a2];\n  const t1 = map[a2 + 1];\n\n  const d2 = map[a2 + 2];\n  const t2 = map[a2 + 3];\n\n  const d3 = map[a2 + 4];\n  const t3 = map[a2 + 5];\n\n  return clamp(catmullRom(value, d0, d1, d2, d3, t0, t1, t2, t3), 0, 1);\n};\n"],"names":["bezierEase","catmullRom","catmullRomDual","catmullRomWeighted","catmullRomWeightedDual","cubicBezier","cubicBezier01","cubicBezierDt","cubicBezierDt2","cubicBezierInverse01","makeArcLengthMap","queryArcLengthMap","sampleToCubicBezier","velocityToBezierEase","abs","acos","cbrt","ceil","cos","log2","min","pow","sign","sqrt","Math","t","a","b","c","d","sqr","v","y","s","solveQuadraticBezier","id","s2","d2","id2","o","p","q","solveDepressedCubicBezier","p_3","q_2","p3_27","ds","w","cw","dp","theta","r","i","cc","π","x1","y1","x2","y2","value","duration","arcLength","v1","v2","w1","w2","slope1","slope2","t0","t1","t2","t3","d0t","d10","d1t","d20","d21","d2t","d31","d32","d3t","a1","a2","a3","b1","b2","da1dt","da2dt","da3dt","db1dt","db2dt","dvdt","fraction","ab","bc","cd","power","d1","d3","sampleDual","b0","v0","b3","v3","measure","tolerance","evenness","limit","n","accum","eps","data","range","l","force","m","l1","l2","e","push","count","length","map","Float32Array","am","d0","clamp"],"mappings":"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"}

package/cjs/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./ease.cjs"), exports);
+_export_star(require("./linalg.cjs"), exports);
+_export_star(require("./matrix.cjs"), exports);
+_export_star(require("./number.cjs"), exports);
+_export_star(require("./polynomial.cjs"), exports);
+_export_star(require("./vector.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/cjs/index.d.cts

@@ -0,0 +1,6 @@
+export * from './ease.d.cts';
+export * from './linalg.d.cts';
+export * from './matrix.d.cts';
+export * from './number.d.cts';
+export * from './polynomial.d.cts';
+export * from './vector.d.cts';

package/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/index.ts"],"sourcesContent":["export * from './ease';\nexport * from './linalg';\nexport * from './matrix';\nexport * from './number';\nexport * from './polynomial';\nexport * from './vector';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA;qBACA;qBACA"}

package/cjs/linalg.cjs

@@ -0,0 +1,101 @@
+"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 lagrangeMinimumTo () {
+        return lagrangeMinimumTo;
+    },
+    get leastSquares () {
+        return leastSquares;
+    },
+    get leastSquaresClosest () {
+        return leastSquaresClosest;
+    },
+    get solveLinearSystem () {
+        return solveLinearSystem;
+    }
+});
+const _matrix = require("./matrix.cjs");
+const _number = require("./number.cjs");
+const { abs, min } = Math;
+const { concat, dims, fill, jordanNormal, mul, transpose } = _matrix.Matrix;
+// Fill an array of length n with all zeros except a single v at index i
+const select = (n, i = n - 1, v = 1)=>(0, _number.seq)(n).map((j)=>i == j ? v : 0);
+const solveLinearSystem = (A, B)=>{
+    // eslint-disable-next-line
+    let [n, m] = dims(A);
+    // Diagonalize system of equations
+    let G = jordanNormal(concat(A, B));
+    // Filter out zero rows
+    G = G.filter((row)=>row.filter((x)=>x).length > 0);
+    n = G.length;
+    if (n > m) {
+        // Overdetermined, no solution
+        return null;
+    }
+    if (!isJordanNormalDiagonal(G)) {
+        // Underdetermined, no solution
+        return null;
+    }
+    if (n == m) {
+        // Extract exact solution
+        const v = (0, _number.seq)(m).map((i)=>G[i][m]);
+        return v;
+    }
+    return null;
+};
+const lagrangeMinimumTo = (A, B, P)=>{
+    const [n, m] = dims(A);
+    const M = concat(A, fill(n, n));
+    const T = (0, _number.seq)(m).map((i)=>[
+            ...select(m, i, 2),
+            ...(0, _number.seq)(n).map((j)=>-A[j][i])
+        ]);
+    const AL = [
+        ...M,
+        ...T
+    ];
+    const BL = [
+        ...B,
+        ...P.map((v)=>2 * v)
+    ];
+    return [
+        AL,
+        BL
+    ];
+};
+const leastSquares = (A, B)=>{
+    const AT = transpose(A);
+    const ATA = mul(AT, A);
+    const ATB = mul([
+        B
+    ], A)[0];
+    return [
+        ATA,
+        ATB
+    ];
+};
+const leastSquaresClosest = (A, B, P)=>{
+    const d = P.length;
+    const AP = A.concat((0, _number.seq)(d).map((i)=>select(d, i)));
+    const BP = B.concat(P);
+    return leastSquares(AP, BP);
+};
+// Verify if matrix is jordan normal on the diagonal
+const isJordanNormalDiagonal = (x)=>{
+    const [n, m] = dims(x);
+    const l = min(n, m);
+    for(let i = 0; i < l; ++i){
+        if (abs(x[i][i] - 1) > 1e-2) return false;
+    }
+    return true;
+};
+
+//# sourceMappingURL=linalg.js.map

package/cjs/linalg.d.cts

@@ -0,0 +1,4 @@
+export declare const solveLinearSystem: (A: number[][], B: number[]) => number[] | null;
+export declare const lagrangeMinimumTo: (A: number[][], B: number[], P: number[]) => [number[][], number[]];
+export declare const leastSquares: (A: number[][], B: number[]) => [number[][], number[]];
+export declare const leastSquaresClosest: (A: number[][], B: number[], P: number[]) => [number[][], number[]];

package/cjs/linalg.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/linalg.ts"],"sourcesContent":["import { Matrix } from './matrix';\nimport { seq } from './number';\n\nconst {abs, min} = Math;\nconst {concat, dims, fill, jordanNormal, mul, transpose} = Matrix;\n\n// Fill an array of length n with all zeros except a single v at index i\nconst select = (n: number, i = n - 1, v = 1) => seq(n).map(j => i == j ? v : 0);\n\n// Solve linear system of equations A X = B\nexport const solveLinearSystem = (A: number[][], B: number[]) => {\n  // eslint-disable-next-line\n  let [n, m] = dims(A);\n\n  // Diagonalize system of equations\n  let G = jordanNormal(concat(A, B));\n\n  // Filter out zero rows\n  G = G.filter(row => row.filter(x => x).length > 0);\n  n = G.length;\n\n  if (n > m) {\n    // Overdetermined, no solution\n    return null;\n  }\n\n  if (!isJordanNormalDiagonal(G)) {\n    // Underdetermined, no solution\n    return null;\n  }\n\n  if (n == m) {\n    // Extract exact solution\n    const v = seq(m).map(i => G[i][m]);\n    return v;\n  }\n\n  return null;\n}\n\n// Use lagrange multipliers to minimize distance to P subject to A X = B\nexport const lagrangeMinimumTo = (A: number[][], B: number[], P: number[]): [number[][], number[]] => {\n  const [n, m] = dims(A);\n\n  const M = concat(A, fill(n, n));\n  const T = seq(m).map(i => [\n    ...select(m, i, 2), ...seq(n).map(j => -A[j][i]),\n  ]);\n\n  const AL = [...M, ...T];\n  const BL = [...B, ...P.map(v => 2*v)];\n\n  return [AL, BL];\n}\n\n// Reduce overdetermined system to least squares equivalent\nexport const leastSquares = (A: number[][], B: number[]): [number[][], number[]] => {\n  const AT = transpose(A);\n\n  const ATA = mul(AT, A);\n  const ATB = mul([B], A)[0];\n\n  return [ATA, ATB];\n}\n\n// Reduce overdetermined system to least squares equivalent with attractor P\nexport const leastSquaresClosest = (A: number[][], B: number[], P: number[]): [number[][], number[]] => {\n  const d = P.length;\n\n  const AP = A.concat(seq(d).map(i => select(d, i)));\n  const BP = B.concat(P);\n\n  return leastSquares(AP, BP);\n}\n\n// Verify if matrix is jordan normal on the diagonal\nconst isJordanNormalDiagonal = (x: number[][]) => {\n  const [n, m] = dims(x);\n  const l = min(n, m);\n\n  for (let i = 0; i < l; ++i) {\n    if (abs(x[i][i] - 1) > 1e-2) return false;\n  }\n  return true;\n}\n"],"names":["lagrangeMinimumTo","leastSquares","leastSquaresClosest","solveLinearSystem","abs","min","Math","concat","dims","fill","jordanNormal","mul","transpose","Matrix","select","n","i","v","seq","map","j","A","B","m","G","filter","row","x","length","isJordanNormalDiagonal","P","M","T","AL","BL","AT","ATA","ATB","d","AP","BP","l"],"mappings":";;;;;;;;;;;QAyCaA;eAAAA;;QAeAC;eAAAA;;QAUAC;eAAAA;;QAxDAC;eAAAA;;;wBAVU;wBACH;AAEpB,MAAM,EAACC,GAAG,EAAEC,GAAG,EAAC,GAAGC;AACnB,MAAM,EAACC,MAAM,EAAEC,IAAI,EAAEC,IAAI,EAAEC,YAAY,EAAEC,GAAG,EAAEC,SAAS,EAAC,GAAGC,cAAM;AAEjE,wEAAwE;AACxE,MAAMC,SAAS,CAACC,GAAWC,IAAID,IAAI,CAAC,EAAEE,IAAI,CAAC,GAAKC,IAAAA,WAAG,EAACH,GAAGI,GAAG,CAACC,CAAAA,IAAKJ,KAAKI,IAAIH,IAAI;AAGtE,MAAMd,oBAAoB,CAACkB,GAAeC;IAC/C,2BAA2B;IAC3B,IAAI,CAACP,GAAGQ,EAAE,GAAGf,KAAKa;IAElB,kCAAkC;IAClC,IAAIG,IAAId,aAAaH,OAAOc,GAAGC;IAE/B,uBAAuB;IACvBE,IAAIA,EAAEC,MAAM,CAACC,CAAAA,MAAOA,IAAID,MAAM,CAACE,CAAAA,IAAKA,GAAGC,MAAM,GAAG;IAChDb,IAAIS,EAAEI,MAAM;IAEZ,IAAIb,IAAIQ,GAAG;QACT,8BAA8B;QAC9B,OAAO;IACT;IAEA,IAAI,CAACM,uBAAuBL,IAAI;QAC9B,+BAA+B;QAC/B,OAAO;IACT;IAEA,IAAIT,KAAKQ,GAAG;QACV,yBAAyB;QACzB,MAAMN,IAAIC,IAAAA,WAAG,EAACK,GAAGJ,GAAG,CAACH,CAAAA,IAAKQ,CAAC,CAACR,EAAE,CAACO,EAAE;QACjC,OAAON;IACT;IAEA,OAAO;AACT;AAGO,MAAMjB,oBAAoB,CAACqB,GAAeC,GAAaQ;IAC5D,MAAM,CAACf,GAAGQ,EAAE,GAAGf,KAAKa;IAEpB,MAAMU,IAAIxB,OAAOc,GAAGZ,KAAKM,GAAGA;IAC5B,MAAMiB,IAAId,IAAAA,WAAG,EAACK,GAAGJ,GAAG,CAACH,CAAAA,IAAK;eACrBF,OAAOS,GAAGP,GAAG;eAAOE,IAAAA,WAAG,EAACH,GAAGI,GAAG,CAACC,CAAAA,IAAK,CAACC,CAAC,CAACD,EAAE,CAACJ,EAAE;SAChD;IAED,MAAMiB,KAAK;WAAIF;WAAMC;KAAE;IACvB,MAAME,KAAK;WAAIZ;WAAMQ,EAAEX,GAAG,CAACF,CAAAA,IAAK,IAAEA;KAAG;IAErC,OAAO;QAACgB;QAAIC;KAAG;AACjB;AAGO,MAAMjC,eAAe,CAACoB,GAAeC;IAC1C,MAAMa,KAAKvB,UAAUS;IAErB,MAAMe,MAAMzB,IAAIwB,IAAId;IACpB,MAAMgB,MAAM1B,IAAI;QAACW;KAAE,EAAED,EAAE,CAAC,EAAE;IAE1B,OAAO;QAACe;QAAKC;KAAI;AACnB;AAGO,MAAMnC,sBAAsB,CAACmB,GAAeC,GAAaQ;IAC9D,MAAMQ,IAAIR,EAAEF,MAAM;IAElB,MAAMW,KAAKlB,EAAEd,MAAM,CAACW,IAAAA,WAAG,EAACoB,GAAGnB,GAAG,CAACH,CAAAA,IAAKF,OAAOwB,GAAGtB;IAC9C,MAAMwB,KAAKlB,EAAEf,MAAM,CAACuB;IAEpB,OAAO7B,aAAasC,IAAIC;AAC1B;AAEA,oDAAoD;AACpD,MAAMX,yBAAyB,CAACF;IAC9B,MAAM,CAACZ,GAAGQ,EAAE,GAAGf,KAAKmB;IACpB,MAAMc,IAAIpC,IAAIU,GAAGQ;IAEjB,IAAK,IAAIP,IAAI,GAAGA,IAAIyB,GAAG,EAAEzB,EAAG;QAC1B,IAAIZ,IAAIuB,CAAC,CAACX,EAAE,CAACA,EAAE,GAAG,KAAK,MAAM,OAAO;IACtC;IACA,OAAO;AACT"}

package/cjs/math.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 } = Math;
+const π = Math.PI;
+const τ = 2 * π;
+const clamp = (x, a, b)=>max(a, Math.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=math.js.map

package/cjs/math.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/math/src/math.ts"],"sourcesContent":["export type XY = [number, number];\nexport type XYZ = [number, number, number];\nexport type XYZW = [number, number, number, number];\n\nconst { max } = Math;\n\nexport const π = Math.PI;\nexport const τ = 2*π;\n\nexport const clamp = (x: number, a: number, b: number) => max(a, Math.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","Math","PI","x","a","b","min","t","d","n","start","step","Array","from","length","map","_","i"],"mappings":";;;;;;;;;;;QASaA;eAAAA;;QAMAC;eAAAA;;QAJAC;eAAAA;;QAGAC;eAAAA;;QAMAC;eAAAA;;QARAC;eAAAA;;QANAC;eAAAA;;QACAC;eAAAA;;;AAHb,MAAM,EAAEC,GAAG,EAAE,GAAGC;AAET,MAAMH,IAAIG,KAAKC,EAAE;AACjB,MAAMH,IAAI,IAAED;AAEZ,MAAMN,QAAQ,CAACW,GAAWC,GAAWC,IAAcL,IAAII,GAAGH,KAAKK,GAAG,CAACD,GAAGF;AAEtE,MAAMT,MAAM,CAACS,IAAcA,IAAIA,IAAIA;AACnC,MAAMN,MAAM,CAACM,IAAcA,IAAIA;AAE/B,MAAMR,OAAO,CAACS,GAAWC,GAAWE,IAAcH,IAAK,CAAA,IAAIG,CAAAA,IAAKF,IAAIE;AACpE,MAAMd,QAAQ,CAACW,GAAWC,GAAWE;IAC1C,MAAMC,IAAI,AAAGH,CAAAA,IAAID,IAAIN,CAAA,IAAKC,IAAK,IAAKA,IAAID;IACxC,OAAOH,KAAKS,GAAGA,IAAII,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"}