@thi.ng/math 5.7.6 → 5.7.8

package/permutations.js

@@ -1,48 +1,19 @@
-/**
- * Computes factorial for `n`. Throws an error if `n < 0`.
- *
- * @param n
- */
-export const factorial = (n) => {
-    if (n < 0)
-        throw new Error(`illegal argument: ${n}`);
-    let res = 1;
-    for (let i = 1; i <= n; i++)
-        res *= i;
-    return res;
+const factorial = (n) => {
+  if (n < 0)
+    throw new Error(`illegal argument: ${n}`);
+  let res = 1;
+  for (let i = 1; i <= n; i++)
+    res *= i;
+  return res;
+};
+const permutationsWithRep = (n, k) => n ** k;
+const permutationsWithoutRep = (n, k) => factorial(n) / factorial(n - k);
+const combinationsWithRep = (n, k) => factorial(n + k - 1) / (factorial(k) * factorial(n - 1));
+const combinationsWithoutRep = (n, k) => factorial(n) / (factorial(k) * factorial(n - k));
+export {
+  combinationsWithRep,
+  combinationsWithoutRep,
+  factorial,
+  permutationsWithRep,
+  permutationsWithoutRep
 };
-/**
- * Computes `n ** k`
- *
- * @param n number of choices
- * @param k number of selected
- */
-export const permutationsWithRep = (n, k) => n ** k;
-/**
- * Computes `n! / (n - k)!`
- *
- * @remarks
- * Reference:
- * https://en.wikipedia.org/wiki/Permutation#k-permutations_of_n
- *
- * @param n number of choices
- * @param k number of selected
- */
-export const permutationsWithoutRep = (n, k) => factorial(n) / factorial(n - k);
-/**
- * Computes `(n + k - 1)! / (k! * (n - 1)!)`
- *
- * @param n number of choices
- * @param k number of selected
- */
-export const combinationsWithRep = (n, k) => factorial(n + k - 1) / (factorial(k) * factorial(n - 1));
-/**
- * Computes `n! / (k! * (n - k)!)`
- *
- * @remarks
- * https://en.wikipedia.org/wiki/Combination#Number_of_k-combinations
- *
- * @param n number of choices
- * @param k number of selected
- */
-export const combinationsWithoutRep = (n, k) => factorial(n) / (factorial(k) * factorial(n - k));

package/prec.js

@@ -1,33 +1,20 @@
 import { EPS } from "./api.js";
-/**
- * Similar to {@link fmod}, {@link remainder}. Returns `a - b * floor(a / b)`
- * (same as GLSL `mod(a, b)`)
- *
- * @remarks
- * **Caution:** Due to the introduction of libc math functions in v4.0.0 and the
- * resulting name/behavior clashes between the modulo logic in JS, C & GLSL,
- * this function previously _was_ called `fmod`, but going forward has been
- * renamed to align w/ its GLSL version and exhibits a different behavior to the
- * current {@link fmod} function.
- *
- * https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/mod.xhtml
- *
- * @param a -
- * @param b -
- */
-export const mod = (a, b) => a - b * Math.floor(a / b);
-export const fract = (x) => x - Math.floor(x);
-export const trunc = (x) => (x < 0 ? Math.ceil(x) : Math.floor(x));
-export const roundTo = (x, prec = 1) => Math.round(x / prec) * prec;
-export const floorTo = (x, prec = 1) => Math.floor(x / prec) * prec;
-export const ceilTo = (x, prec = 1) => Math.ceil(x / prec) * prec;
-/**
- * Only rounds `x` to nearest int if `fract(x)` <= `eps` or >= `1-eps`.
- *
- * @param x -
- * @param eps -
- */
-export const roundEps = (x, eps = EPS) => {
-    const f = fract(x);
-    return f <= eps || f >= 1 - eps ? Math.round(x) : x;
+const mod = (a, b) => a - b * Math.floor(a / b);
+const fract = (x) => x - Math.floor(x);
+const trunc = (x) => x < 0 ? Math.ceil(x) : Math.floor(x);
+const roundTo = (x, prec = 1) => Math.round(x / prec) * prec;
+const floorTo = (x, prec = 1) => Math.floor(x / prec) * prec;
+const ceilTo = (x, prec = 1) => Math.ceil(x / prec) * prec;
+const roundEps = (x, eps = EPS) => {
+  const f = fract(x);
+  return f <= eps || f >= 1 - eps ? Math.round(x) : x;
+};
+export {
+  ceilTo,
+  floorTo,
+  fract,
+  mod,
+  roundEps,
+  roundTo,
+  trunc
 };

package/prime.js

@@ -1,54 +1,37 @@
-/**
- * Returns iterator of all prime numbers ≤ given `x` using Sieve of
- * Eratosthenes.
- *
- * @remarks
- * Reference: https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
- *
- * @param x -
- */
-export function* primesUntil(x) {
-    if (x < 1)
-        return;
-    yield 1;
-    const sieve = [];
-    const max = Math.sqrt(x) | 0;
-    for (let i = 2; i <= x; i++) {
-        if (!sieve[i]) {
-            yield i;
-            __updateSieve(sieve, i, x, max);
-        }
+function* primesUntil(x) {
+  if (x < 1)
+    return;
+  yield 1;
+  const sieve = [];
+  const max = Math.sqrt(x) | 0;
+  for (let i = 2; i <= x; i++) {
+    if (!sieve[i]) {
+      yield i;
+      __updateSieve(sieve, i, x, max);
     }
+  }
 }
-/**
- * Returns largest prime number ≤ given `x` using Sieve of Eratosthenes. Returns
- * -1 if x < 1.
- *
- * @remarks
- * Reference: https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
- *
- * @param x -
- */
-export const nearestPrime = (x) => {
-    if (x < 1)
-        return -1;
-    let prime = 1;
-    const sieve = [];
-    const max = Math.sqrt(x) | 0;
-    for (let i = 2; i <= x; i++) {
-        if (!sieve[i]) {
-            prime = i;
-            __updateSieve(sieve, i, x, max);
-        }
+const nearestPrime = (x) => {
+  if (x < 1)
+    return -1;
+  let prime = 1;
+  const sieve = [];
+  const max = Math.sqrt(x) | 0;
+  for (let i = 2; i <= x; i++) {
+    if (!sieve[i]) {
+      prime = i;
+      __updateSieve(sieve, i, x, max);
     }
-    return prime;
+  }
+  return prime;
 };
-/**
- * @internal
- */
 const __updateSieve = (sieve, i, x, max) => {
-    if (i <= max) {
-        for (let j = i * i; j <= x; j += i)
-            sieve[j] = true;
-    }
+  if (i <= max) {
+    for (let j = i * i; j <= x; j += i)
+      sieve[j] = true;
+  }
+};
+export {
+  nearestPrime,
+  primesUntil
 };

package/ratio.js

@@ -1,18 +1,20 @@
-export const simplifyRatio = (num, denom) => {
-    let e1 = Math.abs(num);
-    let e2 = Math.abs(denom);
-    while (true) {
-        if (e1 < e2) {
-            const t = e1;
-            e1 = e2;
-            e2 = t;
-        }
-        const r = e1 % e2;
-        if (r) {
-            e1 = r;
-        }
-        else {
-            return [num / e2, denom / e2];
-        }
+const simplifyRatio = (num, denom) => {
+  let e1 = Math.abs(num);
+  let e2 = Math.abs(denom);
+  while (true) {
+    if (e1 < e2) {
+      const t = e1;
+      e1 = e2;
+      e2 = t;
     }
+    const r = e1 % e2;
+    if (r) {
+      e1 = r;
+    } else {
+      return [num / e2, denom / e2];
+    }
+  }
+};
+export {
+  simplifyRatio
 };

package/safe-div.js

@@ -1,7 +1,4 @@
-/**
- * Returns `a` divided by `b` or zero if `b = 0`.
- *
- * @param a -
- * @param b -
- */
-export const safeDiv = (a, b) => (b !== 0 ? a / b : 0);
+const safeDiv = (a, b) => b !== 0 ? a / b : 0;
+export {
+  safeDiv
+};

package/solve.js

@@ -1,97 +1,42 @@
 import { EPS } from "./api.js";
 import { safeDiv } from "./safe-div.js";
-/**
- * Produces a new function which computes derivative of the given single-arg
- * function. The extra optional arg `eps` is used to define the step width for
- * computing derived values:
- *
- * `f'(x) = (f(x + eps) - f(x)) / eps`
- *
- * The original function is assumed to be fully differentiable in the interval
- * the returned function is going to be used. No validity checks of any form are
- * done.
- *
- * https://en.wikipedia.org/wiki/Derivative#Continuity_and_differentiability
- *
- * @param fn -
- * @param eps -
- */
-export const derivative = (f, eps = EPS) => (x) => (f(x + eps) - f(x)) / eps;
-/**
- * Computes solution for linear equation: `ax + b = 0`.
- *
- * Note: Returns 0 iff `a == 0`
- *
- * @param a - slope
- * @param b - constant offset
- */
-export const solveLinear = (a, b) => safeDiv(-b, a);
-/**
- * Computes solutions for quadratic equation: `ax^2 + bx + c = 0`. Returns array
- * of real solutions. Note: `a` MUST NOT be zero. If the quadratic term is
- * missing, use {@link solveLinear} instead.
- *
- * - https://en.wikipedia.org/wiki/Quadratic_function
- * - https://en.wikipedia.org/wiki/Quadratic_equation
- *
- * @param a - quadratic coefficient
- * @param b - linear coefficient
- * @param c - constant offset
- * @param eps - tolerance to determine multiple roots
- */
-export const solveQuadratic = (a, b, c, eps = 1e-9) => {
-    const d = 2 * a;
-    let r = b * b - 4 * a * c;
-    return r < 0
-        ? []
-        : r < eps
-            ? [-b / d]
-            : ((r = Math.sqrt(r)), [(-b - r) / d, (-b + r) / d]);
+const derivative = (f, eps = EPS) => (x) => (f(x + eps) - f(x)) / eps;
+const solveLinear = (a, b) => safeDiv(-b, a);
+const solveQuadratic = (a, b, c, eps = 1e-9) => {
+  const d = 2 * a;
+  let r = b * b - 4 * a * c;
+  return r < 0 ? [] : r < eps ? [-b / d] : (r = Math.sqrt(r), [(-b - r) / d, (-b + r) / d]);
 };
-/**
- * Computes solutions for quadratic equation: `ax^3 + bx^2 + c*x + d = 0`.
- * Returns array of solutions, both real & imaginary. Note: `a` MUST NOT be
- * zero. If the cubic term is missing (i.e. zero), use {@link solveQuadratic} or
- * {@link solveLinear} instead.
- *
- * https://en.wikipedia.org/wiki/Cubic_function
- *
- * @param a - cubic coefficient
- * @param b - quadratic coefficient
- * @param c - linear coefficient
- * @param d - constant offset
- * @param eps - tolerance to determine multiple roots
- */
-export const solveCubic = (a, b, c, d, eps = 1e-9) => {
-    const aa = a * a;
-    const bb = b * b;
-    const ba3 = b / (3 * a);
-    const p = (3 * a * c - bb) / (3 * aa);
-    const q = (2 * bb * b - 9 * a * b * c + 27 * aa * d) / (27 * aa * a);
-    if (Math.abs(p) < eps) {
-        return [Math.cbrt(-q) - ba3];
-    }
-    else if (Math.abs(q) < eps) {
-        return p < 0
-            ? [-Math.sqrt(-p) - ba3, -ba3, Math.sqrt(-p) - ba3]
-            : [-ba3];
-    }
-    else {
-        const denom = (q * q) / 4 + (p * p * p) / 27;
-        if (Math.abs(denom) < eps) {
-            return [(-1.5 * q) / p - ba3, (3 * q) / p - ba3];
-        }
-        else if (denom > 0) {
-            const u = Math.cbrt(-q / 2 - Math.sqrt(denom));
-            return [u - p / (3 * u) - ba3];
-        }
-        else {
-            const u = 2 * Math.sqrt(-p / 3), t = Math.acos((3 * q) / p / u) / 3, k = (2 * Math.PI) / 3;
-            return [
-                u * Math.cos(t) - ba3,
-                u * Math.cos(t - k) - ba3,
-                u * Math.cos(t - 2 * k) - ba3,
-            ];
-        }
+const solveCubic = (a, b, c, d, eps = 1e-9) => {
+  const aa = a * a;
+  const bb = b * b;
+  const ba3 = b / (3 * a);
+  const p = (3 * a * c - bb) / (3 * aa);
+  const q = (2 * bb * b - 9 * a * b * c + 27 * aa * d) / (27 * aa * a);
+  if (Math.abs(p) < eps) {
+    return [Math.cbrt(-q) - ba3];
+  } else if (Math.abs(q) < eps) {
+    return p < 0 ? [-Math.sqrt(-p) - ba3, -ba3, Math.sqrt(-p) - ba3] : [-ba3];
+  } else {
+    const denom = q * q / 4 + p * p * p / 27;
+    if (Math.abs(denom) < eps) {
+      return [-1.5 * q / p - ba3, 3 * q / p - ba3];
+    } else if (denom > 0) {
+      const u = Math.cbrt(-q / 2 - Math.sqrt(denom));
+      return [u - p / (3 * u) - ba3];
+    } else {
+      const u = 2 * Math.sqrt(-p / 3), t = Math.acos(3 * q / p / u) / 3, k = 2 * Math.PI / 3;
+      return [
+        u * Math.cos(t) - ba3,
+        u * Math.cos(t - k) - ba3,
+        u * Math.cos(t - 2 * k) - ba3
+      ];
     }
+  }
+};
+export {
+  derivative,
+  solveCubic,
+  solveLinear,
+  solveQuadratic
 };

package/step.js

@@ -1,64 +1,15 @@
 import { clamp01 } from "./interval.js";
-/**
- * Step/threshold function.
- *
- * @param edge - threshold
- * @param x - test value
- * @returns 0, if `x < e`, else 1
- */
-export const step = (edge, x) => (x < edge ? 0 : 1);
-/**
- * GLSL-style smoothStep threshold function.
- *
- * @remarks
- * Also see {@link smoothStep01}, {@link smootherStep}.
- *
- * @param edge - lower threshold
- * @param edge2 - upper threshold
- * @param x - test value
- * @returns 0, if `x < edge1`, 1 if `x > edge2`, else S-curve polynomial interpolation
- */
-export const smoothStep = (edge, edge2, x) => smoothStep01(clamp01((x - edge) / (edge2 - edge)));
-/**
- * Specialized version of {@link smoothStep}, assuming edges are 0/1
- * respectively and `x` is in [0..1]. No clamping performed.
- *
- * @param x
- */
-export const smoothStep01 = (x) => x * x * (3 - 2 * x);
-/**
- * Similar to {@link smoothStep} but using different, higher degree polynomial.
- *
- * @remarks
- * Also see {@link smootherStep01}.
- *
- * @param edge -
- * @param edge2 -
- * @param x -
- */
-export const smootherStep = (edge, edge2, x) => smootherStep01(clamp01((x - edge) / (edge2 - edge)));
-/**
- * Specialized version of {@link smootherStep}, assuming edges are 0/1
- * respectively and `x` is in [0..1]. No clamping performed.
- *
- * @param x
- */
-export const smootherStep01 = (x) => x * x * x * (x * (x * 6 - 15) + 10);
-/**
- * Exponential ramp with variable shape
- *
- * @remarks
- * Example configurations:
- *
- * - S-curve: k=8, n=4
- * - Step near 1.0: k=8, n=20
- * - Pulse: k=0.005, n=-10
- * - Ease-in: k=0.5, n=0.25
- *
- * Interactive graph: https://www.desmos.com/calculator/gcnuyppycz
- *
- * @param k -
- * @param n -
- * @param x -
- */
-export const expStep = (k, n, x) => 1 - Math.exp(-k * Math.pow(x, n));
+const step = (edge, x) => x < edge ? 0 : 1;
+const smoothStep = (edge, edge2, x) => smoothStep01(clamp01((x - edge) / (edge2 - edge)));
+const smoothStep01 = (x) => x * x * (3 - 2 * x);
+const smootherStep = (edge, edge2, x) => smootherStep01(clamp01((x - edge) / (edge2 - edge)));
+const smootherStep01 = (x) => x * x * x * (x * (x * 6 - 15) + 10);
+const expStep = (k, n, x) => 1 - Math.exp(-k * Math.pow(x, n));
+export {
+  expStep,
+  smoothStep,
+  smoothStep01,
+  smootherStep,
+  smootherStep01,
+  step
+};