@danielsimonjr/mathts-core 0.5.0 → 0.7.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { U as Unit, a as UnitInstance, i as isUnitValue } from './index-DpOizJsa.js';
+import { F as FactoryFunction$1 } from './index-zKEDY9aj.js';
+export { U as Unit, a as UnitInstance, i as isUnitValue } from './index-zKEDY9aj.js';
 import { TypedInstance, ReferTo, ReferToSelf, TypedFunction, SignatureFunction } from 'typed-function';
 export { ReferTo, ReferToSelf, SignatureFunction, TypedFunction, TypedInstance, create, default as typed } from 'typed-function';
 
@@ -417,6 +418,718 @@ declare const COMPLEX_ZERO: Complex;
 declare const COMPLEX_ONE: Complex;
 declare const COMPLEX_NEG_ONE: Complex;
 
+interface BigNumber$1 {
+    toNumber(): number;
+}
+/**
+ * Callback function for Range forEach operations
+ */
+type RangeForEachCallback = (value: number, index: number[], range: unknown) => void;
+/**
+ * Callback function for Range map operations
+ */
+type RangeMapCallback<T> = (value: number, index: number[], range: unknown) => T;
+/**
+ * Formatting options for Range display
+ */
+interface RangeFormatOptions {
+    precision?: number;
+    notation?: 'fixed' | 'exponential' | 'engineering' | 'auto';
+    [key: string]: unknown;
+}
+/**
+ * JSON representation of a Range
+ */
+interface RangeJSON {
+    mathjs: 'Range';
+    start: number;
+    end: number;
+    step: number;
+}
+declare const createRangeClass: FactoryFunction$1<{
+    new (start?: number | bigint | BigNumber$1 | null, end?: number | bigint | BigNumber$1 | null, step?: number | bigint | BigNumber$1 | null): {
+        /**
+         * Type identifier
+         */
+        readonly type: string;
+        /**
+         * Range type flag
+         */
+        readonly isRange: boolean;
+        /**
+         * Start value of the range (inclusive)
+         */
+        start: number;
+        /**
+         * End value of the range (exclusive)
+         */
+        end: number;
+        /**
+         * Step size for the range
+         */
+        step: number;
+        /**
+         * Cached primitive array representation
+         */
+        "__#private@#cache": number[] | null;
+        "__#private@#cacheStart"?: number;
+        "__#private@#cacheEnd"?: number;
+        "__#private@#cacheStep"?: number;
+        /**
+         * Create a clone of the range
+         * @return {Range} clone
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Retrieve the size of the range.
+         * Returns an array containing one number, the number of elements in the range.
+         * @memberof Range
+         * @returns {number[]} size
+         */
+        size(): number[];
+        /**
+         * Calculate the minimum value in the range
+         * @memberof Range
+         * @return {number | undefined} min
+         */
+        min(): number | undefined;
+        /**
+         * Calculate the maximum value in the range
+         * @memberof Range
+         * @return {number | undefined} max
+         */
+        max(): number | undefined;
+        /**
+         * Execute a callback function for each value in the range.
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Range being traversed.
+         */
+        forEach(callback: RangeForEachCallback): void;
+        /**
+         * Execute a callback function for each value in the Range, and return the
+         * results as an array
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Matrix being traversed.
+         * @returns {Array} array
+         */
+        map<T>(callback: RangeMapCallback<T>): T[];
+        /**
+         * Create an Array with a copy of the Ranges data
+         * @memberof Range
+         * @returns {Array} array
+         */
+        toArray(): number[];
+        /**
+         * Get the primitive value of the Range, a one dimensional array
+         * @memberof Range
+         * @returns {Array} array
+         */
+        valueOf(): number[];
+        /**
+         * Get a string representation of the range, with optional formatting options.
+         * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+         * @memberof Range
+         * @param {Object | number | function} [options] Formatting options. See
+         *                                               lib/utils/number:format for a
+         *                                               description of the available
+         *                                               options.
+         * @returns {string} str
+         */
+        format(options?: RangeFormatOptions | number | ((value: number) => string)): string;
+        /**
+         * Get a string representation of the range.
+         * @memberof Range
+         * @returns {string}
+         */
+        toString(): string;
+        /**
+         * Get a JSON representation of the range
+         * @memberof Range
+         * @returns {Object} Returns a JSON object structured as:
+         *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+         */
+        toJSON(): RangeJSON;
+    };
+    /**
+     * Parse a string into a range,
+     * The string contains the start, optional step, and end, separated by a colon.
+     * If the string does not contain a valid range, null is returned.
+     * For example str='0:2:11'.
+     * @memberof Range
+     * @param {string} str
+     * @return {Range | null} range
+     */
+    parse(str: string): {
+        /**
+         * Type identifier
+         */
+        readonly type: string;
+        /**
+         * Range type flag
+         */
+        readonly isRange: boolean;
+        /**
+         * Start value of the range (inclusive)
+         */
+        start: number;
+        /**
+         * End value of the range (exclusive)
+         */
+        end: number;
+        /**
+         * Step size for the range
+         */
+        step: number;
+        /**
+         * Cached primitive array representation
+         */
+        "__#private@#cache": number[] | null;
+        "__#private@#cacheStart"?: number;
+        "__#private@#cacheEnd"?: number;
+        "__#private@#cacheStep"?: number;
+        /**
+         * Create a clone of the range
+         * @return {Range} clone
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Retrieve the size of the range.
+         * Returns an array containing one number, the number of elements in the range.
+         * @memberof Range
+         * @returns {number[]} size
+         */
+        size(): number[];
+        /**
+         * Calculate the minimum value in the range
+         * @memberof Range
+         * @return {number | undefined} min
+         */
+        min(): number | undefined;
+        /**
+         * Calculate the maximum value in the range
+         * @memberof Range
+         * @return {number | undefined} max
+         */
+        max(): number | undefined;
+        /**
+         * Execute a callback function for each value in the range.
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Range being traversed.
+         */
+        forEach(callback: RangeForEachCallback): void;
+        /**
+         * Execute a callback function for each value in the Range, and return the
+         * results as an array
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Matrix being traversed.
+         * @returns {Array} array
+         */
+        map<T>(callback: RangeMapCallback<T>): T[];
+        /**
+         * Create an Array with a copy of the Ranges data
+         * @memberof Range
+         * @returns {Array} array
+         */
+        toArray(): number[];
+        /**
+         * Get the primitive value of the Range, a one dimensional array
+         * @memberof Range
+         * @returns {Array} array
+         */
+        valueOf(): number[];
+        /**
+         * Get a string representation of the range, with optional formatting options.
+         * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+         * @memberof Range
+         * @param {Object | number | function} [options] Formatting options. See
+         *                                               lib/utils/number:format for a
+         *                                               description of the available
+         *                                               options.
+         * @returns {string} str
+         */
+        format(options?: RangeFormatOptions | number | ((value: number) => string)): string;
+        /**
+         * Get a string representation of the range.
+         * @memberof Range
+         * @returns {string}
+         */
+        toString(): string;
+        /**
+         * Get a JSON representation of the range
+         * @memberof Range
+         * @returns {Object} Returns a JSON object structured as:
+         *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+         */
+        toJSON(): RangeJSON;
+    } | null;
+    /**
+     * Instantiate a Range from a JSON object
+     * @memberof Range
+     * @param {Object} json A JSON object structured as:
+     *                      `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+     * @return {Range}
+     */
+    fromJSON(json: RangeJSON): {
+        /**
+         * Type identifier
+         */
+        readonly type: string;
+        /**
+         * Range type flag
+         */
+        readonly isRange: boolean;
+        /**
+         * Start value of the range (inclusive)
+         */
+        start: number;
+        /**
+         * End value of the range (exclusive)
+         */
+        end: number;
+        /**
+         * Step size for the range
+         */
+        step: number;
+        /**
+         * Cached primitive array representation
+         */
+        "__#private@#cache": number[] | null;
+        "__#private@#cacheStart"?: number;
+        "__#private@#cacheEnd"?: number;
+        "__#private@#cacheStep"?: number;
+        /**
+         * Create a clone of the range
+         * @return {Range} clone
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Retrieve the size of the range.
+         * Returns an array containing one number, the number of elements in the range.
+         * @memberof Range
+         * @returns {number[]} size
+         */
+        size(): number[];
+        /**
+         * Calculate the minimum value in the range
+         * @memberof Range
+         * @return {number | undefined} min
+         */
+        min(): number | undefined;
+        /**
+         * Calculate the maximum value in the range
+         * @memberof Range
+         * @return {number | undefined} max
+         */
+        max(): number | undefined;
+        /**
+         * Execute a callback function for each value in the range.
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Range being traversed.
+         */
+        forEach(callback: RangeForEachCallback): void;
+        /**
+         * Execute a callback function for each value in the Range, and return the
+         * results as an array
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Matrix being traversed.
+         * @returns {Array} array
+         */
+        map<T>(callback: RangeMapCallback<T>): T[];
+        /**
+         * Create an Array with a copy of the Ranges data
+         * @memberof Range
+         * @returns {Array} array
+         */
+        toArray(): number[];
+        /**
+         * Get the primitive value of the Range, a one dimensional array
+         * @memberof Range
+         * @returns {Array} array
+         */
+        valueOf(): number[];
+        /**
+         * Get a string representation of the range, with optional formatting options.
+         * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+         * @memberof Range
+         * @param {Object | number | function} [options] Formatting options. See
+         *                                               lib/utils/number:format for a
+         *                                               description of the available
+         *                                               options.
+         * @returns {string} str
+         */
+        format(options?: RangeFormatOptions | number | ((value: number) => string)): string;
+        /**
+         * Get a string representation of the range.
+         * @memberof Range
+         * @returns {string}
+         */
+        toString(): string;
+        /**
+         * Get a JSON representation of the range
+         * @memberof Range
+         * @returns {Object} Returns a JSON object structured as:
+         *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+         */
+        toJSON(): RangeJSON;
+    };
+}>;
+/**
+ * Ready-made `Range` class (the factory instantiated with no dependencies),
+ * exported for direct use from the package index — mirrors how core ships a
+ * ready-made `Complex`/`Fraction`/`Unit` alongside its factory.
+ */
+declare const Range: {
+    new (start?: number | bigint | BigNumber$1 | null, end?: number | bigint | BigNumber$1 | null, step?: number | bigint | BigNumber$1 | null): {
+        /**
+         * Type identifier
+         */
+        readonly type: string;
+        /**
+         * Range type flag
+         */
+        readonly isRange: boolean;
+        /**
+         * Start value of the range (inclusive)
+         */
+        start: number;
+        /**
+         * End value of the range (exclusive)
+         */
+        end: number;
+        /**
+         * Step size for the range
+         */
+        step: number;
+        /**
+         * Cached primitive array representation
+         */
+        "__#private@#cache": number[] | null;
+        "__#private@#cacheStart"?: number;
+        "__#private@#cacheEnd"?: number;
+        "__#private@#cacheStep"?: number;
+        /**
+         * Create a clone of the range
+         * @return {Range} clone
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Retrieve the size of the range.
+         * Returns an array containing one number, the number of elements in the range.
+         * @memberof Range
+         * @returns {number[]} size
+         */
+        size(): number[];
+        /**
+         * Calculate the minimum value in the range
+         * @memberof Range
+         * @return {number | undefined} min
+         */
+        min(): number | undefined;
+        /**
+         * Calculate the maximum value in the range
+         * @memberof Range
+         * @return {number | undefined} max
+         */
+        max(): number | undefined;
+        /**
+         * Execute a callback function for each value in the range.
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Range being traversed.
+         */
+        forEach(callback: RangeForEachCallback): void;
+        /**
+         * Execute a callback function for each value in the Range, and return the
+         * results as an array
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Matrix being traversed.
+         * @returns {Array} array
+         */
+        map<T>(callback: RangeMapCallback<T>): T[];
+        /**
+         * Create an Array with a copy of the Ranges data
+         * @memberof Range
+         * @returns {Array} array
+         */
+        toArray(): number[];
+        /**
+         * Get the primitive value of the Range, a one dimensional array
+         * @memberof Range
+         * @returns {Array} array
+         */
+        valueOf(): number[];
+        /**
+         * Get a string representation of the range, with optional formatting options.
+         * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+         * @memberof Range
+         * @param {Object | number | function} [options] Formatting options. See
+         *                                               lib/utils/number:format for a
+         *                                               description of the available
+         *                                               options.
+         * @returns {string} str
+         */
+        format(options?: RangeFormatOptions | number | ((value: number) => string)): string;
+        /**
+         * Get a string representation of the range.
+         * @memberof Range
+         * @returns {string}
+         */
+        toString(): string;
+        /**
+         * Get a JSON representation of the range
+         * @memberof Range
+         * @returns {Object} Returns a JSON object structured as:
+         *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+         */
+        toJSON(): RangeJSON;
+    };
+    /**
+     * Parse a string into a range,
+     * The string contains the start, optional step, and end, separated by a colon.
+     * If the string does not contain a valid range, null is returned.
+     * For example str='0:2:11'.
+     * @memberof Range
+     * @param {string} str
+     * @return {Range | null} range
+     */
+    parse(str: string): {
+        /**
+         * Type identifier
+         */
+        readonly type: string;
+        /**
+         * Range type flag
+         */
+        readonly isRange: boolean;
+        /**
+         * Start value of the range (inclusive)
+         */
+        start: number;
+        /**
+         * End value of the range (exclusive)
+         */
+        end: number;
+        /**
+         * Step size for the range
+         */
+        step: number;
+        /**
+         * Cached primitive array representation
+         */
+        "__#private@#cache": number[] | null;
+        "__#private@#cacheStart"?: number;
+        "__#private@#cacheEnd"?: number;
+        "__#private@#cacheStep"?: number;
+        /**
+         * Create a clone of the range
+         * @return {Range} clone
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Retrieve the size of the range.
+         * Returns an array containing one number, the number of elements in the range.
+         * @memberof Range
+         * @returns {number[]} size
+         */
+        size(): number[];
+        /**
+         * Calculate the minimum value in the range
+         * @memberof Range
+         * @return {number | undefined} min
+         */
+        min(): number | undefined;
+        /**
+         * Calculate the maximum value in the range
+         * @memberof Range
+         * @return {number | undefined} max
+         */
+        max(): number | undefined;
+        /**
+         * Execute a callback function for each value in the range.
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Range being traversed.
+         */
+        forEach(callback: RangeForEachCallback): void;
+        /**
+         * Execute a callback function for each value in the Range, and return the
+         * results as an array
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Matrix being traversed.
+         * @returns {Array} array
+         */
+        map<T>(callback: RangeMapCallback<T>): T[];
+        /**
+         * Create an Array with a copy of the Ranges data
+         * @memberof Range
+         * @returns {Array} array
+         */
+        toArray(): number[];
+        /**
+         * Get the primitive value of the Range, a one dimensional array
+         * @memberof Range
+         * @returns {Array} array
+         */
+        valueOf(): number[];
+        /**
+         * Get a string representation of the range, with optional formatting options.
+         * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+         * @memberof Range
+         * @param {Object | number | function} [options] Formatting options. See
+         *                                               lib/utils/number:format for a
+         *                                               description of the available
+         *                                               options.
+         * @returns {string} str
+         */
+        format(options?: RangeFormatOptions | number | ((value: number) => string)): string;
+        /**
+         * Get a string representation of the range.
+         * @memberof Range
+         * @returns {string}
+         */
+        toString(): string;
+        /**
+         * Get a JSON representation of the range
+         * @memberof Range
+         * @returns {Object} Returns a JSON object structured as:
+         *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+         */
+        toJSON(): RangeJSON;
+    } | null;
+    /**
+     * Instantiate a Range from a JSON object
+     * @memberof Range
+     * @param {Object} json A JSON object structured as:
+     *                      `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+     * @return {Range}
+     */
+    fromJSON(json: RangeJSON): {
+        /**
+         * Type identifier
+         */
+        readonly type: string;
+        /**
+         * Range type flag
+         */
+        readonly isRange: boolean;
+        /**
+         * Start value of the range (inclusive)
+         */
+        start: number;
+        /**
+         * End value of the range (exclusive)
+         */
+        end: number;
+        /**
+         * Step size for the range
+         */
+        step: number;
+        /**
+         * Cached primitive array representation
+         */
+        "__#private@#cache": number[] | null;
+        "__#private@#cacheStart"?: number;
+        "__#private@#cacheEnd"?: number;
+        "__#private@#cacheStep"?: number;
+        /**
+         * Create a clone of the range
+         * @return {Range} clone
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Retrieve the size of the range.
+         * Returns an array containing one number, the number of elements in the range.
+         * @memberof Range
+         * @returns {number[]} size
+         */
+        size(): number[];
+        /**
+         * Calculate the minimum value in the range
+         * @memberof Range
+         * @return {number | undefined} min
+         */
+        min(): number | undefined;
+        /**
+         * Calculate the maximum value in the range
+         * @memberof Range
+         * @return {number | undefined} max
+         */
+        max(): number | undefined;
+        /**
+         * Execute a callback function for each value in the range.
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Range being traversed.
+         */
+        forEach(callback: RangeForEachCallback): void;
+        /**
+         * Execute a callback function for each value in the Range, and return the
+         * results as an array
+         * @memberof Range
+         * @param {function} callback The callback method is invoked with three
+         *                            parameters: the value of the element, the index
+         *                            of the element, and the Matrix being traversed.
+         * @returns {Array} array
+         */
+        map<T>(callback: RangeMapCallback<T>): T[];
+        /**
+         * Create an Array with a copy of the Ranges data
+         * @memberof Range
+         * @returns {Array} array
+         */
+        toArray(): number[];
+        /**
+         * Get the primitive value of the Range, a one dimensional array
+         * @memberof Range
+         * @returns {Array} array
+         */
+        valueOf(): number[];
+        /**
+         * Get a string representation of the range, with optional formatting options.
+         * Output is formatted as 'start:step:end', for example '2:6' or '0:0.2:11'
+         * @memberof Range
+         * @param {Object | number | function} [options] Formatting options. See
+         *                                               lib/utils/number:format for a
+         *                                               description of the available
+         *                                               options.
+         * @returns {string} str
+         */
+        format(options?: RangeFormatOptions | number | ((value: number) => string)): string;
+        /**
+         * Get a string representation of the range.
+         * @memberof Range
+         * @returns {string}
+         */
+        toString(): string;
+        /**
+         * Get a JSON representation of the range
+         * @memberof Range
+         * @returns {Object} Returns a JSON object structured as:
+         *                   `{"mathjs": "Range", "start": 2, "end": 4, "step": 1}`
+         */
+        toJSON(): RangeJSON;
+    };
+};
+
 declare class Dual {
     /** Function value (the real part). */
     readonly value: number;
@@ -1732,6 +2445,75 @@ declare const math: {
     configure: (config: Partial<MathTSConfig>) => void;
 };
 
+/**
+ * Numerically stable reduction primitives.
+ *
+ * Floating-point addition is not associative, so *how* you accumulate decides how much error you
+ * carry. These are the algorithms the established numerical stack uses, and the reason it is
+ * trusted.
+ *
+ * Measured on this repo's own reductions before these existed — 1e6 copies of `0.1`, exact answer
+ * 100000:
+ *
+ * | accumulation                    | relative error |
+ * | ------------------------------- | -------------- |
+ * | naive `s += x`                  | **1.3e-11**    |
+ * | pairwise (this, = NumPy's algo) | **2.9e-16**    |
+ * | Neumaier compensated (`fsum`)   | **0** (exact)  |
+ *
+ * NumPy 2.3.4 reports 2.9e-16 on the same input — we are now at parity. Before this, we were
+ * ~46,000× worse than NumPy on a bog-standard `sum`, and `mean`, `std`, `var` and every statistic
+ * inherit that error.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Sum with **pairwise (cascade) summation** — the algorithm behind `np.sum`.
+ *
+ * Naive accumulation lets the running total grow large while the addends stay small, so each
+ * addition rounds off a little more of the total: error grows as **O(n)·ε**. Pairwise summation
+ * adds numbers of *comparable magnitude* by recursively halving the range, so error grows as
+ * **O(log n)·ε** — for n = 10⁶ that is the difference between ~1e-11 and ~1e-16.
+ *
+ * It costs the same number of additions as the naive loop. There is no speed/accuracy trade here;
+ * the naive version is simply worse.
+ *
+ * Not exact: for that, use {@link neumaierSum}. Pairwise is the right default because it is free.
+ */
+declare function pairwiseSum(xs: ArrayLike<number>, start?: number, end?: number): number;
+/**
+ * Sum with **Neumaier compensation** — correctly rounded for practical purposes, the equivalent
+ * of Python's `math.fsum`.
+ *
+ * Tracks the low-order bits that each addition throws away and folds them back in at the end. It
+ * recovers information that pairwise summation cannot: `[1e16, 1, -1e16]` sums to **1** here,
+ * while both naive and pairwise (and `np.sum`) give **0**, because the `1` is annihilated the
+ * moment it meets `1e16`.
+ *
+ * ~2-4× slower than {@link pairwiseSum}, so it is opt-in rather than the default. Reach for it
+ * when catastrophic cancellation is possible: near-zero results from large terms, long-running
+ * accumulators, conservation checks.
+ *
+ * (Neumaier's variant, not classic Kahan: Kahan loses the compensation when the *addend* is
+ * larger than the running sum, which is precisely the `1e16` case.)
+ */
+declare function neumaierSum(xs: ArrayLike<number>): number;
+/**
+ * Euclidean (2-)norm that does **not** overflow or underflow — BLAS's `dnrm2` scaling.
+ *
+ * The obvious `sqrt(Σxᵢ²)` squares before it adds, so it dies well inside the representable
+ * range: `‖[1e200, 1e200, 1e200, 1e200]‖` overflows to `Infinity` (the true answer, 2e200, is
+ * perfectly representable), and `‖[1e-200] × 4‖` **flushes to 0** — a silent wrong answer, which
+ * is worse.
+ *
+ * NumPy has this bug too: `np.linalg.norm([1e200]*4)` returns `inf` with an overflow warning.
+ * LAPACK does not, and neither do we.
+ *
+ * The fix is to carry a running scale: keep the largest magnitude seen out of the sum of squares,
+ * so the accumulator only ever holds ratios in [0, 1].
+ */
+declare function norm2(xs: ArrayLike<number>): number;
+
 /**
  * @danielsimonjr/mathts-core - Core types and utilities for MathTS
  * @packageDocumentation
@@ -1739,4 +2521,4 @@ declare const math: {
 
 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, type RoundingMode, SI_PREFIXES, SQRT1_2, SQRT2, type Scalar, TAU, type TypeDef, TypeRegistry, UNIT_ALIASES, type UnitDef, UnitParseError, VERSION, abs, addScalar, createFactory, createMathTSTyped, 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, number, 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, neumaierSum, norm2, number, pairwiseSum, pow, registerNativeTypes, registry, round, subtractScalar };