@thi.ng/math 5.7.6 → 5.7.7

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -67,7 +67,7 @@ For Node.js REPL:
 const math = await import("@thi.ng/math");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 4.08 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 4.07 KB
 
 ## Dependencies
 

package/abs.js

@@ -1,3 +1,7 @@
 import { EPS } from "./api.js";
-export const absDiff = (x, y) => Math.abs(x - y);
-export const sign = (x, eps = EPS) => (x > eps ? 1 : x < -eps ? -1 : 0);
+const absDiff = (x, y) => Math.abs(x - y);
+const sign = (x, eps = EPS) => x > eps ? 1 : x < -eps ? -1 : 0;
+export {
+  absDiff,
+  sign
+};

package/angle.js

@@ -1,129 +1,61 @@
 import { DEG2RAD, HALF_PI, INV_HALF_PI, PI, RAD2DEG, TAU } from "./api.js";
-/**
- * Returns vector of `[sin(theta)*n, cos(theta)*n]`.
- *
- * @param theta -
- * @param n -
- */
-export const sincos = (theta, n = 1) => [
-    Math.sin(theta) * n,
-    Math.cos(theta) * n,
+const sincos = (theta, n = 1) => [
+  Math.sin(theta) * n,
+  Math.cos(theta) * n
 ];
-/**
- * Returns vector of `[cos(theta)*n, sin(theta)*n]`.
- *
- * @param theta -
- * @param n -
- */
-export const cossin = (theta, n = 1) => [
-    Math.cos(theta) * n,
-    Math.sin(theta) * n,
+const cossin = (theta, n = 1) => [
+  Math.cos(theta) * n,
+  Math.sin(theta) * n
 ];
-/**
- * Projects `theta` into [0 .. 2π] interval.
- *
- * @param theta -
- */
-export const absTheta = (theta) => ((theta %= TAU), theta < 0 ? TAU + theta : theta);
-export const absInnerAngle = (theta) => ((theta = Math.abs(theta)), theta > PI ? TAU - theta : theta);
-/**
- * Returns smallest absolute angle difference between `a` and `b`.
- * Result will be in [0 .. π] interval.
- *
- * @param a -
- * @param b -
- */
-export const angleDist = (a, b) => absInnerAngle(absTheta((b % TAU) - (a % TAU)));
-/**
- * Like `Math.atan2`, but always returns angle in [0 .. TAU) interval.
- *
- * @param y -
- * @param x -
- */
-export const atan2Abs = (y, x) => absTheta(Math.atan2(y, x));
-/**
- * Returns quadrant ID (0-3) of given angle (in radians).
- *
- * @param theta -
- */
-export const quadrant = (theta) => (absTheta(theta) * INV_HALF_PI) | 0;
-/**
- * Converts angle to degrees.
- *
- * @param theta - angle in radians
- */
-export const deg = (theta) => theta * RAD2DEG;
-/**
- * Converts angle to radians.
- *
- * @param theta - angle in degrees
- */
-export const rad = (theta) => theta * DEG2RAD;
-/**
- * Cosecant. Approaches `±Infinity` for `theta` near multiples of π.
- *
- * @param theta - angle in radians
- */
-export const csc = (theta) => 1 / Math.sin(theta);
-/**
- * Secant. Approaches `±Infinity` for `theta` near π/2 ± nπ
- *
- * @param theta - angle in radians
- */
-export const sec = (theta) => 1 / Math.cos(theta);
-/**
- * Cotangent. Approaches `±Infinity` for `theta` near multiples of π.
- *
- * @param theta - angle in radians
- */
-export const cot = (theta) => 1 / Math.tan(theta);
-/**
- * Law of Cosines. Takes length of two sides of a triangle and the inner
- * angle (in radians) between them. Returns length of third side.
- *
- * @param a -
- * @param b -
- * @param gamma -
- */
-export const loc = (a, b, gamma) => Math.sqrt(a * a + b * b - 2 * a * b * Math.cos(gamma));
-/**
- * Approximates cos(xπ) for x in [-1,1]
- *
- * @param x -
- */
-export const normCos = (x) => {
-    const x2 = x * x;
-    return 1.0 + x2 * (-4 + 2 * x2);
+const absTheta = (theta) => (theta %= TAU, theta < 0 ? TAU + theta : theta);
+const absInnerAngle = (theta) => (theta = Math.abs(theta), theta > PI ? TAU - theta : theta);
+const angleDist = (a, b) => absInnerAngle(absTheta(b % TAU - a % TAU));
+const atan2Abs = (y, x) => absTheta(Math.atan2(y, x));
+const quadrant = (theta) => absTheta(theta) * INV_HALF_PI | 0;
+const deg = (theta) => theta * RAD2DEG;
+const rad = (theta) => theta * DEG2RAD;
+const csc = (theta) => 1 / Math.sin(theta);
+const sec = (theta) => 1 / Math.cos(theta);
+const cot = (theta) => 1 / Math.tan(theta);
+const loc = (a, b, gamma) => Math.sqrt(a * a + b * b - 2 * a * b * Math.cos(gamma));
+const normCos = (x) => {
+  const x2 = x * x;
+  return 1 + x2 * (-4 + 2 * x2);
 };
 const __fastCos = (x) => {
-    const x2 = x * x;
-    return 0.99940307 + x2 * (-0.49558072 + 0.03679168 * x2);
+  const x2 = x * x;
+  return 0.99940307 + x2 * (-0.49558072 + 0.03679168 * x2);
 };
-/**
- * Fast cosine approximation using {@link normCos} (polynomial). Max. error
- * ~0.00059693
- *
- * In [0 .. 2π] interval, approx. 18-20% faster than `Math.cos` on V8.
- *
- * @param theta - in radians
- */
-export const fastCos = (theta) => {
-    theta %= TAU;
-    theta < 0 && (theta = -theta);
-    switch ((theta * INV_HALF_PI) | 0) {
-        case 0:
-            return __fastCos(theta);
-        case 1:
-            return -__fastCos(PI - theta);
-        case 2:
-            return -__fastCos(theta - PI);
-        default:
-            return __fastCos(TAU - theta);
-    }
+const fastCos = (theta) => {
+  theta %= TAU;
+  theta < 0 && (theta = -theta);
+  switch (theta * INV_HALF_PI | 0) {
+    case 0:
+      return __fastCos(theta);
+    case 1:
+      return -__fastCos(PI - theta);
+    case 2:
+      return -__fastCos(theta - PI);
+    default:
+      return __fastCos(TAU - theta);
+  }
+};
+const fastSin = (theta) => fastCos(HALF_PI - theta);
+export {
+  absInnerAngle,
+  absTheta,
+  angleDist,
+  atan2Abs,
+  cossin,
+  cot,
+  csc,
+  deg,
+  fastCos,
+  fastSin,
+  loc,
+  normCos,
+  quadrant,
+  rad,
+  sec,
+  sincos
 };
-/**
- * {@link fastCos}
- *
- * @param theta - in radians
- */
-export const fastSin = (theta) => fastCos(HALF_PI - theta);

package/api.js

@@ -1,20 +1,42 @@
-export const PI = Math.PI;
-export const TAU = PI * 2;
-export const HALF_PI = PI / 2;
-export const THIRD_PI = PI / 3;
-export const QUARTER_PI = PI / 4;
-export const SIXTH_PI = PI / 6;
-export const INV_PI = 1 / PI;
-export const INV_TAU = 1 / TAU;
-export const INV_HALF_PI = 1 / HALF_PI;
-export const DEG2RAD = PI / 180;
-export const RAD2DEG = 180 / PI;
-export const PHI = (1 + Math.sqrt(5)) / 2;
-export const SQRT2 = Math.SQRT2;
-export const SQRT3 = Math.sqrt(3);
-export const SQRT2_2 = SQRT2 / 2;
-export const SQRT3_2 = SQRT3 / 2;
-export const THIRD = 1 / 3;
-export const TWO_THIRD = 2 / 3;
-export const SIXTH = 1 / 6;
-export let EPS = 1e-6;
+const PI = Math.PI;
+const TAU = PI * 2;
+const HALF_PI = PI / 2;
+const THIRD_PI = PI / 3;
+const QUARTER_PI = PI / 4;
+const SIXTH_PI = PI / 6;
+const INV_PI = 1 / PI;
+const INV_TAU = 1 / TAU;
+const INV_HALF_PI = 1 / HALF_PI;
+const DEG2RAD = PI / 180;
+const RAD2DEG = 180 / PI;
+const PHI = (1 + Math.sqrt(5)) / 2;
+const SQRT2 = Math.SQRT2;
+const SQRT3 = Math.sqrt(3);
+const SQRT2_2 = SQRT2 / 2;
+const SQRT3_2 = SQRT3 / 2;
+const THIRD = 1 / 3;
+const TWO_THIRD = 2 / 3;
+const SIXTH = 1 / 6;
+let EPS = 1e-6;
+export {
+  DEG2RAD,
+  EPS,
+  HALF_PI,
+  INV_HALF_PI,
+  INV_PI,
+  INV_TAU,
+  PHI,
+  PI,
+  QUARTER_PI,
+  RAD2DEG,
+  SIXTH,
+  SIXTH_PI,
+  SQRT2,
+  SQRT2_2,
+  SQRT3,
+  SQRT3_2,
+  TAU,
+  THIRD,
+  THIRD_PI,
+  TWO_THIRD
+};

package/crossing.js

@@ -1,60 +1,10 @@
 import { EPS } from "./api.js";
 import { eqDelta } from "./eqdelta.js";
-/**
- * Returns true if line A rises up over B.
- *
- * @example
- * ```ts
- * b1  a2
- *   \/
- *   /\
- * a1  b2
- * ```
- *
- * @param a1 -
- * @param a2 -
- * @param b1 -
- * @param b2 -
- */
-export const isCrossOver = (a1, a2, b1, b2) => a1 < b1 && a2 > b2;
-/**
- * Returns true if line A rises up over B.
- *
- * @example
- * ```ts
- * a1  b2
- *   \/
- *   /\
- * b1  a2
- * ```
- *
- * @param a1 -
- * @param a2 -
- * @param b1 -
- * @param b2 -
- */
-export const isCrossUnder = (a1, a2, b1, b2) => a1 > b1 && a2 < b2;
-/**
- * Returns {@link Crossing} classifier indicating the relationship of line A
- * to line B. The optional epsilon value is used to determine if both
- * lines are considered equal or flat.
- *
- * - {@link isCrossOver}
- * - {@link isCrossUnder}
- * - {@link Crossing}
- *
- * @param a1 -
- * @param a2 -
- * @param b1 -
- * @param b2 -
- * @param eps -
- */
-export const classifyCrossing = (a1, a2, b1, b2, eps = EPS) => eqDelta(a1, b1, eps) && eqDelta(a2, b2, eps)
-    ? eqDelta(a1, b2, eps)
-        ? "flat"
-        : "equal"
-    : isCrossOver(a1, a2, b1, b2)
-        ? "over"
-        : isCrossUnder(a1, a2, b1, b2)
-            ? "under"
-            : "other";
+const isCrossOver = (a1, a2, b1, b2) => a1 < b1 && a2 > b2;
+const isCrossUnder = (a1, a2, b1, b2) => a1 > b1 && a2 < b2;
+const classifyCrossing = (a1, a2, b1, b2, eps = EPS) => eqDelta(a1, b1, eps) && eqDelta(a2, b2, eps) ? eqDelta(a1, b2, eps) ? "flat" : "equal" : isCrossOver(a1, a2, b1, b2) ? "over" : isCrossUnder(a1, a2, b1, b2) ? "under" : "other";
+export {
+  classifyCrossing,
+  isCrossOver,
+  isCrossUnder
+};

package/eqdelta.js

@@ -1,25 +1,9 @@
 import { EPS } from "./api.js";
 const abs = Math.abs;
 const max = Math.max;
-/**
- * Similar to {@link eqDeltaScaled}, but uses given `eps` as is.
- *
- * @param a - left value
- * @param b - right value
- * @param eps - epsilon / tolerance, default `1e-6`
- */
-export const eqDelta = (a, b, eps = EPS) => abs(a - b) <= eps;
-/**
- * Checks if `|a - b| <= ε` and adapts given epsilon value to the given
- * arguments:
- *
- * ε is factored with the largest absolute value of `a` or `b` (but
- * never lesser than the given `eps` value):
- *
- * `ε = ε * max(1, |a|, |b|)`
- *
- * @param a - left value
- * @param b - right value
- * @param eps - epsilon / tolerance, default `1e-6`
- */
-export const eqDeltaScaled = (a, b, eps = EPS) => abs(a - b) <= eps * max(1, abs(a), abs(b));
+const eqDelta = (a, b, eps = EPS) => abs(a - b) <= eps;
+const eqDeltaScaled = (a, b, eps = EPS) => abs(a - b) <= eps * max(1, abs(a), abs(b));
+export {
+  eqDelta,
+  eqDeltaScaled
+};

package/extrema.js

@@ -1,74 +1,32 @@
-/**
- * Returns true if `b` is a local minima, i.e. iff a > b and b < c.
- *
- * @param a -
- * @param b -
- * @param c -
- */
-export const isMinima = (a, b, c) => a > b && b < c;
-/**
- * Returns true if `b` is a local maxima, i.e. iff a < b and b > c.
- *
- * @param a -
- * @param b -
- * @param c -
- */
-export const isMaxima = (a, b, c) => a < b && b > c;
+const isMinima = (a, b, c) => a > b && b < c;
+const isMaxima = (a, b, c) => a < b && b > c;
 const index = (pred, values, from = 0, to = values.length) => {
-    to--;
-    for (let i = from + 1; i < to; i++) {
-        if (pred(values[i - 1], values[i], values[i + 1])) {
-            return i;
-        }
+  to--;
+  for (let i = from + 1; i < to; i++) {
+    if (pred(values[i - 1], values[i], values[i + 1])) {
+      return i;
     }
-    return -1;
+  }
+  return -1;
 };
-/**
- * Returns index of the first local & internal minima found in given
- * `values` array, or -1 if no such minima exists. The search range can
- * be optionally defined via semi-open [from, to) index interval.
- *
- * @param values -
- * @param from -
- * @param to -
- */
-export const minimaIndex = (values, from = 0, to = values.length) => index(isMinima, values, from, to);
-/**
- * Returns index of the first local & internal maxima found in given
- * `values` array, or -1 if no such maxima exists. The search range can
- * be optionally defined via semi-open [from, to) index interval.
- *
- * @param values -
- * @param from -
- * @param to -
- */
-export const maximaIndex = (values, from = 0, to = values.length) => index(isMaxima, values, from, to);
+const minimaIndex = (values, from = 0, to = values.length) => index(isMinima, values, from, to);
+const maximaIndex = (values, from = 0, to = values.length) => index(isMaxima, values, from, to);
 function* indices(fn, vals, from = 0, to = vals.length) {
-    while (from < to) {
-        const i = fn(vals, from, to);
-        if (i < 0)
-            return;
-        yield i;
-        from = i + 1;
-    }
+  while (from < to) {
+    const i = fn(vals, from, to);
+    if (i < 0)
+      return;
+    yield i;
+    from = i + 1;
+  }
 }
-/**
- * Returns an iterator yielding all minima indices in given `values`
- * array. The search range can be optionally defined via semi-open
- * [from, to) index interval.
- *
- * @param values -
- * @param from -
- * @param to -
- */
-export const minimaIndices = (values, from = 0, to = values.length) => indices(minimaIndex, values, from, to);
-/**
- * Returns an iterator yielding all maxima indices in given `values`
- * array. The search range can be optionally defined via semi-open
- * [from, to) index interval.
- *
- * @param values -
- * @param from -
- * @param to -
- */
-export const maximaIndices = (values, from = 0, to = values.length) => indices(minimaIndex, values, from, to);
+const minimaIndices = (values, from = 0, to = values.length) => indices(minimaIndex, values, from, to);
+const maximaIndices = (values, from = 0, to = values.length) => indices(minimaIndex, values, from, to);
+export {
+  isMaxima,
+  isMinima,
+  maximaIndex,
+  maximaIndices,
+  minimaIndex,
+  minimaIndices
+};

package/fit.js

@@ -1,58 +1,15 @@
 import { clamp01, clamp11 } from "./interval.js";
-/**
- * Returns normalized value of `x` WRT to interval `a .. b`. If `a`
- * equals `b`, returns 0.
- *
- * @param x -
- * @param a -
- * @param b -
- */
-export const norm = (x, a, b) => (b !== a ? (x - a) / (b - a) : 0);
-/**
- * Returns a number in the `[c,d]` interval which is relative to `x` in the
- * `[a,b]` interval. **No** clamping will be performed if `x` lies outside the
- * original range (for that use {@link fitClamped} instead).
- *
- * @param x
- * @param a
- * @param b
- * @param c
- * @param d
- */
-export const fit = (x, a, b, c, d) => c + (d - c) * norm(x, a, b);
-/**
- * Clamped version of {@link fit}, i.e. before mapping `x` into the target
- * interval `[c,d]`, it will be clamped to the source interval `[a,b]`.
- *
- * @param x
- * @param a
- * @param b
- * @param c
- * @param d
- */
-export const fitClamped = (x, a, b, c, d) => c + (d - c) * clamp01(norm(x, a, b));
-/**
- * Similar to {@link fitClamped}, assuming [0,1] as source interval.
- *
- * @param x
- * @param a
- * @param b
- */
-export const fit01 = (x, a, b) => a + (b - a) * clamp01(x);
-/**
- * Similar to {@link fitClamped}, assuming the reverse ordered [1,0] as source
- * interval.
- *
- * @param x
- * @param a
- * @param b
- */
-export const fit10 = (x, a, b) => b + (a - b) * clamp01(x);
-/**
- * Similar to {@link fitClamped}, assuming [-1,1] as source interval.
- *
- * @param x
- * @param a
- * @param b
- */
-export const fit11 = (x, a, b) => a + (b - a) * (0.5 + 0.5 * clamp11(x));
+const norm = (x, a, b) => b !== a ? (x - a) / (b - a) : 0;
+const fit = (x, a, b, c, d) => c + (d - c) * norm(x, a, b);
+const fitClamped = (x, a, b, c, d) => c + (d - c) * clamp01(norm(x, a, b));
+const fit01 = (x, a, b) => a + (b - a) * clamp01(x);
+const fit10 = (x, a, b) => b + (a - b) * clamp01(x);
+const fit11 = (x, a, b) => a + (b - a) * (0.5 + 0.5 * clamp11(x));
+export {
+  fit,
+  fit01,
+  fit10,
+  fit11,
+  fitClamped,
+  norm
+};