@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/dist/typed/string.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Typed String Formatting Functions
+ *
+ * Polymorphic string-formatting operations using typed-function for runtime dispatch.
+ * Supports `number`, `BigNumber`, and `string` types as appropriate for each op.
+ *
+ * These are clean implementations using mathTyped dispatch — the dormant synced
+ * layer under functions/src/string/ is left untouched and used only as an
+ * algorithm reference.
+ *
+ * Semantics follow the mathjs convention:
+ *   - bin/hex/oct: sign-magnitude representation for negative numbers (NOT two's-complement),
+ *     e.g. bin(-5) === '-0b101', hex(-5) === '-0x5'.
+ *     (Two's-complement only applies when the optional wordSize argument is used.)
+ *   - format: delegates to utils/string.ts `format()` which dispatches on number vs
+ *     BigNumber, with full options-object support (notation, precision, lowerExp, upperExp, etc.)
+ *   - print: replaces $key / $key.nested placeholders in a template string using
+ *     values from a supplied object or array.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Format a number as binary.
+ *
+ * Negative numbers use sign-magnitude notation (e.g. -5 → '-0b101').
+ * When the optional `wordSize` argument is supplied the value is
+ * formatted as a signed two's-complement integer of that many bits
+ * and a size suffix ('i<wordSize>') is appended.
+ *
+ * @example
+ * ```typescript
+ * bin(2)     // '0b10'
+ * bin(255)   // '0b11111111'
+ * bin(-5)    // '-0b101'
+ * bin(0)     // '0b0'
+ * ```
+ */
+export declare const bin: import("typed-function").TypedFunction;
+/**
+ * Format a number as hexadecimal.
+ *
+ * Negative numbers use sign-magnitude notation (e.g. -5 → '-0x5').
+ * When the optional `wordSize` argument is supplied the value is
+ * formatted as a signed two's-complement integer of that many bits.
+ *
+ * @example
+ * ```typescript
+ * hex(255)   // '0xff'
+ * hex(-5)    // '-0x5'
+ * hex(0)     // '0x0'
+ * ```
+ */
+export declare const hex: import("typed-function").TypedFunction;
+/**
+ * Format a number as octal.
+ *
+ * Negative numbers use sign-magnitude notation (e.g. -8 → '-0o10').
+ * When the optional `wordSize` argument is supplied the value is
+ * formatted as a signed two's-complement integer of that many bits.
+ *
+ * @example
+ * ```typescript
+ * oct(8)     // '0o10'
+ * oct(-8)    // '-0o10'
+ * oct(0)     // '0o0'
+ * ```
+ */
+export declare const oct: import("typed-function").TypedFunction;
+/**
+ * Format a value of any type into a string.
+ *
+ * When called with a plain number or BigNumber it delegates to the lower-level
+ * `utils/string.ts` formatter which supports the full options object:
+ * `{ notation, precision, lowerExp, upperExp, fraction, truncate }`.
+ *
+ * Passing a positional number as the second argument is shorthand for
+ * `{ precision: n }`.
+ *
+ * @example
+ * ```typescript
+ * format(3.14159, 3)                          // '3.14'
+ * format(0.0001, { precision: 2 })            // '1e-4'
+ * format(12400, { notation: 'engineering' })  // '12.4e+3'
+ * format(Infinity)                            // 'Infinity'
+ * format(NaN)                                 // 'NaN'
+ * ```
+ */
+export declare const format: import("typed-function").TypedFunction;
+/**
+ * Interpolate values into a string template.
+ *
+ * Placeholders have the form `$key` or `$key.nested`. Array indices are
+ * accessed as `$0`, `$1`, etc. Non-string values are converted using `format`.
+ *
+ * @example
+ * ```typescript
+ * print('Hello $name!', { name: 'World' })          // 'Hello World!'
+ * print('Lucy is $age years old', { age: 5 })       // 'Lucy is 5 years old'
+ * print('$0 and $1', ['apples', 'bananas'])          // 'apples and bananas'
+ * print('pi ≈ $pi', { pi: Math.PI }, 4)              // 'pi ≈ 3.142'
+ * ```
+ */
+export declare const print: import("typed-function").TypedFunction;
+/**
+ * All typed string-formatting functions.
+ */
+export declare const typedString: {
+    bin: import("typed-function").TypedFunction;
+    hex: import("typed-function").TypedFunction;
+    oct: import("typed-function").TypedFunction;
+    format: import("typed-function").TypedFunction;
+    print: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=string.d.ts.map

package/dist/typed/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/typed/string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkGH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,GAAG,wCAQd,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,wCAQd,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,GAAG,wCAQd,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,MAAM,wCAyCjB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,wCAShB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;CAMvB,CAAC"}

package/dist/typed/trigonometry.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Typed Trigonometric Functions (Parallel-First)
+ *
+ * Polymorphic trigonometric operations using typed-function.
+ * Supports Complex, BigNumber, and Float64Array types.
+ *
+ * Following the parallel-first philosophy per CLAUDE.md:
+ * - Use workers for ALL array transformations (Float64Array)
+ * - Use workers for ALL numerical computations that can be batched
+ * - Only fall back to sequential for trivial scalar operations
+ *
+ * @packageDocumentation
+ */
+/**
+ * Sine function with parallel array support
+ */
+export declare const sin: import("typed-function").TypedFunction;
+/**
+ * Cosine function with parallel array support
+ */
+export declare const cos: import("typed-function").TypedFunction;
+/**
+ * Tangent function with parallel array support
+ */
+export declare const tan: import("typed-function").TypedFunction;
+/**
+ * Cosecant function (1/sin)
+ */
+export declare const csc: import("typed-function").TypedFunction;
+/**
+ * Secant function (1/cos)
+ */
+export declare const sec: import("typed-function").TypedFunction;
+/**
+ * Cotangent function (1/tan)
+ */
+export declare const cot: import("typed-function").TypedFunction;
+/**
+ * Arc sine (inverse sine)
+ */
+export declare const asin: import("typed-function").TypedFunction;
+/**
+ * Arc cosine (inverse cosine)
+ */
+export declare const acos: import("typed-function").TypedFunction;
+/**
+ * Arc tangent (inverse tangent)
+ */
+export declare const atan: import("typed-function").TypedFunction;
+/**
+ * Arc tangent with two arguments (atan2)
+ */
+export declare const atan2: import("typed-function").TypedFunction;
+/**
+ * Arc cosecant
+ */
+export declare const acsc: import("typed-function").TypedFunction;
+/**
+ * Arc secant
+ */
+export declare const asec: import("typed-function").TypedFunction;
+/**
+ * Arc cotangent
+ */
+export declare const acot: import("typed-function").TypedFunction;
+/**
+ * Inverse hyperbolic sine
+ */
+export declare const asinh: import("typed-function").TypedFunction;
+/**
+ * Inverse hyperbolic cosine
+ */
+export declare const acosh: import("typed-function").TypedFunction;
+/**
+ * Inverse hyperbolic tangent
+ */
+export declare const atanh: import("typed-function").TypedFunction;
+/**
+ * Convert degrees to radians
+ */
+export declare const toRadians: import("typed-function").TypedFunction;
+/**
+ * Convert radians to degrees
+ */
+export declare const toDegrees: import("typed-function").TypedFunction;
+/**
+ * Hypotenuse (sqrt(a^2 + b^2)) without intermediate overflow
+ */
+export declare const hypot: import("typed-function").TypedFunction;
+export declare const typedTrigonometry: {
+    sin: import("typed-function").TypedFunction;
+    cos: import("typed-function").TypedFunction;
+    tan: import("typed-function").TypedFunction;
+    csc: import("typed-function").TypedFunction;
+    sec: import("typed-function").TypedFunction;
+    cot: import("typed-function").TypedFunction;
+    asin: import("typed-function").TypedFunction;
+    acos: import("typed-function").TypedFunction;
+    atan: import("typed-function").TypedFunction;
+    atan2: import("typed-function").TypedFunction;
+    acsc: import("typed-function").TypedFunction;
+    asec: import("typed-function").TypedFunction;
+    acot: import("typed-function").TypedFunction;
+    asinh: import("typed-function").TypedFunction;
+    acosh: import("typed-function").TypedFunction;
+    atanh: import("typed-function").TypedFunction;
+    toRadians: import("typed-function").TypedFunction;
+    toDegrees: import("typed-function").TypedFunction;
+    hypot: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=trigonometry.d.ts.map

package/dist/typed/trigonometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../src/typed/trigonometry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAiBH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAUd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAUd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAUd,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAed,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAed,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,GAAG,wCAed,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAqBf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAoBf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAef,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,wCAGf,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAehB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,SAAS,wCAEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,wCAEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,KAAK,wCAKhB,CAAC;AAMH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;CA2B7B,CAAC"}

package/dist/typed/typed-bridge.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Initialize the type bridge for mathjs factory compatibility.
+ * Call once before using any synced mathjs factories.
+ */
+export declare function initTypeBridge(): void;
+//# sourceMappingURL=typed-bridge.d.ts.map

package/dist/typed/typed-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-bridge.d.ts","sourceRoot":"","sources":["../../src/typed/typed-bridge.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAIrC"}

package/dist/typed/unit.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Typed Unit Functions
+ *
+ * Polymorphic dimensional-analysis operations dispatched through
+ * `mathTyped`. Wraps the {@link Unit} value type from
+ * `@danielsimonjr/mathts-core`:
+ *
+ *  - `to(value, target)` — convert a Unit (or construct one) to a target
+ *    notation. Throws on dimension mismatch.
+ *  - `toBest(value)` — pick the unit (with SI prefix) that gives the
+ *    magnitude closest to 1.
+ *
+ * Both functions accept either a `Unit` instance or a `(value, notation)`
+ * pair (the latter just constructs a `Unit` on the fly).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Convert a quantity to a target unit notation.
+ *
+ * Dispatches over:
+ *
+ *  - `(Unit, string)` — convert an existing Unit to the target.
+ *  - `(number, string)` — construct a Unit from a bare numeric value with
+ *    the given notation. (No conversion happens — the result simply *labels*
+ *    the value with the target notation. Useful for entering a quantity
+ *    into the unit system.)
+ *
+ * @example
+ * ```ts
+ * to(new Unit(1, 'm'), 'ft');       // 1 m → 3.28084 ft
+ * to(20, '°C');                     // construct: 20 °C
+ * ```
+ *
+ * @throws {DimensionMismatchError} when converting between incompatible
+ *   dimension vectors (e.g. metres to seconds).
+ */
+export declare const to: import("typed-function").TypedFunction;
+/**
+ * Pick a unit-of-magnitude representation that places the displayed value
+ * closest to 1.
+ *
+ * For example, `0.0001 m` becomes `0.1 mm`, and `1500 g` (canonical
+ * `1.5 kg`) becomes `1.5 kg`.
+ *
+ * @example
+ * ```ts
+ * toBest(new Unit(0.0001, 'm'));    // 0.1 mm
+ * toBest(new Unit(1000, 'g'));      // 1 kg
+ * ```
+ */
+export declare const toBest: import("typed-function").TypedFunction;
+/**
+ * All typed unit functions combined.
+ */
+export declare const typedUnit: {
+    to: import("typed-function").TypedFunction;
+    toBest: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=unit.d.ts.map

package/dist/typed/unit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit.d.ts","sourceRoot":"","sources":["../../src/typed/unit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,EAAE,wCAGb,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,wCAEjB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,SAAS;;;CAGrB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export type { TypedFunction } from './core/function/typed.js';
+export type { MathJsConfig, ConfigOptions } from './core/config.js';
+export type { MathJsInstance } from './core/create.js';
+export type { Matrix, MathCollection, MathNumericType, MathScalarType, MathArray, } from '../types/index.js';
+export type BigNumber = import('./type/local/Decimal.ts').Decimal;
+export type Complex = import('complex.js').default;
+export type Fraction = import('fraction.js').default;
+export interface SparseMatrix {
+    type: 'SparseMatrix';
+    [key: string]: any;
+}
+export interface Unit {
+    type: 'Unit';
+    [key: string]: any;
+}
+export interface MatrixConstructor {
+    new (...args: any[]): any;
+    [key: string]: any;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAIA,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACpE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,YAAY,EACV,MAAM,EACN,cAAc,EACd,eAAe,EACf,cAAc,EACd,SAAS,GACV,MAAM,mBAAmB,CAAC;AAG3B,MAAM,MAAM,SAAS,GAAG,OAAO,yBAAyB,EAAE,OAAO,CAAC;AAClE,MAAM,MAAM,OAAO,GAAG,OAAO,YAAY,EAAE,OAAO,CAAC;AACnD,MAAM,MAAM,QAAQ,GAAG,OAAO,aAAa,EAAE,OAAO,CAAC;AAGrD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,cAAc,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAGD,MAAM,WAAW,iBAAiB;IAChC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB"}

package/dist/unit/to.d.ts

@@ -0,0 +1,13 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface Matrix {
+    size(): number[];
+    storage(): string;
+}
+interface ToDependencies {
+    typed: TypedFunction;
+    matrix: (data: unknown[]) => Matrix;
+    concat: TypedFunction;
+}
+export declare const createTo: import("../utils/factory.js").FactoryFunction<ToDependencies, unknown>;
+export {};
+//# sourceMappingURL=to.d.ts.map

package/dist/unit/to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to.d.ts","sourceRoot":"","sources":["../../src/unit/to.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAO/D,UAAU,MAAM;IACd,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,IAAI,MAAM,CAAC;CACnB;AAED,UAAU,cAAc;IACtB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;IACpC,MAAM,EAAE,aAAa,CAAC;CACvB;AAKD,eAAO,MAAM,QAAQ,wEA0CpB,CAAC"}

package/dist/unit/toBest.d.ts

@@ -0,0 +1,5 @@
+import type { TypedFunction } from '../core/function/typed.js';
+export declare const createToBest: import("../utils/factory.js").FactoryFunction<{
+    typed: TypedFunction;
+}, unknown>;
+//# sourceMappingURL=toBest.d.ts.map

package/dist/unit/toBest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toBest.d.ts","sourceRoot":"","sources":["../../src/unit/toBest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAU/D,eAAO,MAAM,YAAY;WAGF,aAAa;WA2CnC,CAAC"}

package/dist/utils/array.d.ts

@@ -0,0 +1,249 @@
+import { Index, Matrix } from './is.js';
+export type NestedArray<T> = T | NestedArray<T>[];
+export type ArrayOrScalar<T> = T | T[] | NestedArray<T>;
+export interface IdentifiedValue<T> {
+    value: T;
+    identifier: number;
+}
+/**
+ * Calculate the size of a multi dimensional array.
+ * This function checks the size of the first entry, it does not validate
+ * whether all dimensions match. (use function `validate` for that)
+ * @param {Array} x
+ * @return {number[]} size
+ */
+export declare function arraySize<T>(x: NestedArray<T>): number[];
+/**
+ * Validate whether each element in a multi dimensional array has
+ * a size corresponding to the provided size array.
+ * @param {Array} array    Array to be validated
+ * @param {number[]} size  Array with the size of each dimension
+ * @throws DimensionError
+ */
+export declare function validate<T>(array: NestedArray<T>, size: number[]): void;
+/**
+ * Validate whether the source of the index matches the size of the Array
+ * @param {Array | Matrix} value    Array to be validated
+ * @param {Index} index  Index with the source information to validate
+ * @throws DimensionError
+ */
+export declare function validateIndexSourceSize(value: any[] | Matrix, index: Index): void;
+/**
+ * Test whether index is an integer number with index >= 0 and index < length
+ * when length is provided
+ * @param {number} index    Zero-based index
+ * @param {number} [length] Length of the array
+ */
+export declare function validateIndex(index: number | undefined, length?: number): void;
+/**
+ * Test if an index has empty values
+ * @param {Index} index    Zero-based index
+ */
+export declare function isEmptyIndex(index: Index): boolean;
+/**
+ * Resize a multi dimensional array. The resized array is returned.
+ * @param {Array | number} array         Array to be resized
+ * @param {number[]} size Array with the size of each dimension
+ * @param {*} [defaultValue=0]  Value to be filled in new entries,
+ *                              zero by default. Specify for example `null`,
+ *                              to clearly see entries that are not explicitly
+ *                              set.
+ * @return {Array} array         The resized array
+ */
+export declare function resize<T = any>(array: T | T[] | NestedArray<T>, size: number[], defaultValue?: T): NestedArray<T>;
+/**
+ * Re-shape a multi dimensional array to fit the specified dimensions
+ * @param {Array} array           Array to be reshaped
+ * @param {number[]} sizes        List of sizes for each dimension
+ * @returns {Array}               Array whose data has been formatted to fit the
+ *                                specified dimensions
+ *
+ * @throws {DimensionError}       If the product of the new dimension sizes does
+ *                                not equal that of the old ones
+ */
+export declare function reshape<T = any>(array: NestedArray<T>, sizes: number[]): NestedArray<T>;
+/**
+ * Replaces the wildcard -1 in the sizes array.
+ * @param {number[]} sizes  List of sizes for each dimension. At most one wildcard.
+ * @param {number} currentLength  Number of elements in the array.
+ * @throws {Error}                If more than one wildcard or unable to replace it.
+ * @returns {number[]}      The sizes array with wildcard replaced.
+ */
+export declare function processSizesWildcard(sizes: number[], currentLength: number): number[];
+/**
+ * Squeeze a multi dimensional array
+ * @param {Array} array
+ * @param {Array} [size]
+ * @returns {Array} returns the array itself
+ */
+export declare function squeeze<T>(array: NestedArray<T>, size?: number[]): T | NestedArray<T>;
+/**
+ * Unsqueeze a multi dimensional array: add dimensions when missing
+ *
+ * Parameter `size` will be mutated to match the new, unsqueezed matrix size.
+ *
+ * @param {Array} array
+ * @param {number} dims       Desired number of dimensions of the array
+ * @param {number} [outer]    Number of outer dimensions to be added
+ * @param {Array} [size] Current size of array.
+ * @returns {Array} returns the array itself
+ * @private
+ */
+export declare function unsqueeze<T>(array: NestedArray<T>, dims: number, outer?: number, size?: number[]): NestedArray<T>;
+/**
+ * Flatten a multi dimensional array, put all elements in a one dimensional
+ * array
+ * @param {Array} array   A multi dimensional array
+ * @param {boolean} isRectangular Optional. If the array is rectangular (not jagged)
+ * @return {Array}        The flattened array (1 dimensional)
+ */
+export declare function flatten<T>(array: NestedArray<T>, isRectangular?: boolean): T[];
+/**
+ * A safe map
+ * @param {Array} array
+ * @param {function} callback
+ */
+export declare function map<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => U): U[];
+/**
+ * A safe forEach
+ * @param {Array} array
+ * @param {function} callback
+ */
+export declare function forEach<T>(array: T[], callback: (value: T, index: number, array: T[]) => void): void;
+/**
+ * A safe filter
+ * @param {Array} array
+ * @param {function} callback
+ */
+export declare function filter<T>(array: T[], callback: (value: T, index: number, array: T[]) => boolean): T[];
+/**
+ * Filter values in an array given a regular expression
+ * @param {Array} array
+ * @param {RegExp} regexp
+ * @return {Array} Returns the filtered array
+ * @private
+ */
+export declare function filterRegExp(array: string[], regexp: RegExp): string[];
+/**
+ * A safe join
+ * @param {Array} array
+ * @param {string} separator
+ */
+export declare function join<T>(array: T[], separator: string): string;
+/**
+ * Assign a numeric identifier to every element of a sorted array
+ * @param {Array} a  An array
+ * @return {Array} An array of objects containing the original value and its identifier
+ */
+export declare function identify<T>(a: T[]): IdentifiedValue<T>[];
+/**
+ * Remove the numeric identifier from the elements
+ * @param {array} a  An array
+ * @return {array} An array of values without identifiers
+ */
+export declare function generalize<T>(a: IdentifiedValue<T>[]): T[];
+/**
+ * Check the datatype of a given object
+ * This is a low level implementation that should only be used by
+ * parent Matrix classes such as SparseMatrix or DenseMatrix
+ * This method does not validate Array Matrix shape
+ * @param {Array} array
+ * @param {function} typeOf   Callback function to use to determine the type of a value
+ * @return {string}
+ */
+export declare function getArrayDataType(array: any[], typeOf: (value: any) => string): string | undefined;
+/**
+ * Return the last item from an array
+ * @param {Array} array
+ * @returns {*}
+ */
+export declare function last<T>(array: T[]): T;
+/**
+ * Get all but the last element of array.
+ * @param {Array} array
+ * @returns {Array}
+ */
+export declare function initial<T>(array: T[]): T[];
+/**
+ * Concatenates many arrays in the specified direction
+ * @param {...Array} arrays All the arrays to concatenate
+ * @param {number} concatDim The dimension on which to concatenate (zero-based)
+ * @returns {Array}
+ */
+export declare function concat<T>(...args: [...NestedArray<T>[], number]): NestedArray<T>[];
+/**
+ * Receives two or more sizes and gets the broadcasted size for both.
+ * @param  {...number[]} sizes Sizes to broadcast together
+ * @returns {number[]} The broadcasted size
+ */
+export declare function broadcastSizes(...sizes: number[][]): number[];
+/**
+ * Checks if it's possible to broadcast a size to another size
+ * @param {number[]} size The size of the array to check
+ * @param {number[]} toSize The size of the array to validate if it can be broadcasted to
+ */
+export declare function checkBroadcastingRules(size: number[], toSize: number[]): void;
+/**
+ * Broadcasts a single array to a certain size
+ * @param {Array} array Array to be broadcasted
+ * @param {number[]} toSize Size to broadcast the array
+ * @returns {Array} The broadcasted array
+ */
+export declare function broadcastTo<T>(array: NestedArray<T>, toSize: number[]): NestedArray<T>;
+/**
+ * Broadcasts arrays and returns the broadcasted arrays in an array
+ * @param  {...Array | any} arrays
+ * @returns {Array[]} The broadcasted arrays
+ */
+export declare function broadcastArrays<T>(...arrays: NestedArray<T>[]): NestedArray<T>[];
+/**
+ * Stretches a matrix up to a certain size in a certain dimension
+ * @param {Array} arrayToStretch
+ * @param {number[]} sizeToStretch
+ * @param {number} dimToStretch
+ * @returns {Array} The stretched array
+ */
+export declare function stretch<T>(arrayToStretch: NestedArray<T>, sizeToStretch: number, dimToStretch: number): NestedArray<T>;
+/**
+ * Retrieves a single element from an array given an index.
+ *
+ * @param {Array} array - The array from which to retrieve the value.
+ * @param {Array<number>} index - An array of indices specifying the position of the desired element in each dimension.
+ * @returns {*} - The value at the specified position in the array.
+ *
+ * @example
+ * const arr = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
+ * const index = [1, 0, 1];
+ * console.log(get(arr, index)); // 6
+ */
+export declare function get<T>(array: NestedArray<T>, index: number[]): T;
+/**
+ * Recursively maps over each element of nested array using a provided callback function.
+ *
+ * @param {Array} array - The array to be mapped.
+ * @param {Function} callback - The function to execute on each element, taking three arguments:
+ *   - `value` (any): The current element being processed in the array.
+ *   - `index` (Array<number>): The index of the current element being processed in the array.
+ *   - `array` (Array): The array `deepMap` was called upon.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ * @returns {Array} A new array with each element being the result of the callback function.
+ */
+export declare function deepMap<T, U>(array: NestedArray<T>, callback: ((value: T, index: number[], array: NestedArray<T>) => U) | ((value: T) => U), skipIndex?: boolean): NestedArray<U>;
+/**
+ * Recursively iterates over each element in a multi-dimensional array and applies a callback function.
+ *
+ * @param {Array} array - The multi-dimensional array to iterate over.
+ * @param {Function} callback - The function to execute for each element. It receives three arguments:
+ *   - {any} value: The current element being processed in the array.
+ *   - {Array<number>} index: The index of the current element in each dimension.
+ *   - {Array} array: The original array being processed.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ */
+export declare function deepForEach<T>(array: NestedArray<T>, callback: ((value: T, index: number[], array: NestedArray<T>) => void) | ((value: T) => void), skipIndex?: boolean): void;
+/**
+ * Deep clones a multidimensional array
+ * @param {Array} array
+ * @returns {Array} cloned array
+ */
+export declare function clone<T>(array: T[]): T[];
+//# sourceMappingURL=array.d.ts.map

package/dist/utils/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/utils/array.ts"],"names":[],"mappings":"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"}

package/dist/utils/bigint.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Build a bigint logarithm function from a number logarithm,
+ * still returning a number. The idea is that 15 hexadecimal digits
+ * (60 bits) saturates the mantissa of the log, and each additional hex
+ * digit effectively just adds the log of 16 to the resulting value. So
+ * convert the most significant 15 hex digits to a number and take its
+ * log, and then add the log of 16 for each additional hex digit that
+ * was in the bigint.
+ * For negative numbers (complex logarithms), following the bignum
+ * implementation, it just downgrades to number and uses the complex result.
+ * @param {number} log16  the log of 16
+ * @param {(number) -> number} numberLog  the logarithm function for numbers
+ * @param {ConfigurationObject} config  the mathjs configuration
+ * @param {(number) -> Complex} cplx  the associated Complex log
+ * @returns {(bigint) -> number}   the corresponding logarithm for bigints
+ */
+export declare function promoteLogarithm(log16: any, numberLog: any, config: any, cplx: any): (b: any) => any;
+//# sourceMappingURL=bigint.d.ts.map

package/dist/utils/bigint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint.d.ts","sourceRoot":"","sources":["../../src/utils/bigint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,IAChE,GAAG,GAAG,SASxB"}