@cortex-js/compute-engine 0.6.0 → 0.8.0

package/dist/types/compute-engine/boxed-expression/boxed-function.d.ts

@@ -1,44 +1,63 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption, Domain } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOption, BoxedDomain, BoxedLambdaExpression, RuntimeScope } from '../public';
 /**
  * BoxedFunction
  */
 export declare class BoxedFunction extends AbstractBoxedExpression {
-    private _head;
-    private _ops;
+    private _scope;
+    private readonly _head;
+    private readonly _ops;
+    private _canonical;
     private _def;
-    private _isCanonical;
     private _isPure;
+    /** The domain of the value of the function applied to its arguments */
+    private _codomain;
     /** The cached values of applying the tail to the head.
      * If the function is not pure, it is never cached.
      */
     private _value;
     private _numericValue;
     private _hash;
-    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata);
+    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+        def?: BoxedFunctionDefinition;
+    });
     get hash(): number;
-    _purge(): undefined;
-    get wikidata(): string;
-    get description(): string[];
-    get url(): string;
-    get complexity(): number;
-    get head(): string | BoxedExpression;
-    get value(): BoxedExpression | undefined;
-    get numericValue(): BoxedExpression | undefined;
-    get isPure(): boolean;
+    get isCanonical(): boolean;
+    set isCanonical(val: boolean);
     get isLiteral(): boolean;
+    get isPure(): boolean;
+    get json(): Expression;
+    get head(): string | BoxedExpression;
     get ops(): BoxedExpression[];
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
+    get isValid(): boolean;
+    get canonical(): BoxedExpression;
+    map<T = BoxedExpression>(fn: (x: BoxedExpression) => T): IterableIterator<T>;
+    apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
+    subs(sub: Substitution): BoxedExpression;
+    replace(rules: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
+    has(x: string | string[]): boolean;
+    /** `isSame` is structural/symbolic equality */
+    isSame(rhs: BoxedExpression): boolean;
+    match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    unbind(): void;
+    get wikidata(): string | undefined;
+    get description(): string[] | undefined;
+    get url(): string | undefined;
+    get complexity(): number | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    _repairDefinition(): void;
-    /** Signature of the function */
-    get domain(): Domain;
-    /** Domain of the value of the function */
-    get valueDomain(): Domain;
+    bind(_scope: RuntimeScope | null): void;
+    get value(): BoxedExpression | undefined;
+    get numericValue(): BoxedExpression | undefined;
+    get domain(): BoxedDomain;
+    /** `isEqual` is mathematical equality */
+    isEqual(rhs: BoxedExpression): boolean;
     isLess(rhs: BoxedExpression): boolean | undefined;
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
     isGreater(rhs: BoxedExpression): boolean | undefined;
@@ -59,28 +78,17 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     get isExtendedReal(): boolean | undefined;
     get isComplex(): boolean | undefined;
     get isImaginary(): boolean | undefined;
-    get json(): Expression;
-    has(x: string | string[]): boolean;
-    /** `isSame` is structural/symbolic equality */
-    isSame(rhs: BoxedExpression): boolean;
-    match(rhs: BoxedExpression, options?: PatternMatchOption): Substitution | null;
-    /** `isEqual` is mathematical equality */
-    isEqual(rhs: BoxedExpression): boolean;
     get sgn(): -1 | 0 | 1 | undefined | null;
-    map<T = BoxedExpression>(fn: (x: BoxedExpression) => T): IterableIterator<T>;
-    get isCanonical(): boolean;
-    set isCanonical(val: boolean);
-    get canonical(): BoxedExpression;
-    apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
     simplify(options?: SimplifyOptions): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;
     solve(_vars: Iterable<string>): null | BoxedExpression[];
-    replace(rules: BoxedRuleSet, options?: ReplaceOptions): BoxedExpression | null;
-    subs(sub: Substitution): BoxedExpression;
 }
-export declare function lambda(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;
-export declare function ungroup(expr: BoxedExpression): BoxedExpression;
+export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], options?: {
+    [x: string]: any;
+    metadata?: Metadata;
+}): BoxedExpression;
+export declare function lambda(ce: IComputeEngine, fn: BoxedLambdaExpression, args: BoxedExpression[]): BoxedExpression;
 /** Apply the function `f` to elements of `xs`, except to the elements
  * described by `skip`:
  * - `all`: don't apply f to any elements
@@ -90,8 +98,8 @@ export declare function ungroup(expr: BoxedExpression): BoxedExpression;
  * - 'last': apply `f` to all elements except the last
  * - 'most': apply `f` to the last elements, skip the others
  *
- * Account for `Hold`, `ReleaseHold` and  `Nothing`.
+ * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
  *
  * If `f` returns `null`, the element is not added to the result
  */
-export declare function holdMap(xs: BoxedExpression[], skip: 'all' | 'none' | 'first' | 'rest' | 'last' | 'most', f: (BoxedExpression: any) => BoxedExpression | null): BoxedExpression[];
+export declare function holdMap(head: string, xs: BoxedExpression[], skip: 'all' | 'none' | 'first' | 'rest' | 'last' | 'most', associative: boolean, f: (x: BoxedExpression) => BoxedExpression | null): BoxedExpression[];

package/dist/types/compute-engine/boxed-expression/boxed-number.d.ts

@@ -1,7 +1,7 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, Domain, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOption, SimplifyOptions, Substitution } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedNumber
@@ -26,7 +26,9 @@ export declare class BoxedNumber extends AbstractBoxedExpression {
     get isLiteral(): boolean;
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
-    get numericValue(): BoxedExpression | undefined;
+    get complexity(): number;
+    get value(): BoxedExpression;
+    get numericValue(): BoxedExpression;
     get machineValue(): number | null;
     get decimalValue(): Decimal | null;
     get complexValue(): Complex | null;
@@ -34,7 +36,7 @@ export declare class BoxedNumber extends AbstractBoxedExpression {
     get asFloat(): number | null;
     get asSmallInteger(): number | null;
     get asRational(): [number, number] | [null, null];
-    get domain(): Domain;
+    get domain(): BoxedDomain;
     get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;
     isSame(rhs: BoxedExpression): boolean;

package/dist/types/compute-engine/boxed-expression/boxed-patterns.d.ts

@@ -1,20 +1,20 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, Domain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOption, SemiBoxedExpression, Substitution } from '../public';
+import { BoxedExpression, BoxedSubstitution, BoxedDomain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOption, SemiBoxedExpression, Substitution } from '../public';
 export declare class BoxedPattern extends AbstractBoxedExpression implements Pattern {
     _pattern: BoxedExpression;
     _canonicalPattern: BoxedExpression | undefined;
     constructor(ce: IComputeEngine, pattern: LatexString | SemiBoxedExpression, metadata?: Metadata);
     get hash(): number;
-    _purge(): undefined;
+    unbind(): void;
     get json(): Expression;
     get head(): string | BoxedExpression;
-    get valueDomain(): Domain;
+    get domain(): BoxedDomain;
     get isCanonical(): boolean;
     set isCanonical(_val: boolean);
     isSame(rhs: BoxedExpression): boolean;
     isEqual(rhs: BoxedExpression): boolean;
-    match(expr: BoxedExpression, options?: PatternMatchOption): Substitution | null;
+    match(expr: BoxedExpression, options?: PatternMatchOption): BoxedSubstitution | null;
     test(expr: BoxedExpression, options?: PatternMatchOption): boolean;
     count(exprs: Iterable<BoxedExpression>, options?: PatternMatchOption): number;
     subs(sub: Substitution): BoxedPattern;

package/dist/types/compute-engine/boxed-expression/boxed-string.d.ts

@@ -1,6 +1,6 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, Domain, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOption, Substitution } from '../public';
 /**
  * BoxedString
  */
@@ -14,7 +14,7 @@ export declare class BoxedString extends AbstractBoxedExpression {
     get isLiteral(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get domain(): Domain;
+    get domain(): BoxedDomain;
     get complexity(): number;
     get string(): string;
     isEqual(rhs: BoxedExpression): boolean;

package/dist/types/compute-engine/boxed-expression/boxed-symbol-definition.d.ts

@@ -1,13 +1,15 @@
-/* 0.6.0 */
-export declare function domainToFlags(dom: Domain | undefined | null): Partial<SymbolFlags>;
+/* 0.8.0 */
+export declare function domainToFlags(dom: BoxedDomain | undefined | null): Partial<SymbolFlags>;
 export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition {
-    private _engine;
-    private _value;
     readonly name: string;
+    private _def;
+    private _value;
+    private _domain;
+    private _inferedDomain;
+    private _engine;
+    readonly scope: RuntimeScope | undefined;
     wikidata?: string;
     description?: string | string[];
-    readonly scope: RuntimeScope | undefined;
-    private _domain;
     private _number;
     private _integer;
     private _rational;
@@ -36,15 +38,16 @@ export declare class BoxedSymbolDefinitionImpl implements BoxedSymbolDefinition
     at?: (index: string | number) => undefined | BoxedExpression;
     readonly constant: boolean;
     readonly hold: boolean;
-    private _def;
     prototype?: BoxedFunctionDefinition;
     self?: unknown;
     constructor(ce: IComputeEngine, def: SymbolDefinition);
-    _purge(): undefined;
+    reset(): void;
+    unbind(): void;
+    bind(): void;
     get value(): BoxedExpression | undefined;
     set value(val: BoxedExpression | number | undefined);
-    get domain(): Domain | undefined;
-    set domain(domain: Domain | undefined | string);
+    get domain(): BoxedDomain | undefined;
+    set domain(domain: BoxedDomain | DomainExpression | undefined);
     updateFlags(flags: Partial<SymbolFlags>): void;
     setProps(props: Omit<Partial<BoxedSymbolDefinition>, 'domain' | 'value'>): void;
     get number(): boolean | undefined;

package/dist/types/compute-engine/boxed-expression/boxed-symbol.d.ts

@@ -1,38 +1,52 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption, Domain } from '../public';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOption, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition } from '../public';
 /**
  * BoxedSymbol
  *
- * A boxed symbol is a reference to a BoxedSymbolDefinition.
- * The BoxedSymbolDefinition "owns" all the information
+ * A boxed symbol is a reference to a `BoxedSymbolDefinition` or a
+ * `BoxedFunctionDefinition`.
+ *
+ * If a `BoxedSymbolDefinition`, it "owns" all the information
  * about the symbol, its value, domain and various attributes.
+ *
+ * If a `BoxedFunctionDefinition`, it it a reference to a function name,
+ * not a function expression, i.e. `Sin`, not `["Sin", "Pi"]`. This is used
+ * for example in `["InverseFunction", "Sin"]`
  */
 export declare class BoxedSymbol extends AbstractBoxedExpression {
+    private _scope;
     protected _name: string;
     private _hash;
     private _def;
     constructor(ce: IComputeEngine, name: string, metadata?: Metadata);
     get hash(): number;
-    _purge(): undefined;
+    unbind(): undefined;
     get isPure(): boolean;
+    /** A free variable either has no definition, or it has a definition, but no value */
+    get isFree(): boolean;
+    get isConstant(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get wikidata(): string;
-    get description(): string[];
-    get url(): string;
+    get canonical(): BoxedExpression;
+    get wikidata(): string | undefined;
+    get description(): string[] | undefined;
+    get url(): string | undefined;
     get complexity(): number;
     get head(): string;
     get symbol(): string;
-    get isMissing(): boolean;
+    get isNothing(): boolean;
     get isLiteral(): boolean;
+    get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
-    _repairDefinition(): void;
-    get value(): BoxedExpression | undefined;
+    get functionDefinition(): BoxedFunctionDefinition | undefined;
+    bind(scope: RuntimeScope | null): void;
+    get value(): BoxedExpression;
     set value(value: BoxedExpression | number | undefined);
     get numericValue(): BoxedExpression | undefined;
-    get domain(): Domain;
-    set domain(d: Domain);
+    get domain(): BoxedDomain;
+    set domain(d: BoxedDomain);
+    get explicitDomain(): BoxedDomain | undefined;
     get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;
     has(x: string | string[]): boolean;
@@ -43,6 +57,7 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     isLessEqual(rhs: BoxedExpression): boolean | undefined;
     isGreater(rhs: BoxedExpression): boolean | undefined;
     isGreaterEqual(rhs: BoxedExpression): boolean | undefined;
+    get isFunction(): boolean | undefined;
     get isZero(): boolean | undefined;
     get isNotZero(): boolean | undefined;
     get isOne(): boolean | undefined;
@@ -65,7 +80,6 @@ export declare class BoxedSymbol extends AbstractBoxedExpression {
     get isExtendedReal(): boolean | undefined;
     get isComplex(): boolean | undefined;
     get isImaginary(): boolean | undefined;
-    get canonical(): BoxedExpression;
     simplify(options?: SimplifyOptions): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;

package/dist/types/compute-engine/boxed-expression/expression-map.d.ts

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

package/dist/types/compute-engine/boxed-expression/order.d.ts

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

package/dist/types/compute-engine/boxed-expression/serialize.d.ts

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata } from '../public';

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -1,4 +1,6 @@
-/* 0.6.0 */
+/* 0.8.0 */
+import { Expression } from '../../math-json/math-json-format';
+import { BoxedExpression, IComputeEngine } from '../public';
 export declare function isLatexString(s: unknown): s is string;
 export declare function latexString(s: unknown): string | null;
 /**
@@ -9,20 +11,22 @@ export declare function latexString(s: unknown): string | null;
  * - ['Multiply', 5, 'ImaginaryUnit']
  * - ['Multiply', 'ImaginaryUnit', 5]
  */
-export declare function getImaginaryCoef(expr: BoxedExpression): number;
+export declare function getImaginaryCoef(expr: BoxedExpression): number | null;
 /**
  * Return the free symbols in the expression, recursively.
- * A variable, or free symbol,is a symbol that is not bound to a value.
+ * A variable, or free symbol, is a symbol that is not bound to a value.
  */
 export declare function getVars(expr: BoxedExpression): string[];
+export declare function getSymbols(expr: BoxedExpression, set: Set<string>): Set<string>;
+export declare function getSubexpressions(expr: BoxedExpression, head: string): BoxedExpression[];
 /**
  * For any numeric result, or when boxing numbers,
- * if `ce.useDecimal` is true, create them as Decimal number
- * if `ce.useDecimal` is false, create them as machine number
+ * if `preferDecimal` is true, create them as Decimal number
+ * if `preferDecimal` is false, create them as machine number
  */
-export declare function useDecimal(ce: IComputeEngine): boolean;
-/** If result of a numeric evaluation is a complex number,
- * return `NaN` if `ce.useComplex` is false
+export declare function preferDecimal(ce: IComputeEngine): boolean;
+/** When result of a numeric evaluation is a complex number,
+ * return `NaN` if not `complexallowed()`
  */
 export declare function complexAllowed(ce: IComputeEngine): boolean;
 /**
@@ -35,3 +39,16 @@ export declare function complexAllowed(ce: IComputeEngine): boolean;
  */
 export declare function asCanonical(expr: BoxedExpression): BoxedExpression;
 export declare function hashCode(s: string): number;
+export declare function isDictionaryLike(expr: BoxedExpression): boolean;
+export declare function getDictionaryLike(expr: BoxedExpression): {
+    [key: string]: BoxedExpression;
+};
+export declare function isListLike(expr: BoxedExpression): boolean;
+export declare function getListLike(expr: BoxedExpression): BoxedExpression[];
+/**
+ * If `expr` is a number, return it as a Decimal (it might be
+ * in the machine value range or not). Use `isInMachineRange()` to check.
+ *
+ * Use this instead of `machineValue()` when possible, as `machineValue` will truncate decimal numbers to machine numbers
+ */
+export declare function decimalValue(ce: IComputeEngine, expr: Expression | null | undefined): Decimal | null;