@danielsimonjr/mathts-core 0.14.3 → 0.15.0

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAU7C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAoBrE,cAAc,cAAc,CAAC;AAM7B,OAAO,EACL,MAAM,IAAI,aAAa,EACvB,SAAS,EACT,MAAM,EACN,WAAW,EACX,KAAK,oBAAoB,GAC1B,MAAM,aAAa,CAAC;AAMrB,OAAO,EACL,MAAM,IAAI,eAAe,EACzB,aAAa,IAAI,sBAAsB,EACvC,aAAa,IAAI,sBAAsB,EACvC,OAAO,IAAI,gBAAgB,EAC3B,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC;AAIlC,mBAAmB,4BAA4B,CAAC;AAMhD,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAe5F,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,SAAS,EACT,QAAQ,EACR,uBAAuB,EACvB,aAAa,EACb,YAAY,EACZ,MAAM,EACN,OAAO,EACP,oBAAoB,EACpB,OAAO,EACP,SAAS,EACT,OAAO,EACP,GAAG,EACH,OAAO,EACP,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,IAAI,EACJ,OAAO,EACP,MAAM,EACN,cAAc,EACd,sBAAsB,EACtB,WAAW,EACX,eAAe,EACf,OAAO,EACP,GAAG,IAAI,eAAe,EACtB,OAAO,IAAI,YAAY,EACvB,WAAW,IAAI,gBAAgB,EAC/B,KAAK,IAAI,UAAU,GACpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,SAAS,EACT,QAAQ,EACR,MAAM,IAAI,SAAS,EACnB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAOlB,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAc3E,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC"}

package/dist/is.d.ts

@@ -0,0 +1,102 @@
+export interface BigNumber {
+    isBigNumber: boolean;
+    constructor: {
+        prototype: {
+            isBigNumber: boolean;
+        };
+        isDecimal?: (x: unknown) => boolean;
+    };
+}
+export interface Complex {
+    re: number;
+    im: number;
+}
+export interface Fraction {
+    n: number;
+    d: number;
+}
+export interface Unit {
+    constructor: {
+        prototype: {
+            isUnit: boolean;
+        };
+    };
+}
+export interface Matrix {
+    isMatrix?: boolean;
+    _size?: number[];
+    constructor: {
+        prototype: {
+            isMatrix: boolean;
+        };
+    };
+}
+export interface DenseMatrix extends Matrix {
+    isDenseMatrix: boolean;
+}
+export interface SparseMatrix extends Matrix {
+    isSparseMatrix: boolean;
+}
+export interface Range {
+    start: number;
+    end: number;
+    step: number;
+    constructor: {
+        prototype: {
+            isRange: boolean;
+        };
+    };
+}
+export interface IndexDimension {
+    _data?: unknown[];
+    _size: number[];
+    isRange?: boolean;
+    start?: number;
+    end?: number;
+}
+export interface Index {
+    _dimensions: (IndexDimension | string)[];
+    _sourceSize?: (number | null)[];
+    constructor: {
+        prototype: {
+            isIndex: boolean;
+        };
+    };
+}
+export declare function isNumber(x: unknown): x is number;
+export declare function isBigNumber(x: unknown): x is BigNumber;
+export declare function isBigInt(x: unknown): x is bigint;
+export declare function isComplex(x: unknown): x is Complex;
+export declare function isFraction(x: unknown): x is Fraction;
+export declare function isUnit(x: unknown): x is Unit;
+export declare function isString(x: unknown): x is string;
+export declare const isArray: (arg: any) => arg is any[];
+export declare function isMatrix(x: unknown): x is Matrix;
+/**
+ * Test whether a value is a collection: an Array or Matrix
+ * @param {*} x
+ * @returns {boolean} isCollection
+ */
+export declare function isCollection(x: unknown): x is unknown[] | Matrix;
+export declare function isDenseMatrix(x: unknown): x is DenseMatrix;
+export declare function isSparseMatrix(x: unknown): x is SparseMatrix;
+export declare function isRange(x: unknown): x is Range;
+export declare function isIndex(x: unknown): x is Index;
+export declare function isBoolean(x: unknown): x is boolean;
+export declare function isFunction(x: unknown): x is (...args: unknown[]) => unknown;
+export declare function isDate(x: unknown): x is Date;
+export declare function isRegExp(x: unknown): x is RegExp;
+export declare function isObject(x: unknown): x is Record<string, unknown>;
+/**
+ * Returns `true` if the passed object appears to be a Map (i.e. duck typing).
+ *
+ * Methods looked for are `get`, `set`, `keys` and `has`.
+ *
+ * @param {Map | object} object
+ * @returns
+ */
+export declare function isMap(object: unknown): object is Map<unknown, unknown>;
+export declare function isNull(x: unknown): x is null;
+export declare function isUndefined(x: unknown): x is undefined;
+export declare function typeOf(x: unknown): string;
+//# sourceMappingURL=is.d.ts.map

package/dist/is.d.ts.map

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

package/dist/map.d.ts

@@ -0,0 +1,113 @@
+/**
+ * A map facade on a bare object.
+ *
+ * The small number of methods needed to implement a scope,
+ * forwarding on to the SafeProperty functions. Over time, the codebase
+ * will stop using this method, as all objects will be Maps, rather than
+ * more security prone objects.
+ */
+/**
+ * The iterator type `Map` itself declares, derived from the installed TS lib
+ * rather than hard-coded: older libs say `IterableIterator<[K, V]>`, TS >= 5.6
+ * says `MapIterator<[K, V]>` (which additionally requires `[Symbol.dispose]`).
+ * Deriving it keeps `implements Map<K, V>` honest on every TS version.
+ */
+type MapEntryIterator<K, V> = ReturnType<Map<K, V>[typeof Symbol.iterator]>;
+export declare class ObjectWrappingMap<K = string, V = unknown> implements Map<K, V> {
+    wrappedObject: Record<string, V>;
+    readonly [Symbol.toStringTag]: string;
+    constructor(object: Record<string, V>);
+    /**
+     * Declared as a real method rather than assigned in the constructor through a
+     * cast. The old form satisfied the runtime but never appeared in the emitted
+     * type, so `implements Map<K, V>` was a lie that only surfaced downstream:
+     * consumers compiling with `skipLibCheck: false` got TS2420 ("incorrectly
+     * implements interface 'Map'... '[Symbol.iterator]' is missing").
+     */
+    [Symbol.iterator](): MapEntryIterator<K, V>;
+    keys(): IterableIterator<K>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    entries(): IterableIterator<[K, V]>;
+    values(): IterableIterator<V>;
+    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * Create a map with two partitions: a and b.
+ * The set with bKeys determines which keys/values are read/written to map b,
+ * all other values are read/written to map a
+ *
+ * For example:
+ *
+ *   const a = new Map()
+ *   const b = new Map()
+ *   const p = new PartitionedMap(a, b, new Set(['x', 'y']))
+ *
+ * In this case, values `x` and `y` are read/written to map `b`,
+ * all other values are read/written to map `a`.
+ */
+export declare class PartitionedMap<K = unknown, V = unknown> implements Map<K, V> {
+    a: Map<K, V>;
+    b: Map<K, V>;
+    bKeys: Set<K>;
+    readonly [Symbol.toStringTag]: string;
+    /**
+     * @param a - Primary map
+     * @param b - Secondary map
+     * @param bKeys - Set of keys that should be read/written to map b
+     */
+    constructor(a: Map<K, V>, b: Map<K, V>, bKeys: Set<K>);
+    /** See the note on `ObjectWrappingMap[Symbol.iterator]` — same fix. */
+    [Symbol.iterator](): MapEntryIterator<K, V>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * Creates an empty map, or whatever your platform's polyfill is.
+ *
+ * @returns an empty Map or Map like object.
+ */
+export declare function createEmptyMap<K = string, V = unknown>(): Map<K, V>;
+/**
+ * Creates a Map from the given object.
+ *
+ * @param mapOrObject - Map or object to convert
+ * @returns Map instance
+ */
+export declare function createMap<K = string, V = unknown>(mapOrObject?: Map<K, V> | Record<string, V> | null): Map<K, V>;
+/**
+ * Unwraps a map into an object.
+ *
+ * @param map - Map to convert to object
+ * @returns Plain object
+ */
+export declare function toObject<V = unknown>(map: Map<unknown, V>): Record<string, V>;
+/**
+ * Copies the contents of key-value pairs from each `objects` in to `map`.
+ *
+ * Object is `objects` can be a `Map` or object.
+ *
+ * This is the `Map` analog to `Object.assign`.
+ */
+export declare function assign<K = unknown, V = unknown>(map: Map<K, V>, ...objects: (Map<K, V> | Record<string, V> | null | undefined)[]): Map<K, V>;
+/**
+ * Returns `true` if `object` is an {@link ObjectWrappingMap}.
+ *
+ * Defined here, next to the class it guards, so `is.ts` need not import
+ * `map.ts` — that import was the sole edge closing the `is`/`map` cycle.
+ */
+export declare function isObjectWrappingMap(object: unknown): object is ObjectWrappingMap;
+export {};
+//# sourceMappingURL=map.d.ts.map

package/dist/map.d.ts.map

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

package/dist/number.d.ts

@@ -0,0 +1,314 @@
+/**
+ * Split value representation with sign, coefficients, and exponent
+ */
+export interface SplitValue {
+    sign: '+' | '-' | '';
+    coefficients: number[];
+    exponent: number;
+}
+/**
+ * Configuration for number type handling
+ */
+export interface NumberTypeConfig {
+    number: 'number' | 'BigNumber' | 'bigint' | 'Fraction';
+    numberFallback: 'number' | 'BigNumber';
+}
+/**
+ * Format options for number formatting
+ */
+export interface FormatOptions {
+    notation?: 'auto' | 'exponential' | 'fixed' | 'engineering' | 'bin' | 'oct' | 'hex';
+    precision?: number;
+    wordSize?: number;
+    lowerExp?: number;
+    upperExp?: number;
+}
+/**
+ * Normalized format options
+ */
+export interface NormalizedFormatOptions {
+    notation: 'auto' | 'exponential' | 'fixed' | 'engineering' | 'bin' | 'oct' | 'hex';
+    precision: number | undefined;
+    wordSize: number | undefined;
+}
+/**
+ * Check if a number is integer
+ * @param value The value to check
+ * @return true if value is an integer
+ */
+export declare function isInteger(value: number | boolean): boolean;
+/**
+ * Ensure the number type is compatible with the provided value.
+ * If not, return 'number' instead.
+ *
+ * For example:
+ *
+ *     safeNumberType('2.3', { number: 'bigint', numberFallback: 'number' })
+ *
+ * will return 'number' and not 'bigint' because trying to create a bigint with
+ * value 2.3 would throw an exception.
+ *
+ * @param numberStr The number as a string
+ * @param config    Configuration with number type preferences
+ * @returns The safe number type to use
+ */
+export declare function safeNumberType(numberStr: string, config: NumberTypeConfig): 'number' | 'BigNumber' | 'bigint' | 'Fraction';
+/**
+ * Calculate the sign of a number
+ * @param x The number
+ * @returns 1 for positive, -1 for negative, 0 for zero
+ */
+export declare const sign: (x: number) => number;
+/**
+ * Calculate the base-2 logarithm of a number
+ * @param x The number
+ * @returns The base-2 logarithm
+ */
+export declare const log2: (x: number) => number;
+/**
+ * Calculate the base-10 logarithm of a number
+ * @param x The number
+ * @returns The base-10 logarithm
+ */
+export declare const log10: (x: number) => number;
+/**
+ * Calculate the natural logarithm of a number + 1
+ * @param x The number
+ * @returns ln(x + 1)
+ */
+export declare const log1p: (x: number) => number;
+/**
+ * Calculate cubic root for a number
+ *
+ * Code from es6-shim.js:
+ *   https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L1564-L1577
+ *
+ * @param x The number
+ * @returns The cubic root of x
+ */
+export declare const cbrt: (x: number) => number;
+/**
+ * Calculates exponentiation minus 1
+ * @param x The exponent
+ * @return exp(x) - 1
+ */
+export declare const expm1: (x: number) => number;
+/**
+ * Convert a number to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'engineering'    Always use engineering notation.
+ *                                          For example '123.4e+0' and '14.0e+6'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lowerExp` and `upperExp` bounds, and
+ *                                          uses exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                         'bin', 'oct, or
+ *                         'hex'            Format the number using binary, octal,
+ *                                          or hexadecimal notation.
+ *                                          For example '0b1101' and '0x10fe'.
+ *                     {number} wordSize    The word size in bits to use for formatting
+ *                                          in binary, octal, or hexadecimal notation.
+ *                                          To be used only with 'bin', 'oct', or 'hex'
+ *                                          values for 'notation' option. When this option
+ *                                          is defined the value is formatted as a signed
+ *                                          twos complement integer of the given word size
+ *                                          and the size suffix is appended to the output.
+ *                                          For example
+ *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
+ *                                          Default value is undefined.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default,
+ *                                          not rounding any digits.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12.071, {notation: 'fixed'})                // '12'
+ *    format(2.3,    {notation: 'fixed', precision: 2})  // '2.30'
+ *    format(52.8,   {notation: 'exponential'})          // '5.28e+1'
+ *    format(12345678, {notation: 'engineering'})        // '12.345678e+6'
+ *
+ * @param value   The number to format
+ * @param options Optional formatting options or custom formatter function or precision
+ * @return The formatted value
+ */
+export declare function format(value: number, options?: FormatOptions | ((value: number) => string) | number): string;
+/**
+ * Normalize format options into an object:
+ *   {
+ *     notation: string,
+ *     precision: number | undefined,
+ *     wordSize: number | undefined
+ *   }
+ * @param options The input options
+ * @returns Normalized format options
+ */
+export declare function normalizeFormatOptions(options?: FormatOptions | number): NormalizedFormatOptions;
+/**
+ * Split a number into sign, coefficients, and exponent
+ * @param value The number or string to split
+ * @return Object containing sign, coefficients, and exponent
+ */
+export declare function splitNumber(value: number | string): SplitValue;
+/**
+ * Format a number in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param value     The number or string to format
+ * @param precision Optional number of significant figures to return
+ * @returns The formatted string
+ */
+export declare function toEngineering(value: number | string, precision?: number): string;
+/**
+ * Format a number with fixed notation.
+ * @param value     The number or string to format
+ * @param precision Optional number of decimals after the decimal point
+ * @returns The formatted string
+ */
+export declare function toFixed(value: number | string, precision?: number): string;
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param value     The number or string to format
+ * @param precision Number of digits in formatted output
+ * @returns The formatted string
+ */
+export declare function toExponential(value: number | string, precision?: number): string;
+/**
+ * Format a number with a certain precision
+ * @param value     The number or string to format
+ * @param precision Optional number of digits
+ * @param options   Optional formatting options (lowerExp, upperExp)
+ * @return The formatted string
+ */
+export declare function toPrecision(value: number | string, precision?: number, options?: FormatOptions): string;
+/**
+ * Round the number of digits of a number
+ * @param split     A value split with .splitNumber(value)
+ * @param precision A positive integer
+ * @return Object containing sign, coefficients, and exponent with rounded digits
+ */
+export declare function roundDigits(split: SplitValue, precision?: number): SplitValue;
+/**
+ * Count the number of significant digits of a number.
+ *
+ * For example:
+ *   2.34 returns 3
+ *   0.0034 returns 2
+ *   120.5e+30 returns 4
+ *
+ * @param value The number
+ * @return Number of significant digits
+ */
+export declare function digits(value: number): number;
+/**
+ * Compares two floating point numbers.
+ * @param a      First value to compare
+ * @param b      Second value to compare
+ * @param relTol The relative tolerance, indicating the maximum allowed difference relative to the larger absolute value. Must be greater than 0.
+ * @param absTol The minimum absolute tolerance, useful for comparisons near zero. Must be at least 0.
+ * @return whether the two numbers are nearly equal
+ *
+ * @throws Error If `relTol` is less than or equal to 0.
+ * @throws Error If `absTol` is less than 0.
+ *
+ * @example
+ * nearlyEqual(1.000000001, 1.0, 1e-8);            // true
+ * nearlyEqual(1.000000002, 1.0, 0);               // false
+ * nearlyEqual(1.0, 1.009, undefined, 0.01);       // true
+ * nearlyEqual(0.000000001, 0.0, undefined, 1e-8); // true
+ */
+export declare function nearlyEqual(a: number, b: number, relTol?: number, absTol?: number): boolean;
+/**
+ * Calculate the hyperbolic arccos of a number
+ * @param x The number
+ * @return The hyperbolic arccosine
+ */
+export declare const acosh: (x: number) => number;
+/**
+ * Calculate the hyperbolic arcsine of a number
+ * @param x The number
+ * @return The hyperbolic arcsine
+ */
+export declare const asinh: (x: number) => number;
+/**
+ * Calculate the hyperbolic arctangent of a number
+ * @param x The number
+ * @return The hyperbolic arctangent
+ */
+export declare const atanh: (x: number) => number;
+/**
+ * Calculate the hyperbolic cosine of a number
+ * @param x The number
+ * @returns The hyperbolic cosine
+ */
+export declare const cosh: (x: number) => number;
+/**
+ * Calculate the hyperbolic sine of a number
+ * @param x The number
+ * @returns The hyperbolic sine
+ */
+export declare const sinh: (x: number) => number;
+/**
+ * Calculate the hyperbolic tangent of a number
+ * @param x The number
+ * @returns The hyperbolic tangent
+ */
+export declare const tanh: (x: number) => number;
+/**
+ * Returns a value with the magnitude of x and the sign of y.
+ * @param x The value providing the magnitude
+ * @param y The value providing the sign
+ * @returns Value with magnitude of x and sign of y
+ */
+export declare function copysign(x: number, y: number): number;
+/**
+ * Check if x^y is 0 due to infinity
+ * @param x The base
+ * @param y The exponent
+ * @returns true if x^y is 0 due to infinity
+ */
+export declare function isPowZeroAtInfinity(x: number, y: number): boolean;
+//# sourceMappingURL=number.d.ts.map

package/dist/number.d.ts.map

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