@danielsimonjr/mathts-core 0.7.0 → 0.9.0

package/dist/{chunk-AMOHH5MP.js → chunk-2WW76EEF.js}

@@ -2410,23 +2410,28 @@ var BigNumber = class _BigNumber {
   // ============================================================
   // Comparison Methods
   // ============================================================
+  // All comparisons coerce their argument (number/string → BigNumber) exactly like the arithmetic
+  // methods, so `bignumber(8).lessThanOrEqual(3)` behaves like `.add(3)` does. Without the
+  // coercion the raw number reached the static comparator, which read `undefined._sign` and
+  // returned garbage — silently breaking every factory-layer consumer that compares against a
+  // number literal (isPrime, quantiles, …).
   equals(other) {
-    return _BigNumber.compare(this, other) === 0;
+    return _BigNumber.compare(this, this.ensureBigNumber(other)) === 0;
   }
   lessThan(other) {
-    return _BigNumber.compare(this, other) < 0;
+    return _BigNumber.compare(this, this.ensureBigNumber(other)) < 0;
   }
   lessThanOrEqual(other) {
-    return _BigNumber.compare(this, other) <= 0;
+    return _BigNumber.compare(this, this.ensureBigNumber(other)) <= 0;
   }
   greaterThan(other) {
-    return _BigNumber.compare(this, other) > 0;
+    return _BigNumber.compare(this, this.ensureBigNumber(other)) > 0;
   }
   greaterThanOrEqual(other) {
-    return _BigNumber.compare(this, other) >= 0;
+    return _BigNumber.compare(this, this.ensureBigNumber(other)) >= 0;
   }
   compareTo(other) {
-    return _BigNumber.compare(this, other);
+    return _BigNumber.compare(this, this.ensureBigNumber(other));
   }
   compare(other) {
     return this.compareTo(other);
@@ -2437,7 +2442,7 @@ var BigNumber = class _BigNumber {
    * Named `gt` for Decimal.js / mathjs formatter compatibility.
    */
   gt(other) {
-    return this.greaterThan(this.ensureBigNumber(other));
+    return this.greaterThan(other);
   }
   // ============================================================
   // Rounding Methods

package/dist/index.d.ts

@@ -1720,13 +1720,13 @@ declare class BigNumber implements MathTSValue {
      * Square root
      */
     sqrt(): BigNumber;
-    equals(other: BigNumber): boolean;
-    lessThan(other: BigNumber): boolean;
-    lessThanOrEqual(other: BigNumber): boolean;
-    greaterThan(other: BigNumber): boolean;
-    greaterThanOrEqual(other: BigNumber): boolean;
-    compareTo(other: BigNumber): number;
-    compare(other: BigNumber): number;
+    equals(other: BigNumber | number | string): boolean;
+    lessThan(other: BigNumber | number | string): boolean;
+    lessThanOrEqual(other: BigNumber | number | string): boolean;
+    greaterThan(other: BigNumber | number | string): boolean;
+    greaterThanOrEqual(other: BigNumber | number | string): boolean;
+    compareTo(other: BigNumber | number | string): number;
+    compare(other: BigNumber | number | string): number;
     /**
      * Returns true iff this > other.
      * Accepts the same argument types as `add`/`multiply` (BigNumber, number, or string).
@@ -2513,6 +2513,47 @@ declare function neumaierSum(xs: ArrayLike<number>): number;
  * so the accumulator only ever holds ratios in [0, 1].
  */
 declare function norm2(xs: ArrayLike<number>): number;
+/**
+ * Dot product `Σ aᵢ·bᵢ` with **pairwise (cascade) summation** of the products — the accuracy of
+ * {@link pairwiseSum} applied to a dot without materialising the product array.
+ *
+ * A naive `s += a[i]*b[i]` loop carries the same **O(n)·ε** error as a naive sum; measured against
+ * an exact reference on an ill-conditioned dot (large mean × small factor, n = 10⁶) it is ~18×
+ * worse than `np.dot`, which sums pairwise. This closes that gap — and, like {@link pairwiseSum},
+ * costs the same number of flops as the naive loop.
+ *
+ * The two ranges are assumed the same length; callers guard that. Reads only `[start, end)`.
+ */
+declare function pairwiseDot(a: ArrayLike<number>, b: ArrayLike<number>, start?: number, end?: number): number;
+/**
+ * Euclidean distance `‖a − b‖₂` that does **not** overflow or underflow — {@link norm2}'s BLAS
+ * `dnrm2` scaling applied to the elementwise difference.
+ *
+ * `distance` is just a 2-norm, so the obvious `sqrt(Σ(aᵢ−bᵢ)²)` inherits norm's pathology: it
+ * squares before it adds, overflowing to `Infinity` and — the dangerous case — **flushing to a
+ * silent 0** for small differences well inside the representable range. NumPy's `linalg.norm` has
+ * the same bug; scaling on the largest *difference* seen avoids both. The scale tracks the residual
+ * `a − b`, not the inputs, so it stays accurate even when `a` and `b` are individually huge.
+ *
+ * The two ranges are assumed the same length; callers guard that.
+ */
+declare function scaledDistance(a: ArrayLike<number>, b: ArrayLike<number>): number;
+/**
+ * Cumulative sum with **Neumaier compensation** — each prefix total is written to `out[i]` carrying
+ * the low-order bits a naive running sum throws away.
+ *
+ * A cumulative sum is an inherently sequential prefix scan, so pairwise summation does not apply:
+ * you need every intermediate total, not just the final one. `np.cumsum` therefore accumulates
+ * naively and its tail drifts by **O(n)·ε** (relErr ~1.3e-11 over 10⁶ terms). Carrying a running
+ * compensation costs a few extra flops per element, no extra memory, and makes every prefix exact
+ * for practical purposes — a strict improvement over NumPy where accumulated drift matters (e.g.
+ * integrating a signal).
+ *
+ * Writes `out[i]` for `i` in `[0, xs.length)`; `out` may be a `number[]` or a `Float64Array`.
+ */
+declare function neumaierCumsum(xs: ArrayLike<number>, out: {
+    [index: number]: number;
+}): void;
 
 /**
  * @danielsimonjr/mathts-core - Core types and utilities for MathTS
@@ -2521,4 +2562,4 @@ declare function norm2(xs: ArrayLike<number>): number;
 
 declare const VERSION = "0.1.0";
 
-export { ALL_UNITS, BASE_UNITS, BEST_PREFIXES, BIGNUMBER_E, BIGNUMBER_LN10, BIGNUMBER_LN2, BIGNUMBER_NEG_ONE, BIGNUMBER_ONE, BIGNUMBER_PI, BIGNUMBER_TEN, BIGNUMBER_ZERO, type BackendType, BigNumber, type BigNumberConfig, COMPLEX_NEG_ONE, COMPLEX_ONE, COMPLEX_ZERO, Complex, type ConversionDef, DEFAULT_CONFIG, DERIVED_UNITS, DIMENSIONLESS, DUAL_UNARY_RULES, DimensionMismatchError, type Dimensions, Dual, type DualUnaryRule, type DualUnaryRuleName, E, FRACTION_HALF, FRACTION_NEG_ONE, FRACTION_ONE, FRACTION_QUARTER, FRACTION_THIRD, FRACTION_ZERO, type FactoryDependencies, type FactoryFunction, type FactoryImport, Fraction, FunctionRegistry, I, type IBigNumber, type IComplex, type IFraction, type IMatrix, LN10, LN2, LOG10E, LOG2E, MATHTS_CONVERSIONS, MATHTS_TYPES, type MathTSConfig, type MathTSValue, type MatrixBackend, type MatrixDimensions, type NumericScalar, type NumericType, PHI, PI, Range, type RangeForEachCallback, type RangeFormatOptions, type RangeJSON, type RangeMapCallback, type RoundingMode, SI_PREFIXES, SQRT1_2, SQRT2, type Scalar, TAU, type TypeDef, TypeRegistry, UNIT_ALIASES, type UnitDef, UnitParseError, VERSION, abs, addScalar, createFactory, createMathTSTyped, createRangeClass, createTypedFunction, dim, divideScalar, equal, fix, getPrefix, getUnitDef, initTypedWasm, isArray, isBigInt, isBigNumber, isBoolean, isComplex, isDenseMatrix, isDual, isFraction, isFunction, isMatrix, isNull, isNumber, isNumeric, isObject, isSparseMatrix, isString, isTypedWasmAvailable, isUndefined, isUnit, math, mathTyped, multiplyScalar, neumaierSum, norm2, number, pairwiseSum, pow, registerNativeTypes, registry, round, subtractScalar };
+export { ALL_UNITS, BASE_UNITS, BEST_PREFIXES, BIGNUMBER_E, BIGNUMBER_LN10, BIGNUMBER_LN2, BIGNUMBER_NEG_ONE, BIGNUMBER_ONE, BIGNUMBER_PI, BIGNUMBER_TEN, BIGNUMBER_ZERO, type BackendType, BigNumber, type BigNumberConfig, COMPLEX_NEG_ONE, COMPLEX_ONE, COMPLEX_ZERO, Complex, type ConversionDef, DEFAULT_CONFIG, DERIVED_UNITS, DIMENSIONLESS, DUAL_UNARY_RULES, DimensionMismatchError, type Dimensions, Dual, type DualUnaryRule, type DualUnaryRuleName, E, FRACTION_HALF, FRACTION_NEG_ONE, FRACTION_ONE, FRACTION_QUARTER, FRACTION_THIRD, FRACTION_ZERO, type FactoryDependencies, type FactoryFunction, type FactoryImport, Fraction, FunctionRegistry, I, type IBigNumber, type IComplex, type IFraction, type IMatrix, LN10, LN2, LOG10E, LOG2E, MATHTS_CONVERSIONS, MATHTS_TYPES, type MathTSConfig, type MathTSValue, type MatrixBackend, type MatrixDimensions, type NumericScalar, type NumericType, PHI, PI, Range, type RangeForEachCallback, type RangeFormatOptions, type RangeJSON, type RangeMapCallback, type RoundingMode, SI_PREFIXES, SQRT1_2, SQRT2, type Scalar, TAU, type TypeDef, TypeRegistry, UNIT_ALIASES, type UnitDef, UnitParseError, VERSION, abs, addScalar, createFactory, createMathTSTyped, createRangeClass, createTypedFunction, dim, divideScalar, equal, fix, getPrefix, getUnitDef, initTypedWasm, isArray, isBigInt, isBigNumber, isBoolean, isComplex, isDenseMatrix, isDual, isFraction, isFunction, isMatrix, isNull, isNumber, isNumeric, isObject, isSparseMatrix, isString, isTypedWasmAvailable, isUndefined, isUnit, math, mathTyped, multiplyScalar, neumaierCumsum, neumaierSum, norm2, number, pairwiseDot, pairwiseSum, pow, registerNativeTypes, registry, round, scaledDistance, subtractScalar };

package/dist/index.js

@@ -44,7 +44,7 @@ import {
   round,
   sign,
   subtractScalar
-} from "./chunk-AMOHH5MP.js";
+} from "./chunk-2WW76EEF.js";
 
 // src/types/matrix/Range.ts
 var name = "Range";
@@ -1248,6 +1248,66 @@ function norm2(xs) {
   }
   return scale === 0 ? 0 : scale * Math.sqrt(ssq);
 }
+function pairwiseDot(a, b, start = 0, end = a.length) {
+  const n = end - start;
+  if (n <= PAIRWISE_BLOCK) {
+    let s0 = 0;
+    let s1 = 0;
+    let s2 = 0;
+    let s3 = 0;
+    let s4 = 0;
+    let s5 = 0;
+    let s6 = 0;
+    let s7 = 0;
+    let i = start;
+    const limit = start + (n - n % 8);
+    for (; i < limit; i += 8) {
+      s0 += a[i] * b[i];
+      s1 += a[i + 1] * b[i + 1];
+      s2 += a[i + 2] * b[i + 2];
+      s3 += a[i + 3] * b[i + 3];
+      s4 += a[i + 4] * b[i + 4];
+      s5 += a[i + 5] * b[i + 5];
+      s6 += a[i + 6] * b[i + 6];
+      s7 += a[i + 7] * b[i + 7];
+    }
+    let tail = 0;
+    for (; i < end; i++) tail += a[i] * b[i];
+    return s0 + s1 + (s2 + s3) + (s4 + s5 + (s6 + s7)) + tail;
+  }
+  const half = (n >> 1) - (n >> 1) % 8;
+  return pairwiseDot(a, b, start, start + half) + pairwiseDot(a, b, start + half, end);
+}
+function scaledDistance(a, b) {
+  let scale = 0;
+  let ssq = 1;
+  for (let i = 0; i < a.length; i++) {
+    const d = a[i] - b[i];
+    if (d === 0) continue;
+    if (Number.isNaN(d)) return NaN;
+    const ad = Math.abs(d);
+    if (scale < ad) {
+      const r = scale / ad;
+      ssq = 1 + ssq * r * r;
+      scale = ad;
+    } else {
+      const r = ad / scale;
+      ssq += r * r;
+    }
+  }
+  return scale === 0 ? 0 : scale * Math.sqrt(ssq);
+}
+function neumaierCumsum(xs, out) {
+  let sum = 0;
+  let c = 0;
+  for (let i = 0; i < xs.length; i++) {
+    const x = xs[i];
+    const t = sum + x;
+    c += Math.abs(sum) >= Math.abs(x) ? sum - t + x : x - t + sum;
+    sum = t;
+    out[i] = sum + c;
+  }
+}
 
 // src/index.ts
 var VERSION = "0.1.0";
@@ -1339,14 +1399,17 @@ export {
   math,
   mathTyped,
   multiplyScalar,
+  neumaierCumsum,
   neumaierSum,
   norm2,
   number,
+  pairwiseDot,
   pairwiseSum,
   pow,
   registerNativeTypes,
   registry,
   round,
+  scaledDistance,
   subtractScalar,
   typed
 };

package/dist/internal.js

@@ -69,7 +69,7 @@ import {
   typeOf,
   unitDependencies,
   warnOnce
-} from "./chunk-AMOHH5MP.js";
+} from "./chunk-2WW76EEF.js";
 export {
   Unit as CoreUnit,
   acosh,

package/package.json

@@ -1,59 +1,59 @@
-{
-  "name": "@danielsimonjr/mathts-core",
-  "version": "0.7.0",
-  "description": "Core types, utilities, and configuration for MathTS",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./internal": {
-      "import": "./dist/internal.js",
-      "types": "./dist/internal.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts src/internal.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts src/internal.ts --format esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
-  },
-  "dependencies": {
-    "typed-function": "github:danielsimonjr/typed-function"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/danielsimonjr/mathts",
-    "directory": "core"
-  },
-  "keywords": [
-    "math",
-    "typescript",
-    "core"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-core",
+  "version": "0.9.0",
+  "description": "Core types, utilities, and configuration for MathTS",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./internal": {
+      "import": "./dist/internal.js",
+      "types": "./dist/internal.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/internal.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/internal.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "typed-function": "github:danielsimonjr/typed-function"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "core"
+  },
+  "keywords": [
+    "math",
+    "typescript",
+    "core"
+  ]
+}