@cortex-js/compute-engine 0.50.2 → 0.51.1

package/dist/types/compute-engine/compilation/javascript-target.d.ts

@@ -1,6 +1,7 @@
-/* 0.50.2 */
-import { chop, factorial, gcd, lcm, limit } from '../numerics/numeric';
-import { gamma, gammaln } from '../numerics/special-functions';
+/* 0.51.1 */
+import { chop, factorial, factorial2, gcd, lcm, limit } from '../numerics/numeric';
+import { gamma, gammaln, erf, erfc, erfInv, beta, digamma, trigamma, polygamma, zeta, lambertW, besselJ, besselY, besselI, besselK, airyAi, airyBi, fresnelS, fresnelC, sinc } from '../numerics/special-functions';
+import { choose } from '../boxed-expression/expand';
 import { interquartileRange, kurtosis, mean, median, mode, populationStandardDeviation, populationVariance, quartiles, skewness, standardDeviation, variance } from '../numerics/statistics';
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
@@ -8,10 +9,21 @@ import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarge
  */
 export declare class ComputeEngineFunction extends Function {
     SYS: {
+        color(input: string): number[];
+        colorToString(input: string | number[], format?: string): string;
+        colorMix(input1: string | number[], input2: string | number[], ratio?: number): number[];
+        colorContrast(bg: string | number[], fg: string | number[]): number;
+        contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
+        colorToColorspace(input: string | number[], space: string): number[];
+        colormap(name: string, arg?: number): number[] | number[][];
+        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        colorFromColorspace(components: number[], space: string): number[];
         chop: typeof chop;
         factorial: typeof factorial;
+        factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
+        heaviside: (x: number) => 0 | 1 | 0.5;
         integrate: (f: any, a: any, b: any) => number;
         lcm: typeof lcm;
         lngamma: typeof gammaln;
@@ -27,6 +39,136 @@ export declare class ComputeEngineFunction extends Function {
         mode: typeof mode;
         quartiles: typeof quartiles;
         interquartileRange: typeof interquartileRange;
+        erf: typeof erf;
+        erfc: typeof erfc;
+        erfInv: typeof erfInv;
+        beta: typeof beta;
+        digamma: typeof digamma;
+        trigamma: typeof trigamma;
+        polygamma: typeof polygamma;
+        zeta: typeof zeta;
+        lambertW: typeof lambertW;
+        besselJ: typeof besselJ;
+        besselY: typeof besselY;
+        besselI: typeof besselI;
+        besselK: typeof besselK;
+        airyAi: typeof airyAi;
+        airyBi: typeof airyBi;
+        sinc: typeof sinc;
+        fresnelS: typeof fresnelS;
+        fresnelC: typeof fresnelC;
+        binomial: typeof choose;
+        fibonacci: typeof fibonacci;
+        csin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        catan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csinh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccosh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctanh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csqrt: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cexp: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cln: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cpow: (z: any, w: any) => {
+            re: number;
+            im: number;
+        };
+        ccot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cabs: (z: any) => any;
+        carg: (z: any) => any;
+        cconj: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cneg: (z: any) => {
+            re: number;
+            im: number;
+        };
     };
     constructor(body: string, preamble?: string);
 }
@@ -35,10 +177,21 @@ export declare class ComputeEngineFunction extends Function {
  */
 export declare class ComputeEngineFunctionLiteral extends Function {
     SYS: {
+        color(input: string): number[];
+        colorToString(input: string | number[], format?: string): string;
+        colorMix(input1: string | number[], input2: string | number[], ratio?: number): number[];
+        colorContrast(bg: string | number[], fg: string | number[]): number;
+        contrastingColor(bg: string | number[], fg1?: string | number[], fg2?: string | number[]): number[];
+        colorToColorspace(input: string | number[], space: string): number[];
+        colormap(name: string, arg?: number): number[] | number[][];
+        _interpolatePalette(colors: [number, number, number][], t: number): number[];
+        colorFromColorspace(components: number[], space: string): number[];
         chop: typeof chop;
         factorial: typeof factorial;
+        factorial2: typeof factorial2;
         gamma: typeof gamma;
         gcd: typeof gcd;
+        heaviside: (x: number) => 0 | 1 | 0.5;
         integrate: (f: any, a: any, b: any) => number;
         lcm: typeof lcm;
         lngamma: typeof gammaln;
@@ -54,6 +207,136 @@ export declare class ComputeEngineFunctionLiteral extends Function {
         mode: typeof mode;
         quartiles: typeof quartiles;
         interquartileRange: typeof interquartileRange;
+        erf: typeof erf;
+        erfc: typeof erfc;
+        erfInv: typeof erfInv;
+        beta: typeof beta;
+        digamma: typeof digamma;
+        trigamma: typeof trigamma;
+        polygamma: typeof polygamma;
+        zeta: typeof zeta;
+        lambertW: typeof lambertW;
+        besselJ: typeof besselJ;
+        besselY: typeof besselY;
+        besselI: typeof besselI;
+        besselK: typeof besselK;
+        airyAi: typeof airyAi;
+        airyBi: typeof airyBi;
+        sinc: typeof sinc;
+        fresnelS: typeof fresnelS;
+        fresnelC: typeof fresnelC;
+        binomial: typeof choose;
+        fibonacci: typeof fibonacci;
+        csin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casin: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacos: (z: any) => {
+            re: number;
+            im: number;
+        };
+        catan: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csinh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccosh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ctanh: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csqrt: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cexp: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cln: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cpow: (z: any, w: any) => {
+            re: number;
+            im: number;
+        };
+        ccot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        csech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        ccsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacot: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casec: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsc: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacoth: (z: any) => {
+            re: number;
+            im: number;
+        };
+        casech: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cacsch: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cabs: (z: any) => any;
+        carg: (z: any) => any;
+        cconj: (z: any) => {
+            re: number;
+            im: number;
+        };
+        cneg: (z: any) => {
+            re: number;
+            im: number;
+        };
     };
     constructor(body: string, args: string[]);
 }
@@ -66,3 +349,8 @@ export declare class JavaScriptTarget implements LanguageTarget<Expression> {
     createTarget(options?: Partial<CompileTarget<Expression>>): CompileTarget<Expression>;
     compile(expr: Expression, options?: CompilationOptions<Expression>): CompilationResult;
 }
+/**
+ * Compute the nth Fibonacci number using iterative doubling.
+ */
+declare function fibonacci(n: number): number;
+export {};

package/dist/types/compute-engine/compilation/python-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { CompileTarget, CompiledOperators, CompiledFunctions, LanguageTarget, CompilationOptions, CompilationResult } from './types';
 /**
  * Python/NumPy language target implementation

package/dist/types/compute-engine/compilation/types.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 /**
  * Source code in the target language
  */
@@ -34,6 +34,9 @@ export interface CompileTarget<Expr = unknown> {
     string: (str: string) => string;
     /** Format numeric literals for the target language */
     number: (n: number) => string;
+    /** Format a complex numeric literal for the target language.
+     *  Only called when the imaginary part is non-zero. */
+    complex?: (re: number, im: number) => string;
     /** Format whitespace for the target language */
     ws: (s?: string) => string;
     /** Code to be inserted at the beginning of the compiled output */
@@ -129,6 +132,15 @@ export interface CompilationOptions<Expr = unknown> {
     imports?: unknown[];
     /** Additional preamble code */
     preamble?: string;
+    /**
+     * When true, complex results (`{ re, im }`) are converted to real numbers:
+     * - If the imaginary part is zero, the real part is returned
+     * - Otherwise, `NaN` is returned
+     *
+     * This avoids object allocations for callers that only need real-valued
+     * results (e.g., plotting).
+     */
+    realOnly?: boolean;
 }
 /**
  * Result of compiling an expression
@@ -151,6 +163,21 @@ export interface CompilationResult {
      * target's `compileShaderFunction()` method directly.
      */
     preamble?: string;
-    /** Executable function (present for JS-executable targets only) */
-    run?: (...args: number[]) => number;
+    /**
+     * Executable function (present for JS-executable targets only).
+     *
+     * For plain expressions, call with a vars object:
+     * ```typescript
+     * result.run({ x: 0.5 })
+     * ```
+     *
+     * For `Function` (lambda) expressions, call with positional arguments:
+     * ```typescript
+     * result.run(0.5)
+     * ```
+     */
+    run?: (...args: unknown[]) => number | {
+        re: number;
+        im: number;
+    };
 }

package/dist/types/compute-engine/compilation/wgsl-target.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { CompiledFunctions } from './types';
 import { GPUShaderTarget } from './gpu-target';
 /**

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 /**
  * The default cost function, used to determine if a new expression is simpler
  * than the old one.

package/dist/types/compute-engine/engine-assumptions.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { MathJsonSymbol } from '../math-json/types';
 export declare function ask(ce: IComputeEngine, pattern: Expression): BoxedSubstitution[];
 export declare function verify(ce: IComputeEngine, query: Expression): boolean | undefined;

package/dist/types/compute-engine/engine-cache.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
     private _entries;
     getOrBuild<T>(cacheName: string, build: () => T, purge?: (t: T) => T | undefined): T;
     invalidate(cacheName: string): void;

package/dist/types/compute-engine/engine-common-symbols.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 export type CommonSymbolTable = {
     [symbol: string]: null | Expression;
 };

package/dist/types/compute-engine/engine-compilation-targets.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { LanguageTarget } from './compilation/types';
 /**
  * Internal registry for compilation targets.

package/dist/types/compute-engine/engine-configuration-lifecycle.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 type ResetHooks = {
     refreshNumericConstants: () => void;
     resetCommonSymbols: () => void;

package/dist/types/compute-engine/engine-declarations.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { MathJsonSymbol } from '../math-json/types';
 import type { ValueDefinition, OperatorDefinition, AssignValue, Expression, BoxedDefinition, SymbolDefinition, IComputeEngine, Scope } from './global-types';

package/dist/types/compute-engine/engine-expression-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import { Decimal } from 'decimal.js';
 import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
 import { NumericValue } from './numeric-value/types';

package/dist/types/compute-engine/engine-extension-contracts.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { LanguageTarget, CompilationOptions } from './compilation/types';
 export declare function assertCompilationTargetName(name: unknown): string;
 export declare function assertLibraryName(name: unknown): string;

package/dist/types/compute-engine/engine-latex-dictionary-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { LatexDictionaryEntry } from './latex-syntax/types';
 type DefaultDictionaryProvider = () => Readonly<LatexDictionaryEntry[]>;
 export declare class EngineLatexDictionaryState {

package/dist/types/compute-engine/engine-library-bootstrap.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { LatexDictionaryEntry, LibraryCategory } from './latex-syntax/types';
 export declare function resolveBootstrapLibraries(libraries?: readonly (string | LibraryDefinition)[]): LibraryDefinition[];
 export declare function loadLibraryDefinitions(engine: ComputeEngine, libraries: readonly LibraryDefinition[]): void;

package/dist/types/compute-engine/engine-numeric-configuration.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { AngularUnit } from './types-definitions';
 export declare class EngineNumericConfiguration {
     private _bignum;

package/dist/types/compute-engine/engine-parse-entrypoint.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
 import type { FormOption } from './types-serialization';
 export type ParseEntrypointOptions = Partial<ParseLatexOptions> & {

package/dist/types/compute-engine/engine-runtime-state.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
     private _timeLimit;
     private _iterationLimit;
     private _recursionLimit;

package/dist/types/compute-engine/engine-scope.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { IComputeEngine, Scope, EvalContext } from './global-types';
 export declare function pushScope(ce: IComputeEngine, scope?: Scope, name?: string): void;
 export declare function popScope(ce: IComputeEngine): void;

package/dist/types/compute-engine/engine-sequences.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 export declare function declareSequence(ce: IComputeEngine, name: string, def: SequenceDefinition): IComputeEngine;
 export declare function getSequenceStatus(ce: IComputeEngine, name: string): SequenceStatus;
 export declare function getSequence(ce: IComputeEngine, name: string): SequenceInfo | undefined;

package/dist/types/compute-engine/engine-simplification-rules.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 /**
  * Internal holder for simplification rules and their cache-staleness marker.
  *

package/dist/types/compute-engine/engine-startup-coordinator.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
 export type CommonNumberBindings = {
     Zero: Expression;

package/dist/types/compute-engine/engine-type-resolver.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 type ResolverScope = {
     parent: ResolverScope | null;
     types?: Record<string, TypeReference>;

package/dist/types/compute-engine/engine-validation-entrypoints.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import { BoxedType } from '../common/type/boxed-type';
 import type { Expression, Metadata, ExpressionInput } from './global-types';
 type ValidationHost = {

package/dist/types/compute-engine/free-functions.d.ts

@@ -1,4 +1,5 @@
-/* 0.50.2 */
+/* 0.51.1 */
+import type { Type, TypeString } from '../common/type/types';
 import type { LatexString } from './latex-syntax/types';
 import { compile as compileExpr } from './compilation/compile-expression';
 /** @internal Called by index.ts to register the ComputeEngine class,
@@ -6,15 +7,20 @@ import { compile as compileExpr } from './compilation/compile-expression';
 export declare function _setComputeEngineClass(cls: new () => IComputeEngine): void;
 export declare function getDefaultEngine(): IComputeEngine;
 export declare function parse(latex: LatexString): Expression;
-export declare function simplify(latex: LatexString | Expression): Expression;
-export declare function evaluate(latex: LatexString | Expression): Expression;
-export declare function N(latex: LatexString | Expression): Expression;
+export declare function box(expr: ExpressionInput): Expression;
+export declare function simplify(expr: LatexString | ExpressionInput): Expression;
+export declare function evaluate(expr: LatexString | ExpressionInput): Expression;
+export declare function N(expr: LatexString | ExpressionInput): Expression;
+export declare function declare(id: string, def: Type | TypeString | Partial<SymbolDefinition>): void;
+export declare function declare(symbols: {
+    [id: string]: Type | TypeString | Partial<SymbolDefinition>;
+}): void;
 export declare function assign(id: string, value: AssignValue): void;
 export declare function assign(ids: {
     [id: string]: AssignValue;
 }): void;
-export declare function expand(latex: LatexString | Expression): Expression | null;
-export declare function solve(latex: LatexString | Expression, vars?: string | Iterable<string> | Expression | Iterable<Expression>): null | ReadonlyArray<Expression> | Record<string, Expression> | Array<Record<string, Expression>>;
-export declare function expandAll(latex: LatexString | Expression): Expression | null;
-export declare function factor(latex: LatexString | Expression): Expression;
-export declare function compile(latex: LatexString | Expression, options?: Parameters<typeof compileExpr>[1]): ReturnType<typeof compileExpr>;
+export declare function expand(expr: LatexString | ExpressionInput): Expression | null;
+export declare function solve(expr: LatexString | ExpressionInput, vars?: string | Iterable<string> | Expression | Iterable<Expression>): null | ReadonlyArray<Expression> | Record<string, Expression> | Array<Record<string, Expression>>;
+export declare function expandAll(expr: LatexString | ExpressionInput): Expression | null;
+export declare function factor(expr: LatexString | ExpressionInput): Expression;
+export declare function compile(expr: LatexString | ExpressionInput, options?: Parameters<typeof compileExpr>[1]): ReturnType<typeof compileExpr>;

package/dist/types/compute-engine/function-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS

package/dist/types/compute-engine/global-types.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 export type * from './types-serialization';
 export type { ValueDefinition, SequenceDefinition, SequenceStatus, SequenceInfo, OEISSequenceInfo, OEISOptions, OperatorDefinition, BaseDefinition, SimplifyOptions, SymbolDefinition, SymbolDefinitions, LibraryDefinition, AngularUnit, Sign, BaseCollectionHandlers, IndexedCollectionHandlers, CollectionHandlers, TaggedValueDefinition, TaggedOperatorDefinition, BoxedDefinition, BoxedBaseDefinition, BoxedValueDefinition, OperatorDefinitionFlags, BoxedOperatorDefinition, } from './types-definitions';
 export type * from './types-evaluation';

package/dist/types/compute-engine/index.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
 import { Decimal } from 'decimal.js';
 import { Type, TypeResolver, TypeString } from '../common/type/types';
 import { BoxedType } from '../common/type/boxed-type';
@@ -17,7 +17,7 @@ import { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factor
 import './boxed-expression/serialize';
 import { type ParseEntrypointOptions } from './engine-parse-entrypoint';
 export type * from './global-types';
-export { parse, simplify, evaluate, N, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
+export { parse, box, simplify, evaluate, N, declare, assign, expand, expandAll, factor, solve, compile, getDefaultEngine, } from './free-functions';
 export { validatePattern };
 export { factorPerfectSquare, factorDifferenceOfSquares, factorQuadratic, factorPolynomial, };
 export type { CompileTarget, CompiledOperators, CompiledFunctions, CompilationOptions, CompilationResult, LanguageTarget, TargetSource, CompiledFunction, } from './compilation/types';

package/dist/types/compute-engine/interval/arithmetic.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
  * Basic interval arithmetic operations
  *
  * @module interval/arithmetic

package/dist/types/compute-engine/interval/comparison.d.ts

@@ -1,4 +1,4 @@
-/* 0.50.2 */
+/* 0.51.1 */
  * Comparison and conditional interval operations
  *
  * @module interval/comparison