@cortex-js/compute-engine 0.35.6 → 0.50.0

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

@@ -0,0 +1,44 @@
+/* 0.50.0 */
+import { Decimal } from 'decimal.js';
+import type { MathJsonNumberObject, MathJsonSymbol } from '../math-json/types';
+import { NumericValue } from './numeric-value/types';
+import type { Rational } from './numerics/types';
+import type { BoxedDefinition, Expression, CanonicalOptions, Metadata, ValueDefinition, IComputeEngine as ComputeEngine } from './global-types';
+export type CommonNumberTable = {
+    [num: number]: null | Expression;
+};
+type SymbolHost = ComputeEngine & {
+    strict: boolean;
+    Nothing: Expression;
+    lookupDefinition(id: MathJsonSymbol): undefined | BoxedDefinition;
+    _declareSymbolValue(name: MathJsonSymbol, def: Partial<ValueDefinition>): BoxedDefinition;
+    error(message: string | string[], where?: string): Expression;
+};
+type NumberHost = ComputeEngine & {
+    Zero: Expression;
+    One: Expression;
+    NegativeOne: Expression;
+    Two: Expression;
+    NaN: Expression;
+    PositiveInfinity: Expression;
+    NegativeInfinity: Expression;
+    _fn(name: MathJsonSymbol, ops: ReadonlyArray<Expression>, options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    }): Expression;
+    number(value: number | bigint | string | NumericValue | MathJsonNumberObject | Decimal | Complex | Rational, options?: {
+        metadata: Metadata;
+        canonical: CanonicalOptions;
+    }): Expression;
+};
+export declare function createSymbolExpression(engine: SymbolHost, commonSymbols: {
+    [symbol: string]: null | Expression;
+}, symbolName: string, options?: {
+    canonical?: CanonicalOptions;
+    metadata?: Metadata;
+}): Expression;
+export declare function createNumberExpression(engine: NumberHost, commonNumbers: CommonNumberTable, value: number | bigint | string | NumericValue | MathJsonNumberObject | Decimal | Complex | Rational, options?: {
+    metadata: Metadata;
+    canonical: CanonicalOptions;
+}): Expression;
+export {};

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

@@ -0,0 +1,9 @@
+/* 0.50.0 */
+import type { LanguageTarget, CompilationOptions } from './compilation/types';
+export declare function assertCompilationTargetName(name: unknown): string;
+export declare function assertLibraryName(name: unknown): string;
+export declare function assertCompilationTargetContract(target: unknown): asserts target is LanguageTarget<Expression>;
+export declare function assertLibraryDefinitionContract(library: unknown): asserts library is LibraryDefinition;
+export declare function assertCompilationOptionsContract(options: unknown): asserts options is CompilationOptions<Expression> & {
+    fallback?: boolean;
+};

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

@@ -0,0 +1,13 @@
+/* 0.50.0 */
+import type { LatexDictionaryEntry } from './latex-syntax/types';
+type DefaultDictionaryProvider = () => Readonly<LatexDictionaryEntry[]>;
+export declare class EngineLatexDictionaryState {
+    private readonly _defaultProvider;
+    private _input;
+    private _indexed;
+    constructor(_defaultProvider: DefaultDictionaryProvider);
+    get dictionary(): Readonly<LatexDictionaryEntry[]>;
+    set dictionary(dictionary: Readonly<LatexDictionaryEntry[]>);
+    get indexedDictionary(): IndexedLatexDictionary;
+}
+export {};

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

@@ -0,0 +1,6 @@
+/* 0.50.0 */
+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;
+export declare function collectLibraryLatexEntries(libraries: readonly LibraryDefinition[]): LatexDictionaryEntry[];
+export declare function getLatexDictionaryForDomain(domain?: LibraryCategory | 'all'): readonly Readonly<LatexDictionaryEntry>[];

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

@@ -0,0 +1,34 @@
+/* 0.50.0 */
+import type { AngularUnit } from './types-definitions';
+export declare class EngineNumericConfiguration {
+    private _bignum;
+    private _precision;
+    private _angularUnit;
+    private _tolerance;
+    private _bignumTolerance;
+    private _negBignumTolerance;
+    private _constants;
+    constructor(options?: {
+        precision?: number | 'machine';
+        tolerance?: number | 'auto';
+        angularUnit?: AngularUnit;
+    });
+    get precision(): number;
+    setPrecision(value: number | 'machine' | 'auto'): boolean;
+    get angularUnit(): AngularUnit;
+    setAngularUnit(value: AngularUnit): boolean;
+    get tolerance(): number;
+    setTolerance(value: number | 'auto'): void;
+    get bignumTolerance(): Decimal;
+    get negBignumTolerance(): Decimal;
+    get bignumNaN(): Decimal;
+    get bignumZero(): Decimal;
+    get bignumOne(): Decimal;
+    get bignumTwo(): Decimal;
+    get bignumHalf(): Decimal;
+    get bignumPi(): Decimal;
+    get bignumNegativeOne(): Decimal;
+    refreshConstants(): void;
+    bignum(value: Decimal.Value | bigint): Decimal;
+    private computeConstants;
+}

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

@@ -0,0 +1,7 @@
+/* 0.50.0 */
+import type { LatexString, ParseLatexOptions } from './latex-syntax/types';
+import type { FormOption } from './types-serialization';
+export type ParseEntrypointOptions = Partial<ParseLatexOptions> & {
+    form?: FormOption;
+};
+export declare function parseLatexEntrypoint(engine: ComputeEngine, latex: LatexString | null, options?: ParseEntrypointOptions): Expression | null;

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

@@ -0,0 +1,19 @@
+/* 0.50.0 */
+    private _timeLimit;
+    private _iterationLimit;
+    private _recursionLimit;
+    private _deadline;
+    private _isVerifying;
+    get timeLimit(): number;
+    set timeLimit(value: number);
+    get iterationLimit(): number;
+    set iterationLimit(value: number);
+    get recursionLimit(): number;
+    set recursionLimit(value: number);
+    get deadline(): number | undefined;
+    set deadline(value: number | undefined);
+    get timeRemaining(): number;
+    get isVerifying(): boolean;
+    set isVerifying(value: boolean);
+    shouldContinueExecution(): boolean;
+}

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

@@ -0,0 +1,13 @@
+/* 0.50.0 */
+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;
+export declare function pushEvalContext(ce: IComputeEngine, scope: Scope, name?: string): void;
+export declare function popEvalContext(ce: IComputeEngine): void;
+export declare function inScope<T>(ce: IComputeEngine, scope: Scope | undefined, f: () => T): T;
+export declare function printStack(ce: IComputeEngine, options?: {
+    details?: boolean;
+    maxDepth?: number;
+}): void;
+export declare function lookupContext(ce: IComputeEngine, id: MathJsonSymbol): EvalContext | undefined;
+export declare function swapContext(ce: IComputeEngine, context: EvalContext): void;

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

@@ -0,0 +1,14 @@
+/* 0.50.0 */
+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;
+export declare function listSequences(ce: IComputeEngine): string[];
+export declare function isSequence(ce: IComputeEngine, name: string): boolean;
+export declare function clearSequenceCache(ce: IComputeEngine, name?: string): void;
+export declare function getSequenceCache(ce: IComputeEngine, name: string): Map<number | string, Expression> | undefined;
+export declare function getSequenceTerms(ce: IComputeEngine, name: string, start: number, end: number, step?: number): Expression[] | undefined;
+export declare function lookupOEIS(ce: IComputeEngine, terms: (number | Expression)[], options?: OEISOptions): Promise<OEISSequenceInfo[]>;
+export declare function checkSequenceOEIS(ce: IComputeEngine, name: string, count?: number, options?: OEISOptions): Promise<{
+    matches: OEISSequenceInfo[];
+    terms: number[];
+}>;

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

@@ -0,0 +1,15 @@
+/* 0.50.0 */
+/**
+ * Internal holder for simplification rules and their cache-staleness marker.
+ *
+ * @internal
+ */
+export declare class SimplificationRuleStore {
+    private _rules;
+    private _cachedLength;
+    constructor(initialRules: Rule[]);
+    get rules(): Rule[];
+    set rules(rules: Rule[]);
+    hasMutatedSinceLastCache(): boolean;
+    markCached(): void;
+}

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

@@ -0,0 +1,28 @@
+/* 0.50.0 */
+import type { Expression, IComputeEngine as ComputeEngine, LibraryDefinition } from './global-types';
+export type CommonNumberBindings = {
+    Zero: Expression;
+    One: Expression;
+    Half: Expression;
+    NegativeOne: Expression;
+    Two: Expression;
+    I: Expression;
+    NaN: Expression;
+    PositiveInfinity: Expression;
+    NegativeInfinity: Expression;
+    ComplexInfinity: Expression;
+};
+export type CommonSymbolBindings = {
+    True: Expression;
+    False: Expression;
+    Pi: Expression;
+    E: Expression;
+    Nothing: Expression;
+};
+export declare class EngineStartupCoordinator {
+    private readonly engine;
+    constructor(engine: ComputeEngine);
+    initializeCommonNumbers(): CommonNumberBindings;
+    bootstrapLibraries(libraries?: readonly (string | LibraryDefinition)[]): void;
+    initializeCommonSymbolBindings(commonSymbols: CommonSymbolTable): CommonSymbolBindings;
+}

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

@@ -0,0 +1,12 @@
+/* 0.50.0 */
+type ResolverScope = {
+    parent: ResolverScope | null;
+    types?: Record<string, TypeReference>;
+};
+export type TypeResolverHost = {
+    context: {
+        lexicalScope: ResolverScope;
+    };
+};
+export declare function createTypeResolver(host: TypeResolverHost): TypeResolver;
+export {};

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

@@ -0,0 +1,13 @@
+/* 0.50.0 */
+import { BoxedType } from '../common/type/boxed-type';
+import type { Expression, Metadata, ExpressionInput } from './global-types';
+type ValidationHost = {
+    string(s: string, metadata?: Metadata): Expression;
+    function(name: string, ops: ReadonlyArray<ExpressionInput>, options?: {
+        metadata?: Metadata;
+    }): Expression;
+    box(expr: ExpressionInput): Expression;
+};
+export declare function createErrorExpression(engine: ValidationHost, message: string | string[], where?: string): Expression;
+export declare function createTypeErrorExpression(engine: ValidationHost, expected: Type, actual: undefined | Type | BoxedType, where?: string): Expression;
+export {};

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

@@ -0,0 +1,20 @@
+/* 0.50.0 */
+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,
+ *  avoiding a circular dependency (index.ts re-exports this file). */
+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 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>;

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
-import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './global-types';
+/* 0.50.0 */
+import type { BoxedDefinition, Expression, IComputeEngine as ComputeEngine, Scope } from './global-types';
 /***
  * ### THEORY OF OPERATIONS
  *
@@ -37,11 +37,11 @@ import type { BoxedDefinition, BoxedExpression, ComputeEngine, Scope } from './g
 /**
  * From an expression, return a predicate function, which can be used to filter.
  */
-export declare function predicate(_expr: BoxedExpression): (...args: BoxedExpression[]) => boolean;
+export declare function predicate(_expr: Expression): (...args: Expression[]) => boolean;
 /**
  * From an expression, create an ordering function, which can be used to sort.
  */
-export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: BoxedExpression) => -1 | 0 | 1;
+export declare function order(_expr: Expression): (a: Expression, b: Expression) => -1 | 0 | 1;
 /**
  * Given an expression, rewrite it to a symbol or canonical Function form.
  *
@@ -72,7 +72,7 @@ export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: B
  *
  *
  */
-export declare function canonicalFunctionLiteral(expr: BoxedExpression | undefined): BoxedExpression | undefined;
+export declare function canonicalFunctionLiteral(expr: Expression | undefined): Expression | undefined;
 /** Assuming that ops has the following form:
  * - body
  * - ...params
@@ -80,18 +80,18 @@ export declare function canonicalFunctionLiteral(expr: BoxedExpression | undefin
  * body is potentially wrapped in a Block expression and the arguments are
  * declared in the scope of the body.
  */
-export declare function canonicalFunctionLiteralArguments(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | undefined;
+export declare function canonicalFunctionLiteralArguments(ce: ComputeEngine, ops: ReadonlyArray<Expression>): Expression | undefined;
 /**
  * Apply arguments to an expression which is either:
  * - a `["Function"]` expression
  * - the symbol for a function, e.g. `Sin`.
  */
-export declare function apply(fn: BoxedExpression, args: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function apply(fn: Expression, args: ReadonlyArray<Expression>): Expression;
 /**
  * Return a lambda function, assuming a scoped environment has been
  * created and there is a single numeric argument
  */
-export declare function makeLambdaN1(expr: BoxedExpression): ((arg: number) => number) | undefined;
+export declare function makeLambdaN1(expr: Expression): ((arg: number) => number) | undefined;
 /**
  * Given an expression such as:
  * - ["Function", ["Add", 1, "x"], "x"]
@@ -102,7 +102,7 @@ export declare function makeLambdaN1(expr: BoxedExpression): ((arg: number) => n
  *
  * return a JS function that can be called with arguments.
  */
-export declare function applicable(fn: BoxedExpression): (xs: ReadonlyArray<BoxedExpression>) => BoxedExpression | undefined;
+export declare function applicable(fn: Expression): (xs: ReadonlyArray<Expression>) => Expression | undefined;
 /**
  * Use `applicableN1()` when the function is known to be a function with a
  * single real argument that returns a real value.
@@ -111,7 +111,7 @@ export declare function applicable(fn: BoxedExpression): (xs: ReadonlyArray<Boxe
  * with an argument.
  *
  */
-export declare function applicableN1(fn: BoxedExpression): (x: number) => number;
+export declare function applicableN1(fn: Expression): (x: number) => number;
 /**
  * Given a string like "f(x,y)" return, ["f", ["x", "y"]]
  */