@danielsimonjr/mathts-core 0.14.3 → 0.15.0

package/dist/error/DimensionError.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Create a range error with the message:
+ *     'Dimension mismatch (<actual size> != <expected size>)'
+ * Or with a custom message when called with a single string argument.
+ *
+ * The single canonical `DimensionError` for the whole monorepo (Bucket B, commit 1),
+ * exposed via the `@danielsimonjr/mathts-core/internal` subpath. `expression/src/error/
+ * DimensionError.ts` and `functions/src/error/DimensionError.ts` are now thin
+ * re-export shims of this class — a `DimensionError` thrown in one package is
+ * `instanceof DimensionError` in any other, since there is only ever one class
+ * identity. `core/src/array.ts` (and the ~20 other call sites across matrix algos,
+ * subset, resize, concat, reshape, ...) all throw this same class.
+ */
+export declare class DimensionError extends RangeError {
+    actual?: number | number[];
+    expected?: number | number[];
+    relation?: string;
+    isDimensionError: true;
+    /**
+     * @param actual - The actual size or custom error message
+     * @param expected - The expected size (optional if actual is a custom message)
+     * @param relation - Optional relation between actual and expected size: '!=', '<', etc.
+     */
+    constructor(actual: number | number[] | string, expected?: number | number[], relation?: string);
+}
+//# sourceMappingURL=DimensionError.d.ts.map

package/dist/error/DimensionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DimensionError.d.ts","sourceRoot":"","sources":["../../src/error/DimensionError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAC5C,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,OAAiB;IAEjC;;;;OAIG;IACH,YAAY,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAwC9F;CACF"}

package/dist/error/IndexError.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Custom error type for index out of range errors.
+ *
+ * The single canonical `IndexError` for the whole monorepo (Bucket B, commit 1),
+ * exposed via the `@danielsimonjr/mathts-core/internal` subpath. `expression/src/error/
+ * IndexError.ts` and `functions/src/error/IndexError.ts` are now thin re-export shims
+ * of this class — an `IndexError` thrown in one package is `instanceof IndexError`
+ * in any other, since there is only ever one class identity. `core/src/array.ts` /
+ * `core/src/collection.ts` (and the many other call sites across concat, subset,
+ * cumsum, mapSlices, ...) all throw this same class.
+ *
+ * @extends RangeError
+ */
+export declare class IndexError extends RangeError {
+    index: number;
+    min: number | undefined;
+    max: number | undefined;
+    isIndexError: true;
+    /**
+     * Create an IndexError
+     *
+     * Can be called in two ways:
+     * - IndexError(index, max) - assumes min=0
+     * - IndexError(index, min, max)
+     *
+     * @param index  The actual index
+     * @param min    Minimum index (included), or max if only 2 args provided
+     * @param max    Maximum index (excluded)
+     */
+    constructor(index: number, min?: number, max?: number);
+}
+export declare function createIndexError(index: number, min?: number, max?: number): IndexError;
+//# sourceMappingURL=IndexError.d.ts.map

package/dist/error/IndexError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexError.d.ts","sourceRoot":"","sources":["../../src/error/IndexError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAW,SAAQ,UAAU;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,YAAY,OAAiB;IAE7B;;;;;;;;;;OAUG;IACH,YAAY,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAqCpD;CACF;AAID,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAEtF"}

package/dist/error/MathjsError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Custom error type for Mathjs errors
+ * @extends Error
+ */
+export declare class MathjsError extends Error {
+    isMathjsError: true;
+    /**
+     * Create a MathjsError
+     * @param message  Error message
+     */
+    constructor(message: string);
+}
+//# sourceMappingURL=MathjsError.d.ts.map

package/dist/error/MathjsError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MathjsError.d.ts","sourceRoot":"","sources":["../../src/error/MathjsError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,aAAa,OAAiB;IAE9B;;;OAGG;IACH,YAAY,OAAO,EAAE,MAAM,EAgB1B;CACF"}

package/dist/factory/factory.d.ts

@@ -0,0 +1,154 @@
+/**
+ * MathTS Function Factory
+ *
+ * Provides a factory pattern for creating MathTS functions with:
+ * - Typed function dispatch via typed-function
+ * - Dependency injection for inter-function references
+ * - Backend selection integration
+ * - Lazy loading support
+ *
+ * @packageDocumentation
+ */
+import type { TypedFunction, TypedInstance, SignatureFunction, ReferTo, ReferToSelf } from '../typed/mathts-typed.js';
+/**
+ * Configuration for MathTS instance
+ */
+export interface MathTSConfig {
+    /** Numeric precision (for BigNumber) */
+    precision: number;
+    /** Default matrix type */
+    matrix: 'Matrix' | 'Array';
+    /** Number type for parsing */
+    number: 'number' | 'BigNumber' | 'Fraction';
+    /** Enable predictable randomness */
+    randomSeed: string | null;
+    /** Epsilon for floating point comparison */
+    epsilon: number;
+    /** Preferred backend for matrix operations */
+    preferredBackend: 'auto' | 'js' | 'wasm' | 'gpu';
+    /** Minimum elements to use WASM backend */
+    wasmThreshold: number;
+    /** Minimum elements to use GPU backend */
+    gpuThreshold: number;
+    /** Enable parallel processing */
+    parallelEnabled: boolean;
+    /** Minimum elements to parallelize */
+    parallelThreshold: number;
+}
+/**
+ * Default MathTS configuration
+ */
+export declare const DEFAULT_CONFIG: MathTSConfig;
+/**
+ * Factory function definition
+ */
+export interface FactoryFunction<T = TypedFunction> {
+    /** Name of the function */
+    name: string;
+    /** Dependencies required by this function */
+    dependencies: string[];
+    /** Factory that creates the function given dependencies */
+    factory: (deps: FactoryDependencies) => T;
+}
+/**
+ * Dependencies passed to factory functions
+ */
+export interface FactoryDependencies {
+    /** MathTS configuration */
+    config: MathTSConfig;
+    /** typed-function instance */
+    typed: TypedInstance;
+    /** Registered functions (for cross-references) */
+    [key: string]: unknown;
+}
+/**
+ * Import definition for a factory function
+ */
+export type FactoryImport = FactoryFunction | (() => Promise<FactoryFunction>);
+/**
+ * MathTS function registry
+ */
+export declare class FunctionRegistry {
+    private factories;
+    private instances;
+    private dependencies;
+    private creating;
+    constructor(config?: Partial<MathTSConfig>, typed?: TypedInstance);
+    /**
+     * Register a factory function
+     */
+    register(factory: FactoryFunction): void;
+    /**
+     * Register multiple factory functions
+     */
+    registerAll(factories: FactoryFunction[]): void;
+    /**
+     * Get or create a function by name
+     */
+    get(name: string): TypedFunction;
+    /**
+     * Check if a function is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered function names
+     */
+    names(): string[];
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<MathTSConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): MathTSConfig;
+}
+/**
+ * Create a factory function definition
+ *
+ * @example
+ * ```typescript
+ * export const addFactory = createFactory('add', ['typed'], ({ typed }) =>
+ *   typed('add', {
+ *     'number, number': (a, b) => a + b,
+ *     'Complex, Complex': (a, b) => ({ re: a.re + b.re, im: a.im + b.im }),
+ *   })
+ * );
+ * ```
+ */
+export declare function createFactory<T = TypedFunction>(name: string, dependencies: string[], factory: (deps: FactoryDependencies) => T): FactoryFunction<T>;
+/**
+ * Create a typed function using the factory pattern
+ *
+ * This is a convenience wrapper that creates a factory and immediately
+ * invokes it with the default dependencies.
+ *
+ * @example
+ * ```typescript
+ * export const add = createTypedFunction('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'string, string': (a, b) => a + b,
+ * });
+ * ```
+ */
+export declare function createTypedFunction(name: string, signatures: Record<string, SignatureFunction | ReferTo | ReferToSelf>): TypedFunction;
+export declare const registry: FunctionRegistry;
+export declare const math: {
+    /**
+     * Get a registered function
+     */
+    get: (name: string) => TypedFunction;
+    /**
+     * Register a factory function
+     */
+    register: (factory: FactoryFunction) => void;
+    /**
+     * Get configuration
+     */
+    config: () => MathTSConfig;
+    /**
+     * Update configuration
+     */
+    configure: (config: Partial<MathTSConfig>) => void;
+};
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory/factory.d.ts.map

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

package/dist/factory/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Factory pattern exports
+ */
+export { FunctionRegistry, createFactory, createTypedFunction, registry, math, DEFAULT_CONFIG, } from './factory.js';
+export type { MathTSConfig, FactoryFunction, FactoryDependencies, FactoryImport, } from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factory/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACnB,QAAQ,EACR,IAAI,EACJ,cAAc,GACf,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,aAAa,GACd,MAAM,cAAc,CAAC"}

package/dist/factory.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Type for a factory function that creates instances
+ */
+export interface FactoryFunction<TResult = unknown> {
+    (scope: Record<string, unknown>): TResult;
+    isFactory: true;
+    fn: string;
+    dependencies: string[];
+    meta?: FactoryMeta;
+}
+/**
+ * Type for legacy factory objects (old-style factories)
+ */
+export interface LegacyFactory {
+    type?: string;
+    name: string;
+    factory: (...args: unknown[]) => unknown;
+    math?: boolean;
+    dependencies?: string[];
+    meta?: FactoryMeta;
+}
+/**
+ * Meta information that can be attached to a factory
+ */
+export interface FactoryMeta {
+    /**
+     * If true, the factory will be recreated when config changes
+     */
+    recreateOnConfigChange?: boolean;
+    /**
+     * If true, this is a lazy factory that should only be created when needed
+     */
+    lazy?: boolean;
+    /**
+     * Additional custom metadata
+     */
+    [key: string]: unknown;
+}
+/**
+ * Type for dependency names, which can be optional (prefixed with '?')
+ */
+export type DependencyName = string;
+/**
+ * Type for the create callback function
+ */
+export type CreateFunction<TDeps extends Record<string, unknown>, TResult> = (dependencies: TDeps) => TResult;
+/**
+ * Create a factory function, which can be used to inject dependencies.
+ *
+ * The created functions are memoized, a consecutive call of the factory
+ * with the exact same inputs will return the same function instance.
+ * The memoized cache is exposed on `factory.cache` and can be cleared
+ * if needed.
+ *
+ * Example:
+ *
+ *     const name = 'log'
+ *     const dependencies = ['config', 'typed', 'divideScalar', 'Complex']
+ *
+ *     export const createLog = factory(name, dependencies, ({ typed, config, divideScalar, Complex }) => {
+ *       // ... create the function log here and return it
+ *     }
+ *
+ * @param name           Name of the function to be created
+ * @param dependencies   The names of all required dependencies
+ * @param create         Callback function called with an object with all dependencies
+ * @param meta           Optional object with meta information that will be attached
+ *                       to the created factory function as property `meta`. For explanation
+ *                       of what meta properties can be specified and what they mean, see
+ *                       docs/core/extension.md.
+ * @returns The factory function
+ */
+export declare function factory<TDeps extends Record<string, unknown> = Record<string, unknown>, TResult = unknown>(name: string, dependencies: DependencyName[], create: CreateFunction<TDeps, TResult>, meta?: FactoryMeta): FactoryFunction<TResult>;
+/**
+ * Sort all factories such that when loading in order, the dependencies are resolved.
+ *
+ * @param factories Array of factory functions or legacy factories
+ * @returns Returns a new array with the sorted factories
+ */
+export declare function sortFactories(factories: Array<FactoryFunction | LegacyFactory>): Array<FactoryFunction | LegacyFactory>;
+export declare function create(factories: Array<FactoryFunction | LegacyFactory>, scope?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Test whether an object is a factory. This is the case when it has
+ * properties name, dependencies, and a function create.
+ * @param obj Any value to test
+ * @returns true if obj is a factory function
+ */
+export declare function isFactory(obj: unknown): obj is FactoryFunction;
+/**
+ * Assert that all dependencies of a list with dependencies are available in the provided scope.
+ *
+ * Will throw an exception when there are dependencies missing.
+ *
+ * @param name         Name for the function to be created. Used to generate a useful error message
+ * @param dependencies Array of dependency names
+ * @param scope        Object containing the available dependencies
+ * @throws Error if required dependencies are missing
+ */
+export declare function assertDependencies(name: string, dependencies: DependencyName[], scope: Record<string, unknown>): void;
+/**
+ * Check if a dependency is optional (starts with '?')
+ * @param dependency The dependency name to check
+ * @returns true if the dependency is optional
+ */
+export declare function isOptionalDependency(dependency: DependencyName): boolean;
+/**
+ * Remove the optional notation '?' from a dependency name
+ * @param dependency The dependency name
+ * @returns The dependency name without optional notation
+ */
+export declare function stripOptionalNotation(dependency: DependencyName): string;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,OAAO;IAChD,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC1C,SAAS,EAAE,IAAI,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACzC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;OAEG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,IAAI,CAC3E,YAAY,EAAE,KAAK,KAChB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,OAAO,CACrB,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,OAAO,GAAG,OAAO,EAEjB,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,cAAc,EAAE,EAC9B,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,EACtC,IAAI,CAAC,EAAE,WAAW,GACjB,eAAe,CAAC,OAAO,CAAC,CAoB1B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,KAAK,CAAC,eAAe,GAAG,aAAa,CAAC,GAChD,KAAK,CAAC,eAAe,GAAG,aAAa,CAAC,CA0FxC;AAGD,wBAAgB,MAAM,CACpB,SAAS,EAAE,KAAK,CAAC,eAAe,GAAG,aAAa,CAAC,EACjD,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAClC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQzB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,eAAe,CAG9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,cAAc,EAAE,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,IAAI,CAeN;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAIxE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,cAAc,GAAG,MAAM,CAExE"}