@thi.ng/math 5.13.6 → 5.15.0

package/README.md

@@ -7,7 +7,7 @@
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/109331703950160316?domain=https%3A%2F%2Fmastodon.thi.ng&style=social)](https://mastodon.thi.ng/@toxi)
 
 > [!NOTE]
-> This is one of 210 standalone projects, maintained as part
+> This is one of 212 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -77,7 +77,7 @@ For Node.js REPL:
 const math = await import("@thi.ng/math");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 5.04 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 5.48 KB
 
 ## Dependencies
 

package/fraction.d.ts

@@ -0,0 +1,58 @@
+import type { FnN2 } from "@thi.ng/api";
+/**
+ * Iteratively computes Greatest Common Divisor of given `a` and `b`.
+ *
+ * @remarks
+ * Reference:
+ *
+ * - https://en.wikipedia.org/wiki/Greatest_common_divisor
+ *
+ * @param a
+ * @param b
+ */
+export declare const gcd: FnN2;
+/**
+ * Computes Least Common Multiple for given `a` and `b`. Returns zero if either
+ * input is zero.
+ *
+ * @remarks
+ * Reference:
+ *
+ * - https://en.wikipedia.org/wiki/Least_common_multiple
+ *
+ * @param a
+ * @param b
+ */
+export declare const lcm: FnN2;
+/**
+ * Converts given `x` to a fraction with optional `maxDenom`inator, using
+ * continued fractions for best possible precision.
+ *
+ * @remarks
+ * Reference:
+ *
+ * - https://en.wikipedia.org/wiki/Continued_fraction
+ *
+ * @example
+ * ```ts tangle:../export/as-fraction.ts
+ * import { asFraction } from "@thi.ng/math";
+ *
+ * console.log(Math.PI, asFraction(Math.PI));
+ * // 3.141592653589793 [1146408, 364913]
+ *
+ * // keep denominator <= 1000
+ * console.log(Math.PI, asFraction(Math.PI, 1000));
+ * // 3.141592653589793 [ 355, 113 ]
+ * ```
+ *
+ * @param x
+ * @param maxDenom
+ */
+export declare const asFraction: (x: number, maxDenom?: number) => number[];
+/**
+ * Reverse op of {@link asFraction}. Converts a fraction tuple to a JS number.
+ *
+ * @param fraction
+ */
+export declare const asFloat: ([a, b]: [number, number]) => number;
+//# sourceMappingURL=fraction.d.ts.map

package/fraction.js

@@ -0,0 +1,46 @@
+const gcd = (a, b) => {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    const tmp = b;
+    b = a % b;
+    a = tmp;
+  }
+  return a;
+};
+const lcm = (a, b) => {
+  if (!Number.isFinite(a) || !Number.isFinite(b))
+    throw new Error("both inputs must be finite");
+  return a && b ? Math.abs(a * b) / gcd(a, b) : 0;
+};
+const asFraction = (x, maxDenom = 1e6) => {
+  if (!Number.isFinite(x)) throw new Error("input must be a finite");
+  if (Number.isInteger(x)) return [x, 1];
+  const sign = Math.sign(x);
+  x = Math.abs(x);
+  let n0 = 0;
+  let n1 = 1;
+  let d0 = 1;
+  let d1 = 0;
+  while (true) {
+    const i = Math.floor(x);
+    const d2 = i * d1 + d0;
+    if (d2 > maxDenom) break;
+    const n2 = i * n1 + n0;
+    n0 = n1;
+    n1 = n2;
+    d0 = d1;
+    d1 = d2;
+    const rem = x - i;
+    if (rem < Number.EPSILON) break;
+    x = 1 / rem;
+  }
+  return [sign * n1, d1];
+};
+const asFloat = ([a, b]) => a / b;
+export {
+  asFloat,
+  asFraction,
+  gcd,
+  lcm
+};

package/index.d.ts

@@ -6,12 +6,14 @@ export * from "./eqdelta.js";
 export * from "./extrema.js";
 export * from "./easing.js";
 export * from "./fit.js";
+export * from "./fraction.js";
 export * from "./int.js";
 export * from "./interval.js";
 export * from "./libc.js";
 export * from "./min-error.js";
 export * from "./mix.js";
 export * from "./permutations.js";
+export * from "./polynomial.js";
 export * from "./prec.js";
 export * from "./prime.js";
 export * from "./ratio.js";

package/index.js

@@ -6,12 +6,14 @@ export * from "./eqdelta.js";
 export * from "./extrema.js";
 export * from "./easing.js";
 export * from "./fit.js";
+export * from "./fraction.js";
 export * from "./int.js";
 export * from "./interval.js";
 export * from "./libc.js";
 export * from "./min-error.js";
 export * from "./mix.js";
 export * from "./permutations.js";
+export * from "./polynomial.js";
 export * from "./prec.js";
 export * from "./prime.js";
 export * from "./ratio.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thi.ng/math",
-	"version": "5.13.6",
+	"version": "5.15.0",
 	"description": "Assorted common math functions & utilities",
 	"type": "module",
 	"module": "./index.js",
@@ -42,7 +42,7 @@
 		"tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
 	},
 	"dependencies": {
-		"@thi.ng/api": "^8.12.9"
+		"@thi.ng/api": "^8.12.11"
 	},
 	"devDependencies": {
 		"esbuild": "^0.27.0",
@@ -104,6 +104,9 @@
 		"./fit": {
 			"default": "./fit.js"
 		},
+		"./fraction": {
+			"default": "./fraction.js"
+		},
 		"./int": {
 			"default": "./int.js"
 		},
@@ -122,6 +125,9 @@
 		"./permutations": {
 			"default": "./permutations.js"
 		},
+		"./polynomial": {
+			"default": "./polynomial.js"
+		},
 		"./prec": {
 			"default": "./prec.js"
 		},
@@ -144,5 +150,5 @@
 	"thi.ng": {
 		"year": 2013
 	},
-	"gitHead": "fdca77cabf47dd23a9ab17a5ca13e3060075c12c\n"
+	"gitHead": "e7a21b9d2a188fa04d4c893d8531c40fbc0f4c06\n"
 }

package/polynomial.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Computes polynomial for `x` and given `coeffs` (in order of increasing
+ * exponents).
+ *
+ * @remarks
+ * See {@link polynomialRegression} for computing coefficients.
+ *
+ * The number of given coefficients defines the degree (+1) of the polynomial,
+ * i.e. a cubic function will require 4 coeffs, with the y-intercept being the
+ * first coeff.
+ *
+ * @example
+ * ```ts tangle:../export/polynomial.ts
+ * import { polynomial } from "@thi.ng/math";
+ *
+ * const coeffs = [-5, -4, 3, 2];
+ *
+ * for(let x = -2; x <= 2; x += 0.5) {
+ *   console.log(`f(${x}) = ${polynomial(x, coeffs)}`);
+ * }
+ * // f(-2) = -1
+ * // f(-1.5) = 1
+ * // f(-1) = 0
+ * // f(-0.5) = -2.5
+ * // f(0) = -5
+ * // f(0.5) = -6
+ * // f(1) = -4
+ * // f(1.5) = 2.5
+ * // f(2) = 15
+ * ```
+ *
+ * @param x
+ * @param coeffs
+ */
+export declare const polynomial: (x: number, coeffs: number[]) => number;
+/**
+ * Computes the coefficients of a polynomial regression for the given `samples`
+ * (each a [x,y] tuple). The `degree` param defines the degree of the polynomial
+ * and the number of returned coefficients (+1).
+ *
+ * @remarks
+ * The resulting coeffs can be then used with {@link polynomial} to evaluate the
+ * curve (i.e. used to make predictions).
+ *
+ * @param samples
+ * @param degree
+ */
+export declare const polynomialRegression: (samples: number[][], degree: number) => number[];
+//# sourceMappingURL=polynomial.d.ts.map

package/polynomial.js

@@ -0,0 +1,20 @@
+import { gaussianElimination } from "./solve.js";
+const polynomial = (x, coeffs) => coeffs.reduce((sum, c, i) => sum + c * x ** i, 0);
+const polynomialRegression = (samples, degree) => {
+  const mat = [];
+  const aug = [];
+  for (let i = 0; i <= degree; i++) {
+    const col = [];
+    for (let j = 0; j <= degree; j++) {
+      col.push(samples.reduce((acc, x) => acc + x[0] ** (i + j), 0));
+    }
+    mat.push(col);
+    aug.push(samples.reduce((acc, x) => acc + x[0] ** i * x[1], 0));
+  }
+  mat.push(aug);
+  return gaussianElimination(mat, degree + 1);
+};
+export {
+  polynomial,
+  polynomialRegression
+};

package/solve.d.ts

@@ -75,4 +75,34 @@ export declare const solveCubic: (a: number, b: number, c: number, d: number, ep
  * @param d - input coefficients & output solutions [0,N-1]
  */
 export declare const solveTridiagonal: (a: NumericArray, b: NumericArray, c: NumericArray, d: NumericArray) => NumericArray;
+/**
+ * Takes an augmented matrix (in column-major order) and uses Gaussian
+ * elimination to compute solution coefficients for its system of linear
+ * equations `Ax = b`.
+ *
+ * @remarks
+ * References:
+ * - https://en.wikipedia.org/wiki/Gaussian_elimination
+ * - https://www.geeksforgeeks.org/dsa/gaussian-elimination/
+ *
+ * @example
+ * ```ts tangle:../export/gaussian-elimination.ts
+ * import { gaussianElimination } from "@thi.ng/math";
+ *
+ * // in column-major order
+ * const matrix = [
+ *   [3, 2, 5],
+ *   [2, 3, -3],
+ *   [-4, 3, 1],
+ *   [3, 15, 14]
+ * ];
+ *
+ * console.log(gaussianElimination(matrix, 1));
+ * // [3, 1, 2] (rounded)
+ * ```
+ *
+ * @param mat
+ * @param degree
+ */
+export declare const gaussianElimination: (mat: number[][], degree: number) => number[];
 //# sourceMappingURL=solve.d.ts.map

package/solve.js

@@ -51,8 +51,40 @@ const solveTridiagonal = (a, b, c, d) => {
   }
   return d;
 };
+const gaussianElimination = (mat, degree) => {
+  const n = mat.length - 1;
+  const coeffs = [degree];
+  for (let i = 0; i < n; i++) {
+    let max = i;
+    const col = mat[i];
+    for (let j = i + 1; j < n; j++) {
+      if (Math.abs(col[j]) > Math.abs(col[max])) max = j;
+    }
+    for (let k = i; k <= n; k++) {
+      const col2 = mat[k];
+      const tmp = col2[i];
+      col2[i] = col2[max];
+      col2[max] = tmp;
+    }
+    for (let j = i + 1; j < n; j++) {
+      for (let k = n; k >= i; k--) {
+        mat[k][j] -= mat[k][i] * mat[i][j] / mat[i][i];
+      }
+    }
+  }
+  for (let j = n; j-- > 0; ) {
+    const d = mat[j][j];
+    let sum = 0;
+    for (let k = j + 1; k < n; k++) {
+      sum += mat[k][j] * coeffs[k];
+    }
+    coeffs[j] = (mat[n][j] - sum) / d;
+  }
+  return coeffs;
+};
 export {
   derivative,
+  gaussianElimination,
   solveCubic,
   solveLinear,
   solveQuadratic,