@danielsimonjr/mathts-functions 0.65.0 → 0.67.0

package/dist/index.js

@@ -24,6 +24,10 @@ __export(typed_exports, {
   CENTRALITY_WORKER_THRESHOLD: () => CENTRALITY_WORKER_THRESHOLD,
   DIST_WORKER_THRESHOLD: () => DIST_WORKER_THRESHOLD,
   GAUSS_WORKER_THRESHOLD: () => GAUSS_WORKER_THRESHOLD,
+  GL4ConvergenceError: () => GL4ConvergenceError,
+  GL4_A: () => GL4_A,
+  GL4_B: () => GL4_B,
+  GL4_C: () => GL4_C,
   GPU_ELEMENTWISE_OPS: () => GPU_ELEMENTWISE_OPS,
   GPU_MIN_ELEMENTS: () => GPU_MIN_ELEMENTS2,
   GPU_REDUCE_OPS: () => GPU_REDUCE_OPS,
@@ -206,6 +210,7 @@ __export(typed_exports, {
   gammaPDF: () => gammaPDF,
   gammainc: () => gammainc,
   gammaincp: () => gammaincp,
+  gaussLegendre4: () => gaussLegendre4,
   gaussQuad: () => gaussQuad,
   gcd: () => gcd,
   geometricPMF: () => geometricPMF,
@@ -397,6 +402,7 @@ __export(typed_exports, {
   random: () => random,
   randomInt: () => randomInt,
   rank: () => rank,
+  rationalNullspace: () => rationalNullspace,
   rayleighDist: () => rayleighDist,
   rbfInterpolate: () => rbfInterpolate,
   re: () => re,
@@ -1683,6 +1689,8 @@ var pow = mathTyped2("pow", {
   // Dual numbers (forward-mode AD): constant or variable exponent.
   "Dual, number": (a, b) => a.powConst(b),
   "Dual, Dual": (a, b) => a.pow(b),
+  // Dimensional power, including physics-mode `e^2` (elementary charge squared).
+  "Unit, number": (a, b) => a.pow(b),
   // Matrix power A^n for a square 2-D array and non-negative integer n, via binary
   // exponentiation on the native DenseMatrix backend (accelerated matmul, B2). Element-
   // wise power is `dotPow`; negative/fractional matrix powers need eigendecomposition —
@@ -11119,8 +11127,8 @@ function integerPolynomialGCD(a, b) {
   return g.map((c) => Number(c) / lead);
 }
 function polynomialLCM(a, b) {
-  const gcd2 = polynomialGCD(a, b);
-  const [quotient] = polyDivMod(polymul(a, b), gcd2);
+  const gcd3 = polynomialGCD(a, b);
+  const [quotient] = polyDivMod(polymul(a, b), gcd3);
   const leading = quotient[quotient.length - 1];
   if (leading !== 0 && leading !== 1) {
     return quotient.map((c) => c / leading);
@@ -14116,6 +14124,126 @@ function quad(f, a, b, opts) {
   return panel(a, b, 0);
 }
 
+// src/numeric/rational-nullspace.ts
+import { Fraction as Fraction2, isFraction as isFraction2 } from "@danielsimonjr/mathts-core";
+function gcd2(a, b) {
+  let x = a < 0n ? -a : a;
+  let y = b < 0n ? -b : b;
+  while (y !== 0n) {
+    const t = y;
+    y = x % y;
+    x = t;
+  }
+  return x;
+}
+function lcm2(a, b) {
+  if (a === 0n || b === 0n) return 0n;
+  return a / gcd2(a, b) * b;
+}
+function entryToFraction(value, row2, col) {
+  if (isFraction2(value)) return value;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(
+      `rationalNullspace: entry [${row2}, ${col}] must be a finite number or a Fraction`
+    );
+  }
+  return Number.isInteger(value) ? new Fraction2(value, 1) : Fraction2.fromNumber(value);
+}
+function integerize(vec) {
+  let scale4 = 1n;
+  for (const f of vec) {
+    if (f.numerator !== 0n) scale4 = lcm2(scale4, f.denominator);
+  }
+  const ints = vec.map((f) => f.numerator * scale4 / f.denominator);
+  let content2 = 0n;
+  for (const x of ints) {
+    if (x !== 0n) content2 = gcd2(content2, x);
+  }
+  if (content2 === 0n) content2 = 1n;
+  const reduced = ints.map((x) => x / content2);
+  const first = reduced.find((x) => x !== 0n) ?? 0n;
+  const sign3 = first < 0n ? -1n : 1n;
+  return reduced.map((x) => new Fraction2(sign3 * x, 1n));
+}
+function rref(matrix2) {
+  const rows = matrix2.length;
+  const cols = rows === 0 ? 0 : matrix2[0].length;
+  const pivotCols = [];
+  let r = 0;
+  for (let c = 0; c < cols && r < rows; c++) {
+    let pivotRow = -1;
+    for (let i = r; i < rows; i++) {
+      if (matrix2[i][c].numerator !== 0n) {
+        pivotRow = i;
+        break;
+      }
+    }
+    if (pivotRow === -1) continue;
+    if (pivotRow !== r) {
+      const swap = matrix2[r];
+      matrix2[r] = matrix2[pivotRow];
+      matrix2[pivotRow] = swap;
+    }
+    const pivot = matrix2[r][c];
+    for (let j = 0; j < cols; j++) matrix2[r][j] = matrix2[r][j].div(pivot);
+    for (let i = 0; i < rows; i++) {
+      if (i === r || matrix2[i][c].numerator === 0n) continue;
+      const factor2 = matrix2[i][c];
+      for (let j = 0; j < cols; j++) {
+        matrix2[i][j] = matrix2[i][j].sub(factor2.mul(matrix2[r][j]));
+      }
+    }
+    pivotCols.push(c);
+    r++;
+  }
+  return pivotCols;
+}
+function rationalNullspace(matrix2, options) {
+  if (matrix2.length === 0) {
+    const cols2 = options?.columns ?? 0;
+    if (!Number.isInteger(cols2) || cols2 < 0) {
+      throw new TypeError("rationalNullspace: columns must be a non-negative integer");
+    }
+    const basis2 = [];
+    for (let free = 0; free < cols2; free++) {
+      const vec = [];
+      for (let j = 0; j < cols2; j++) vec.push(new Fraction2(j === free ? 1n : 0n, 1n));
+      basis2.push(vec);
+    }
+    return { basis: basis2, rank: 0 };
+  }
+  const cols = matrix2[0].length;
+  if (options?.columns !== void 0 && options.columns !== cols) {
+    throw new TypeError(
+      `rationalNullspace: columns ${options.columns} does not match row length ${cols}`
+    );
+  }
+  for (let i = 0; i < matrix2.length; i++) {
+    if (!Array.isArray(matrix2[i]) || matrix2[i].length !== cols) {
+      throw new TypeError(
+        `rationalNullspace: row ${i} has length ${matrix2[i]?.length ?? "n/a"}; expected ${cols}`
+      );
+    }
+  }
+  const reduced = matrix2.map((row2, i) => row2.map((value, j) => entryToFraction(value, i, j)));
+  const pivotCols = rref(reduced);
+  const pivotSet = new Set(pivotCols);
+  const basis = [];
+  const zero = new Fraction2(0n, 1n);
+  const one = new Fraction2(1n, 1n);
+  for (let free = 0; free < cols; free++) {
+    if (pivotSet.has(free)) continue;
+    const vec = new Array(cols);
+    for (let j = 0; j < cols; j++) vec[j] = zero;
+    vec[free] = one;
+    for (let i = 0; i < pivotCols.length; i++) {
+      vec[pivotCols[i]] = zero.sub(reduced[i][free]);
+    }
+    basis.push(integerize(vec));
+  }
+  return { basis, rank: pivotCols.length };
+}
+
 // src/numeric/solveParabolicPDE.ts
 function asSpaceFn(c, dflt) {
   if (c === void 0) return () => dflt;
@@ -14681,6 +14809,129 @@ function solveDDE(f, tspan, history, delays, options = {}) {
   };
 }
 
+// src/numeric/gauss-legendre4.ts
+var SQRT3_OVER_6 = Math.sqrt(3) / 6;
+var GL4_C = [0.5 - SQRT3_OVER_6, 0.5 + SQRT3_OVER_6];
+var GL4_A = [
+  [0.25, 0.25 - SQRT3_OVER_6],
+  [0.25 + SQRT3_OVER_6, 0.25]
+];
+var GL4_B = [0.5, 0.5];
+var GL4ConvergenceError = class extends Error {
+  constructor(message = "Picard iteration did not converge") {
+    super(message);
+    this.name = "GL4ConvergenceError";
+  }
+};
+function assertFiniteVector(label, v) {
+  for (let i = 0; i < v.length; i++) {
+    if (!Number.isFinite(v[i])) {
+      throw new TypeError(`${label}[${i}] must be a finite number`);
+    }
+  }
+}
+function gaussLegendre4(f, y0, tspan, options) {
+  if (y0.length === 0) {
+    throw new TypeError("y0 must be a non-empty vector");
+  }
+  assertFiniteVector("y0", y0);
+  const t0 = tspan[0];
+  const t1 = tspan[1];
+  if (!Number.isFinite(t0) || !Number.isFinite(t1)) {
+    throw new TypeError("tspan entries must be finite numbers");
+  }
+  const picardTol = options?.picardTol ?? 1e-12;
+  const picardMaxIter = options?.picardMaxIter ?? 64;
+  if (!(picardTol > 0) || !Number.isFinite(picardTol)) {
+    throw new TypeError("picardTol must be a positive finite number");
+  }
+  if (!Number.isInteger(picardMaxIter) || picardMaxIter < 1) {
+    throw new TypeError("picardMaxIter must be a positive integer");
+  }
+  if (t0 === t1) {
+    return { t: [t0], y: [y0.slice()], iterations: [] };
+  }
+  const span = t1 - t0;
+  let nSteps;
+  if (options?.steps !== void 0) {
+    nSteps = options.steps;
+    if (!Number.isInteger(nSteps) || nSteps < 1) {
+      throw new TypeError("steps must be a positive integer");
+    }
+  } else if (options?.h !== void 0) {
+    const hAbs = options.h;
+    if (!(hAbs > 0) || !Number.isFinite(hAbs)) {
+      throw new TypeError("h must be a positive finite number");
+    }
+    nSteps = Math.max(1, Math.ceil(Math.abs(span) / hAbs));
+  } else {
+    nSteps = 100;
+  }
+  const h = span / nSteps;
+  const n = y0.length;
+  const c0 = GL4_C[0];
+  const c1 = GL4_C[1];
+  const a00 = GL4_A[0][0];
+  const a01 = GL4_A[0][1];
+  const a10 = GL4_A[1][0];
+  const a11 = GL4_A[1][1];
+  const b0 = GL4_B[0];
+  const b1 = GL4_B[1];
+  const t = [t0];
+  const y = [y0.slice()];
+  const iterations = [];
+  let tn = t0;
+  let yn = y0.slice();
+  for (let step = 0; step < nSteps; step++) {
+    let Y0 = yn.slice();
+    let Y1 = yn.slice();
+    let converged = false;
+    let used = 0;
+    const next = new Array(n);
+    for (let iter = 0; iter < picardMaxIter; iter++) {
+      used = iter + 1;
+      const k0 = f(tn + c0 * h, Y0);
+      const k1 = f(tn + c1 * h, Y1);
+      if (k0.length !== n || k1.length !== n) {
+        throw new TypeError(`f must return a vector of length ${n}`);
+      }
+      assertFiniteVector("f(t, y)", k0);
+      assertFiniteVector("f(t, y)", k1);
+      let maxDiff = 0;
+      const nY0 = new Array(n);
+      const nY1 = new Array(n);
+      for (let i = 0; i < n; i++) {
+        nY0[i] = yn[i] + h * (a00 * k0[i] + a01 * k1[i]);
+        nY1[i] = yn[i] + h * (a10 * k0[i] + a11 * k1[i]);
+        const d0 = Math.abs(nY0[i] - Y0[i]);
+        const d1 = Math.abs(nY1[i] - Y1[i]);
+        if (d0 > maxDiff) maxDiff = d0;
+        if (d1 > maxDiff) maxDiff = d1;
+      }
+      Y0 = nY0;
+      Y1 = nY1;
+      if (maxDiff <= picardTol) {
+        for (let i = 0; i < n; i++) {
+          next[i] = yn[i] + h * (b0 * k0[i] + b1 * k1[i]);
+        }
+        converged = true;
+        break;
+      }
+    }
+    if (!converged) {
+      throw new GL4ConvergenceError(
+        `Picard iteration did not converge within ${picardMaxIter} iterations (step h=${h})`
+      );
+    }
+    tn += h;
+    yn = next;
+    t.push(tn);
+    y.push(yn.slice());
+    iterations.push(used);
+  }
+  return { t, y, iterations };
+}
+
 // src/typed/numeric.ts
 function findRoot(f, a, b, opts) {
   const tol = opts?.tol ?? 1e-12;
@@ -19545,12 +19796,12 @@ function rowReduce(A, tol = 1e-10) {
   return M;
 }
 function matrixRank(A, tol = 1e-10) {
-  const rref = rowReduce(A, tol);
+  const rref2 = rowReduce(A, tol);
   let r = 0;
-  for (let i = 0; i < rref.length; i++) {
+  for (let i = 0; i < rref2.length; i++) {
     let nonzero = false;
-    for (let j = 0; j < rref[i].length; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
+    for (let j = 0; j < rref2[i].length; j++) {
+      if (Math.abs(rref2[i][j]) > tol) {
         nonzero = true;
         break;
       }
@@ -19890,11 +20141,11 @@ async function jordanForm(A) {
   return { J, P: P2 };
 }
 function matrixRankInternal(A, tol) {
-  const rref = rowReduce(A, tol);
+  const rref2 = rowReduce(A, tol);
   let r = 0;
-  for (let i = 0; i < rref.length; i++) {
-    for (let j = 0; j < rref[i].length; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
+  for (let i = 0; i < rref2.length; i++) {
+    for (let j = 0; j < rref2[i].length; j++) {
+      if (Math.abs(rref2[i][j]) > tol) {
         r++;
         break;
       }
@@ -19954,11 +20205,11 @@ async function buildJordanBlocks(A, lambda, algebraicMult, geoMult, n, tol) {
   return blocks;
 }
 function findKernelVector(A, n, tol) {
-  const rref = rowReduce(A, tol);
+  const rref2 = rowReduce(A, tol);
   const pivotCols = /* @__PURE__ */ new Set();
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
+      if (Math.abs(rref2[i][j]) > tol) {
         pivotCols.add(j);
         break;
       }
@@ -19980,8 +20231,8 @@ function findKernelVector(A, n, tol) {
   v[freeCol] = 1;
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      if (Math.abs(rref[i][j]) > tol) {
-        v[j] = -rref[i][freeCol];
+      if (Math.abs(rref2[i][j]) > tol) {
+        v[j] = -rref2[i][freeCol];
         break;
       }
     }
@@ -20114,7 +20365,7 @@ import { enableGpu, disableGpu, isGpuEnabled as isGpuEnabled3, GPU_MIN_ELEMENTS
 
 // src/typed/relational.ts
 import naturalSort from "javascript-natural-sort";
-import { mathTyped as mathTyped14, Complex as Complex6, BigNumber as BigNumber6, Fraction as Fraction2 } from "@danielsimonjr/mathts-core";
+import { mathTyped as mathTyped14, Complex as Complex6, BigNumber as BigNumber6, Fraction as Fraction3 } from "@danielsimonjr/mathts-core";
 var REL_TOL = 1e-12;
 var ABS_TOL = 1e-15;
 function numbersNearlyEqual(x, y) {
@@ -20138,7 +20389,7 @@ function typeNameOf(x) {
   if (typeof x === "string") return "string";
   if (x instanceof Complex6) return "Complex";
   if (x instanceof BigNumber6) return "BigNumber";
-  if (x instanceof Fraction2) return "Fraction";
+  if (x instanceof Fraction3) return "Fraction";
   if (Array.isArray(x)) return "Array";
   if (typeof x === "object") return "Object";
   return typeof x;
@@ -20276,7 +20527,7 @@ function _numericCompare(x, y) {
   let ny;
   if (x instanceof BigNumber6) {
     nx = x.toNumber();
-  } else if (x instanceof Fraction2) {
+  } else if (x instanceof Fraction3) {
     nx = x.valueOf();
   } else if (typeof x === "bigint") {
     nx = Number(x);
@@ -20285,7 +20536,7 @@ function _numericCompare(x, y) {
   }
   if (y instanceof BigNumber6) {
     ny = y.toNumber();
-  } else if (y instanceof Fraction2) {
+  } else if (y instanceof Fraction3) {
     ny = y.valueOf();
   } else if (typeof y === "bigint") {
     ny = Number(y);
@@ -20705,7 +20956,7 @@ import {
 } from "@danielsimonjr/mathts-expression";
 import {
   Complex as Complex9,
-  Fraction as Fraction4,
+  Fraction as Fraction5,
   I,
   PHI,
   SQRT2,
@@ -20713,11 +20964,12 @@ import {
   LN2 as LN22,
   LN10,
   LOG2E,
-  LOG10E
+  LOG10E,
+  Unit as Unit2
 } from "@danielsimonjr/mathts-core";
 
 // src/factories/scope.ts
-import { mathTyped as mathTyped18, Complex as Complex7, Fraction as Fraction3, BigNumber as BigNumber8 } from "@danielsimonjr/mathts-core";
+import { mathTyped as mathTyped18, Complex as Complex7, Fraction as Fraction4, BigNumber as BigNumber8 } from "@danielsimonjr/mathts-core";
 
 // src/typed/typed-bridge.ts
 import { registerNativeTypes } from "@danielsimonjr/mathts-core";
@@ -20832,7 +21084,7 @@ var factoryScope = {
   // Class constructors (uppercase) — factories use `new BigNumber(...)` etc.
   Complex: Complex7,
   BigNumber: BigNumber8,
-  Fraction: Fraction3,
+  Fraction: Fraction4,
   // Matrix bridge classes
   DenseMatrix: MathJSDenseMatrix,
   SparseMatrix: MathJSSparseMatrix,
@@ -20846,7 +21098,7 @@ var factoryScope = {
     if (typeof x === "number") return BigNumber8.fromNumber(x);
     return BigNumber8.fromNumber(Number(x.valueOf()));
   },
-  fraction: (n, d) => new Fraction3(n, d ?? 1),
+  fraction: (n, d) => new Fraction4(n, d ?? 1),
   number: Number,
   // Matrix helper factories
   createDenseMatrix: (data) => new MathJSDenseMatrix(data),
@@ -21372,7 +21624,7 @@ var dependencies10 = ["typed", "BigNumber", "complex", "Fraction"];
 var createSign = /* @__PURE__ */ factory(
   name10,
   dependencies10,
-  ({ typed: typed3, BigNumber: BigNumber9, complex: complex3, Fraction: Fraction5 }) => {
+  ({ typed: typed3, BigNumber: BigNumber9, complex: complex3, Fraction: Fraction6 }) => {
     return typed3(name10, {
       number: signNumber,
       Complex: function(x) {
@@ -21385,7 +21637,7 @@ var createSign = /* @__PURE__ */ factory(
         return x > 0n ? 1n : x < 0n ? -1n : 0n;
       },
       Fraction: function(x) {
-        return x.n === 0n ? new Fraction5(0) : new Fraction5(x.s);
+        return x.n === 0n ? new Fraction6(0) : new Fraction6(x.s);
       },
       // deep map collection, skip zeros since sign(0) = 0
       "Array | Matrix": typed3.referToSelf(
@@ -26861,7 +27113,7 @@ var createCbrt = /* @__PURE__ */ factory(
     matrix: matrix2,
     Complex: Complex13,
     BigNumber: BigNumber9,
-    Fraction: Fraction5
+    Fraction: Fraction6
   }) => {
     return typed3(name106, {
       number: cbrtNumber,
@@ -26919,7 +27171,7 @@ var createCbrt = /* @__PURE__ */ factory(
       if (isBigNumber(value)) {
         return new BigNumber9(1).div(3);
       } else if (isFraction(value)) {
-        return new Fraction5(1, 3);
+        return new Fraction6(1, 3);
       } else {
         return 1 / 3;
       }
@@ -27360,7 +27612,7 @@ var dependencies112 = ["typed", "config", "matrix", "BigNumber", "?Fraction"];
 var createXgcd = /* @__PURE__ */ factory(
   name112,
   dependencies112,
-  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9, Fraction: Fraction5 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9, Fraction: Fraction6 }) => {
     const typedSignatures = {
       "number, number": function(a, b) {
         const res = xgcdNumber(a, b);
@@ -27368,7 +27620,7 @@ var createXgcd = /* @__PURE__ */ factory(
       },
       "BigNumber, BigNumber": _xgcdBigNumber
     };
-    if (Fraction5) {
+    if (Fraction6) {
       typedSignatures["Fraction, Fraction"] = _xgcdFraction;
     }
     return typed3(name112, typedSignatures);
@@ -27406,14 +27658,14 @@ var createXgcd = /* @__PURE__ */ factory(
       return config2.matrix === "Array" ? res : matrix2(res);
     }
     function _xgcdFraction(a, b) {
-      if (!Fraction5) {
+      if (!Fraction6) {
         throw new Error("Fraction is not available");
       }
       let t;
       let q;
       let r;
-      const zero = new Fraction5(0);
-      const one = new Fraction5(1);
+      const zero = new Fraction6(0);
+      const one = new Fraction6(1);
       let x = zero;
       let lastx = one;
       let y = one;
@@ -28147,7 +28399,7 @@ var createBernoulli = /* @__PURE__ */ factory(
     isInteger: _isInteger,
     number: number2,
     BigNumber: BigNumber9,
-    Fraction: Fraction5
+    Fraction: Fraction6
   }) => {
     const numberCache = [void 0];
     const fractionCache = [void 0];
@@ -28164,7 +28416,7 @@ var createBernoulli = /* @__PURE__ */ factory(
       ),
       "bigint | Fraction": (index) => _bernoulli(
         number2(index),
-        (n) => new Fraction5(n),
+        (n) => new Fraction6(n),
         fractionCache,
         (a, b) => a.add(b),
         (a, b) => a.mul(b),
@@ -31009,7 +31261,7 @@ var createCompare = /* @__PURE__ */ factory(
     equalScalar: equalScalar3,
     matrix: matrix2,
     BigNumber: BigNumber9,
-    Fraction: Fraction5,
+    Fraction: Fraction6,
     DenseMatrix: DenseMatrix7,
     concat: concat3
   }) => {
@@ -31037,7 +31289,7 @@ var createCompare = /* @__PURE__ */ factory(
           return x === y ? 0n : x > y ? 1n : -1n;
         },
         "Fraction, Fraction": function(x, y) {
-          return new Fraction5(x.compare(y));
+          return new Fraction6(x.compare(y));
         },
         "Complex, Complex": function() {
           throw new TypeError("No ordering relation is defined for complex numbers");
@@ -31713,8 +31965,8 @@ var createInvmod = /* @__PURE__ */ factory(
       if (equal2(b, 0)) throw new Error("Divisor must be non zero");
       const res = xgcd2(a, b);
       const resVal = res.valueOf();
-      const [gcd2, invValue] = resVal;
-      if (!equal2(gcd2, 1)) return NaN;
+      const [gcd3, invValue] = resVal;
+      if (!equal2(gcd3, 1)) return NaN;
       let inv3 = mod3(invValue, b);
       if (smaller2(inv3, 0)) inv3 = add5(inv3, b);
       return inv3;
@@ -32055,9 +32307,9 @@ var createPinv = /* @__PURE__ */ factory(
       return M;
     }
     function _rankFact(mat, rows, cols) {
-      const rref = _rref(mat, rows, cols);
-      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot9(rref[j], rref[j]))));
-      const F = rref.filter((_, i) => !_isZero(dot9(rref[i], rref[i])));
+      const rref2 = _rref(mat, rows, cols);
+      const C = mat.map((row2) => row2.filter((_, j) => j < rows && !_isZero(dot9(rref2[j], rref2[j]))));
+      const F = rref2.filter((_, i) => !_isZero(dot9(rref2[i], rref2[i])));
       return { C, F };
     }
     function _isZero(x) {
@@ -35173,33 +35425,33 @@ var dependencies203 = ["typed", "Unit"];
 var createCreateUnit = /* @__PURE__ */ factory(
   name203,
   dependencies203,
-  ({ typed: typed3, Unit: Unit2 }) => {
+  ({ typed: typed3, Unit: Unit3 }) => {
     return typed3(name203, {
       // General function signature. First parameter is an object where each property is the definition of a new unit. The object keys are the unit names and the values are the definitions. The values can be objects, strings, or Units. If a property is an empty object or an empty string, a new base unit is created. The second parameter is the options.
       "Object, Object": function(obj, options) {
-        return Unit2.createUnit(obj, options);
+        return Unit3.createUnit(obj, options);
       },
       // Same as above but without the options.
       Object: function(obj) {
-        return Unit2.createUnit(obj, {});
+        return Unit3.createUnit(obj, {});
       },
       // Shortcut method for creating one unit.
       "string, Unit | string | Object, Object": function(name254, def, options) {
         const obj = {};
         obj[name254] = def;
-        return Unit2.createUnit(obj, options);
+        return Unit3.createUnit(obj, options);
       },
       // Same as above but without the options.
       "string, Unit | string | Object": function(name254, def) {
         const obj = {};
         obj[name254] = def;
-        return Unit2.createUnit(obj, {});
+        return Unit3.createUnit(obj, {});
       },
       // Without a definition, creates a base unit.
       string: function(name254) {
         const obj = {};
         obj[name254] = {};
-        return Unit2.createUnit(obj, {});
+        return Unit3.createUnit(obj, {});
       }
     });
   }
@@ -35211,22 +35463,22 @@ var dependencies204 = ["typed", "Unit"];
 var createUnitFunction = /* @__PURE__ */ factory(
   name204,
   dependencies204,
-  ({ typed: typed3, Unit: Unit2 }) => {
+  ({ typed: typed3, Unit: Unit3 }) => {
     return typed3(name204, {
       Unit: function(x) {
         return x.clone();
       },
       string: function(x) {
-        if (Unit2.isValuelessUnit(x)) {
-          return new Unit2(null, x);
+        if (Unit3.isValuelessUnit(x)) {
+          return new Unit3(null, x);
         }
-        return Unit2.parse(x, { allowNoUnits: true });
+        return Unit3.parse(x, { allowNoUnits: true });
       },
       "number | BigNumber | Fraction | Complex, string | Unit": function(value, unit2) {
-        return new Unit2(value, unit2);
+        return new Unit3(value, unit2);
       },
       "number | BigNumber | Fraction": function(value) {
-        return new Unit2(value);
+        return new Unit3(value);
       },
       "Array | Matrix": typed3.referToSelf(
         (self) => (x) => deepMap(x, self)
@@ -42614,9 +42866,9 @@ function unitFactory(name254, valueStr, unitStr) {
   return factory(
     name254,
     dependencies254,
-    ({ config: config2, Unit: Unit2, BigNumber: BigNumber9 }) => {
+    ({ config: config2, Unit: Unit3, BigNumber: BigNumber9 }) => {
       const value = config2.number === "BigNumber" ? new BigNumber9(valueStr) : parseFloat(valueStr);
-      const unit2 = new Unit2(value, unitStr);
+      const unit2 = new Unit3(value, unitStr);
       unit2.fixPrefix = true;
       return unit2;
     }
@@ -43559,18 +43811,81 @@ var mathScope = {
   }
 }
 var parse = factoryScope.parse;
-var evaluate = createEvaluate(parse, mathScope);
-function compileExpr(expr) {
-  return _compileExpression(parse, mathScope, expr);
+var _evaluate = createEvaluate(parse, mathScope);
+var ELEMENTARY_CHARGE_COULOMB = 1602176634e-28;
+function elementaryChargeUnit() {
+  return new Unit2(ELEMENTARY_CHARGE_COULOMB, "C");
+}
+function isMapScope(scope) {
+  const candidate = scope;
+  return typeof candidate.has === "function" && typeof candidate.get === "function" && typeof candidate.set === "function";
+}
+function physicsBinding(charge) {
+  return charge === "scalar" ? ELEMENTARY_CHARGE_COULOMB : elementaryChargeUnit();
+}
+function physicsScope(scope, options) {
+  const charge = physicsBinding(options?.charge);
+  if (scope == null) return { e: charge };
+  if (isMapScope(scope)) {
+    if (scope.has("e")) return scope;
+    return {
+      has(key2) {
+        return key2 === "e" || scope.has(key2);
+      },
+      get(key2) {
+        return key2 === "e" ? charge : scope.get(key2);
+      },
+      set(key2, value) {
+        scope.set(key2, value);
+      }
+    };
+  }
+  if (Object.prototype.hasOwnProperty.call(scope, "e")) return scope;
+  return { e: charge, ...scope };
 }
-function parser() {
+function assertPhysicsOptions(options) {
+  if (options?.charge !== void 0 && options.charge !== "unit" && options.charge !== "scalar") {
+    throw new TypeError('charge must be "unit" or "scalar"');
+  }
+  if (options?.physics !== true) {
+    if (options?.charge !== void 0) {
+      throw new TypeError("charge requires { physics: true }");
+    }
+    return void 0;
+  }
+  return { charge: options.charge ?? "unit" };
+}
+function evaluate(exprOrExprs, scope, options) {
+  const physics = assertPhysicsOptions(options);
+  const bound = physics === void 0 ? scope : physicsScope(scope, physics);
+  const inner = options?.unsafe === true ? { unsafe: true } : void 0;
+  if (Array.isArray(exprOrExprs)) return _evaluate(exprOrExprs, bound, inner);
+  return _evaluate(exprOrExprs, bound, inner);
+}
+function compileExpr(expr, options) {
+  const compiled = _compileExpression(
+    parse,
+    mathScope,
+    expr,
+    options?.unsafe === true ? { unsafe: true } : void 0
+  );
+  const physics = assertPhysicsOptions(options);
+  if (physics === void 0) return compiled;
+  return {
+    evaluate(scope) {
+      return compiled.evaluate(physicsScope(scope, physics));
+    }
+  };
+}
+function parser(options) {
   const scope = {};
+  const callOptions = options?.physics === true || options?.unsafe === true || options?.charge !== void 0 ? { physics: options?.physics, unsafe: options?.unsafe, charge: options?.charge } : void 0;
   return {
     /** The live scope object — assignments during `evaluate` land here. */
     scope,
     /** Evaluate an expression against the retained scope. */
     evaluate(expr) {
-      return evaluate(expr, scope);
+      return evaluate(expr, scope, callOptions);
     },
     /** Read a retained variable. */
     get(name254) {
@@ -43605,7 +43920,7 @@ function reviver(_key, value) {
       case "Complex":
         return Complex9.fromJSON(tagged);
       case "Fraction":
-        return Fraction4.fromJSON(tagged);
+        return Fraction5.fromJSON(tagged);
       case "number":
         if (tagged.value === "Infinity") return Infinity;
         if (tagged.value === "-Infinity") return -Infinity;
@@ -45144,6 +45459,147 @@ function config(options) {
   return { ...shared };
 }
 
+// src/numeric/propagate-uncertainty.ts
+function asFiniteNumber(label, value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new TypeError(`${label} is not a finite number`);
+  }
+  return value;
+}
+function partialDerivative2(expr, name254, values) {
+  const node = derivative2(expr, name254);
+  return asFiniteNumber(`partial of "${expr}" with respect to "${name254}"`, node.evaluate(values));
+}
+function centralPartial(f, name254, point, relativeStep) {
+  const x = point[name254];
+  const h = relativeStep * Math.max(Math.abs(x), 1e-30);
+  const plus = asFiniteNumber(
+    `partial of function with respect to "${name254}"`,
+    f({ ...point, [name254]: x + h })
+  );
+  const minus = asFiniteNumber(
+    `partial of function with respect to "${name254}"`,
+    f({ ...point, [name254]: x - h })
+  );
+  return (plus - minus) / (2 * h);
+}
+function curvatureRatio(evaluateAt, name254, point, partial, offset, value) {
+  if (!Number.isFinite(offset)) {
+    throw new TypeError(`curvatureOffsets.${name254} is not a finite number`);
+  }
+  const linear = partial * offset;
+  if (linear === 0) return null;
+  let up;
+  let down;
+  try {
+    up = evaluateAt({ ...point, [name254]: point[name254] + offset });
+    down = evaluateAt({ ...point, [name254]: point[name254] - offset });
+  } catch {
+    return null;
+  }
+  if (!Number.isFinite(up) || !Number.isFinite(down)) return null;
+  return Math.abs(up + down - 2 * value) / 2 / Math.abs(linear);
+}
+function propagateUncertainty(expr, values, sigmas, options) {
+  const isFunction = typeof expr === "function";
+  if (!isFunction && (typeof expr !== "string" || expr.length === 0)) {
+    throw new TypeError("expr must be a non-empty string or a function");
+  }
+  if (options?.relativeStep !== void 0 && !isFunction) {
+    throw new TypeError(
+      "relativeStep applies only to a function; a string uses the symbolic derivative"
+    );
+  }
+  const relativeStep = options?.relativeStep ?? 1e-6;
+  if (isFunction && (!(relativeStep > 0) || !Number.isFinite(relativeStep))) {
+    throw new TypeError("relativeStep must be a positive finite number");
+  }
+  if (values === null || typeof values !== "object") {
+    throw new TypeError("values must be an object of finite numbers");
+  }
+  const names = Object.keys(values);
+  const point = {};
+  for (const name254 of names) {
+    point[name254] = asFiniteNumber(`values.${name254}`, values[name254]);
+  }
+  const covariance = options?.covariance;
+  if (covariance !== void 0 && sigmas !== void 0) {
+    throw new TypeError("pass either sigmas or covariance, not both");
+  }
+  if (sigmas !== void 0 && (sigmas === null || typeof sigmas !== "object")) {
+    throw new TypeError("sigmas must be an object of finite numbers");
+  }
+  const partials = {};
+  const gradient2 = [];
+  const call = isFunction ? expr : void 0;
+  for (const name254 of names) {
+    const d = call ? centralPartial(call, name254, point, relativeStep) : partialDerivative2(expr, name254, point);
+    partials[name254] = d;
+    gradient2.push(d);
+  }
+  const value = asFiniteNumber("value", call ? call(point) : evaluate(expr, point));
+  let variance2;
+  if (covariance !== void 0) {
+    const n = names.length;
+    if (covariance.length !== n) {
+      throw new TypeError(`covariance must be ${n}\xD7${n} to match values`);
+    }
+    variance2 = 0;
+    for (let i = 0; i < n; i++) {
+      const row2 = covariance[i];
+      if (row2 === void 0 || row2.length !== n) {
+        throw new TypeError(`covariance must be ${n}\xD7${n} to match values`);
+      }
+      let acc = 0;
+      for (let j = 0; j < n; j++) {
+        const sij = asFiniteNumber(`covariance[${i}][${j}]`, row2[j]);
+        acc += sij * gradient2[j];
+      }
+      variance2 += gradient2[i] * acc;
+    }
+  } else {
+    variance2 = 0;
+    if (sigmas !== void 0) {
+      for (const key2 of Object.keys(sigmas)) {
+        if (!Object.prototype.hasOwnProperty.call(point, key2)) {
+          throw new TypeError(`sigmas.${key2} has no matching value`);
+        }
+      }
+      for (let i = 0; i < names.length; i++) {
+        const name254 = names[i];
+        if (!Object.prototype.hasOwnProperty.call(sigmas, name254)) continue;
+        const sigma2 = asFiniteNumber(`sigmas.${name254}`, sigmas[name254]);
+        if (sigma2 < 0) {
+          throw new RangeError(`sigmas.${name254} must be >= 0`);
+        }
+        variance2 += (gradient2[i] * sigma2) ** 2;
+      }
+    }
+  }
+  if (variance2 < 0) {
+    if (variance2 > -1e-12) variance2 = 0;
+    else throw new RangeError("covariance produced a negative variance");
+  }
+  const sigma = Math.sqrt(variance2);
+  const offsets = options?.curvatureOffsets;
+  if (offsets === void 0) return { value, sigma, partials };
+  if (offsets === null || typeof offsets !== "object") {
+    throw new TypeError("curvatureOffsets must be an object of finite numbers");
+  }
+  const evaluateAt = (at) => {
+    if (call) return call(at);
+    return asFiniteNumber("curvature probe", evaluate(expr, at));
+  };
+  const curvature = {};
+  for (const name254 of Object.keys(offsets)) {
+    if (!Object.prototype.hasOwnProperty.call(point, name254)) {
+      throw new TypeError(`curvatureOffsets.${name254} has no matching value`);
+    }
+    curvature[name254] = curvatureRatio(evaluateAt, name254, point, partials[name254], offsets[name254], value);
+  }
+  return { value, sigma, partials, curvature };
+}
+
 // src/help.ts
 import { createHelpClass, embeddedDocs } from "@danielsimonjr/mathts-expression";
 var savedConfig = {};
@@ -49457,8 +49913,8 @@ function intToRatPoly(p) {
 }
 function ratPolyToInt(p) {
   if (p.length === 0) return { poly: [], den: 1n };
-  let lcm2 = 1n;
-  const gcd2 = (a, b) => {
+  let lcm3 = 1n;
+  const gcd3 = (a, b) => {
     let x = a < 0n ? -a : a;
     let y = b < 0n ? -b : b;
     while (y !== 0n) {
@@ -49469,10 +49925,10 @@ function ratPolyToInt(p) {
     return x;
   };
   for (const r of p) {
-    const g = gcd2(lcm2, r.den);
-    lcm2 = lcm2 / g * r.den;
+    const g = gcd3(lcm3, r.den);
+    lcm3 = lcm3 / g * r.den;
   }
-  return { poly: trim(p.map((r) => r.num * lcm2 / r.den)), den: lcm2 };
+  return { poly: trim(p.map((r) => r.num * lcm3 / r.den)), den: lcm3 };
 }
 function rpAdd(a, b) {
   const n = Math.max(a.length, b.length);
@@ -55276,6 +55732,10 @@ export {
   DIST_WORKER_THRESHOLD,
   EARTH_RADIUS_KM,
   GAUSS_WORKER_THRESHOLD,
+  GL4ConvergenceError,
+  GL4_A,
+  GL4_B,
+  GL4_C,
   GPU_ELEMENTWISE_OPS,
   GPU_MIN_ELEMENTS2 as GPU_MIN_ELEMENTS,
   GPU_REDUCE_OPS,
@@ -55698,6 +56158,7 @@ export {
   gammainc,
   gammaincp,
   gasConstant,
+  gaussLegendre4,
   gaussQuad,
   gaussianKDE,
   gaussianProcessRegression,
@@ -56040,6 +56501,7 @@ export {
   permutationTest,
   permutations,
   permutationsGen,
+  physicsScope,
   pickRandom,
   piecewise,
   pinv,
@@ -56079,6 +56541,7 @@ export {
   procrustes,
   prod,
   projectVector,
+  propagateUncertainty,
   proportionCI,
   proportionZTest,
   protonMass,
@@ -56107,6 +56570,7 @@ export {
   range,
   rank,
   rankdata,
+  rationalNullspace,
   rationalize,
   rayPlaneIntersect,
   rayTriangleIntersect,