@cortex-js/compute-engine 0.11.0 → 0.12.1

package/dist/types/compute-engine/library/random-expression.d.ts

@@ -0,0 +1,2 @@
+/* 0.12.1 */
+export declare function randomExpression(level?: number): Expression;

package/dist/types/compute-engine/library/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.11.0 */
-export declare const RELOP_LIBRARY: IDTable;
+/* 0.12.1 */
+export declare const RELOP_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.11.0 */
-export declare const SETS_LIBRARY: IDTable;
+/* 0.12.1 */
+export declare const SETS_LIBRARY: IdTable;

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

@@ -1,2 +1,2 @@
-/* 0.11.0 */
-export declare const TRIGONOMETRY_LIBRARY: IDTable[];
+/* 0.12.1 */
+export declare const TRIGONOMETRY_LIBRARY: IdTable[];

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

@@ -1,3 +1,3 @@
-/* 0.11.0 */
+/* 0.12.1 */
 export declare function isSymbolDefinition(def: BoxedSymbolDefinition | BoxedFunctionDefinition | SymbolDefinition | FunctionDefinition | undefined | null): def is BoxedSymbolDefinition;
 export declare function isFunctionDefinition(def: BoxedSymbolDefinition | BoxedFunctionDefinition | SymbolDefinition | FunctionDefinition | undefined | null): def is BoxedFunctionDefinition;

package/dist/types/compute-engine/numerics/numeric-bigint.d.ts

@@ -0,0 +1,12 @@
+/* 0.12.1 */
+export declare function bigint(a: Decimal | number | bigint | string): bigint;
+export declare function gcd(a: bigint, b: bigint): bigint;
+export declare function lcm(a: bigint, b: bigint): bigint;
+export declare function primeFactors(d: bigint): Map<bigint, number>;
+/** Return `[factor, root]` such that
+ * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
+ *
+ * factorPower(75, 2) -> [5, 3] = 5^2 * 3
+ *
+ */
+export declare function factorPower(n: bigint, exponent: number): [factor: bigint, root: bigint];

package/dist/types/compute-engine/numerics/numeric-bignum.d.ts

@@ -1,15 +1,7 @@
-/* 0.11.0 */
+/* 0.12.1 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;
-export declare function primeFactors(ce: IComputeEngine, n: Decimal): Map<Decimal, number>;
-/** Return `[factor, root]` such that
- * pow(n, 1/exponent) = factor * pow(root, 1/exponent)
- *
- * factorPower(75, 2) -> [5, 3] = 5^2 * 3
- *
- */
-export declare function factorPower(ce: IComputeEngine, n: Decimal, exponent: number): [factor: Decimal, root: Decimal];
 export declare function factorial(ce: IComputeEngine, n: Decimal): Decimal;
 export declare function lngamma(ce: IComputeEngine, z: Decimal): Decimal;
 export declare function gamma(ce: IComputeEngine, z: Decimal): Decimal;

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.11.0 */
+/* 0.12.1 */
 export declare function gamma(c: Complex): Complex;
 export declare function lngamma(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 import Decimal from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;

package/dist/types/compute-engine/numerics/primes.d.ts

@@ -1,2 +1,2 @@
-/* 0.11.0 */
+/* 0.12.1 */
 export declare function isPrime(n: number): boolean | undefined;

package/dist/types/compute-engine/numerics/rationals.d.ts

@@ -1,22 +1,20 @@
-/* 0.11.0 */
-import Decimal from 'decimal.js';
+/* 0.12.1 */
 export declare function isRational(x: any | null): x is Rational;
 export declare function isMachineRational(x: any | null): x is [number, number];
-export declare function isBigRational(x: any | null): x is [Decimal, Decimal];
+export declare function isBigRational(x: any | null): x is [bigint, bigint];
 export declare function isRationalZero(x: Rational): boolean;
 export declare function isRationalOne(x: Rational): boolean;
 export declare function isRationalNegativeOne(x: Rational): boolean;
 export declare function machineNumerator(x: Rational): number;
 export declare function machineDenominator(x: Rational): number;
-export declare function isNeg(lhs: Rational): boolean;
-export declare function neg(lhs: [number, number]): [number, number];
-export declare function neg(lhs: [Decimal, Decimal]): [Decimal, Decimal];
-export declare function neg(lhs: Rational): Rational;
-export declare function inverse(lhs: [number, number]): [number, number];
-export declare function inverse(lhs: [Decimal, Decimal]): [Decimal, Decimal];
-export declare function inverse(lhs: Rational): Rational;
+export declare function isNeg(x: Rational): boolean;
+export declare function neg(x: [number, number]): [number, number];
+export declare function neg(x: [bigint, bigint]): [bigint, bigint];
+export declare function neg(x: Rational): Rational;
+export declare function inverse(x: [number, number]): [number, number];
+export declare function inverse(x: [bigint, bigint]): [bigint, bigint];
+export declare function inverse(x: Rational): Rational;
 export declare function asRational(expr: BoxedExpression): Rational | undefined;
-export declare function asMachineRational(r: Rational): [number, number];
 /**
  * Add a literal numeric value to a rational.
  * If the rational is a bignum, this is a hint to do the calculation in bignum
@@ -29,7 +27,7 @@ export declare function add(lhs: Rational, rhs: BoxedExpression | Rational): Rat
 export declare function mul(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
 export declare function pow(r: Rational, exp: number): Rational;
 export declare function reducedRational(r: [number, number]): [number, number];
-export declare function reducedRational(r: [Decimal, Decimal]): [Decimal, Decimal];
+export declare function reducedRational(r: [bigint, bigint]): [bigint, bigint];
 export declare function reducedRational(r: Rational): Rational;
 /** Return a rational approximation of x */
 export declare function rationalize(x: number): [n: number, d: number] | number;

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

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -9,11 +9,10 @@
  */
 import type { Decimal } from 'decimal.js';
 import type { Complex } from 'complex.js';
-import type { SignalMessage, WarningSignal, WarningSignalHandler } from '../common/signals';
 import type { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
 import type { NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
 export * from './latex-syntax/public';
-export type Rational = [number, number] | [Decimal, Decimal];
+export type Rational = [number, number] | [bigint, bigint];
 /**
  * Metadata that can be associated with a `BoxedExpression`
  */
@@ -82,12 +81,10 @@ export type ReplaceOptions = {
  * A substitution can also be considered a more constrained version of a
  * rule whose `lhs` is always a symbol.
  */
-export type Substitution = {
-    [symbol: string]: SemiBoxedExpression;
-};
-export type BoxedSubstitution = {
-    [symbol: string]: BoxedExpression;
+export type Substitution<T = SemiBoxedExpression> = {
+    [symbol: string]: T;
 };
+export type BoxedSubstitution = Substitution<BoxedExpression>;
 /** A LaTeX string starts and end with `$`, for example
  * `"$\frac{\pi}{2}$"`.
  */
@@ -352,7 +349,12 @@ export interface BoxedExpression {
      * **Note** applicable to canonical and non-canonical expressions.
      *
      */
-    readonly symbols: BoxedExpression[];
+    readonly symbols: string[];
+    /**
+     * All the free variables in the expression, recursively,
+     * that is all the symbols with no value
+     */
+    readonly freeVars: string[];
     /** All the `["Error"]` subexpressions
      *
      * **Note** applicable to canonical and non-canonical expressions.
@@ -1022,7 +1024,7 @@ export interface ExpressionMapInterface<U> {
  * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
  *
  */
-export type IDTable = {
+export type IdTable = {
     [id: string]: SymbolDefinition | FunctionDefinition;
 };
 /**
@@ -1050,33 +1052,30 @@ export type RuntimeIdentifierTable = Map<string, BoxedSymbolDefinition | BoxedFu
  *
  */
 export type Scope = {
-    /** This handler is invoked when exiting this scope if there are any
-     * warnings pending. */
-    warn?: WarningSignalHandler;
     /** Signal `timeout` when the execution time for this scope is exceeded.
      * Time in seconds, default 2s.
      *
      * @experimental
      */
-    timeLimit?: number;
+    timeLimit: number;
     /** Signal `out-of-memory` when the memory usage for this scope is exceeded.
      * Memory in Megabytes, default: 1Mb.
      *
      * @experimental
      */
-    memoryLimit?: number;
+    memoryLimit: number;
     /** Signal `recursion-depth-exceeded` when the recursion depth for this
      * scope is exceeded.
      *
      * @experimental
      */
-    recursionLimit?: number;
+    recursionLimit: number;
     /** Signal `iteration-limit-exceeded` when the iteration limit for this
      * scope is exceeded. Default: no limits.
      *
      * @experimental
      */
-    iterationLimit?: number;
+    iterationLimit: number;
 };
 export type RuntimeScope = Scope & {
     parentScope?: RuntimeScope;
@@ -1090,8 +1089,6 @@ export type RuntimeScope = Scope & {
     };
     /** Free memory should not go below this level for execution to proceed */
     lowWaterMark?: number;
-    /** Set when one or more warnings have been signaled in this scope */
-    warnings?: WarningSignal[];
 };
 export type BaseDefinition = {
     /** A short (about 1 line) description. May contain Markdown. */
@@ -1468,10 +1465,10 @@ export type SymbolAttributes = {
   
   | Operation | `"never"` | `"simplify"` | `"evaluate"` | `"N"` |
   | :--- | :----- |
-  | `canonical()`|  {% icon "circle-check" "green-700" %} | | | |
-  | `simplify()` |   {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %} | | |
-  | `evaluate()` |   {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %} | |
-  | `"N()"` |  {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %}  |  {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %}  |
+  | `canonical()`|  (X) | | | |
+  | `simplify()` |   (X) | (X) | | |
+  | `evaluate()` |   (X) | (X) | (X) | |
+  | `"N()"` |  (X) | (X)  |  (X) | (X)  |
   
   </div>
   
@@ -1569,7 +1566,7 @@ export interface IComputeEngine {
     chop(n: Complex): Complex | 0;
     chop(n: number | Decimal | Complex): number | Decimal | Complex;
     /** @internal */
-    bignum: (a: Decimal.Value) => Decimal;
+    bignum: (a: Decimal.Value | bigint) => Decimal;
     /** @internal */
     complex: (a: number | Complex, b?: number) => Complex;
     set precision(p: number | 'machine');
@@ -1604,8 +1601,9 @@ export interface IComputeEngine {
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
         canonical?: boolean;
     }): BoxedExpression;
+    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
     /** Return a boxed number */
-    number(value: number | string | MathJsonNumber | Decimal | Complex | [num: number, denom: number] | [num: Decimal, denom: Decimal], options?: {
+    number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     }): BoxedExpression;
@@ -1667,23 +1665,23 @@ export interface IComputeEngine {
      *
      * The result is canonical.
      */
-    power(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
+    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
     sqrt(base: BoxedExpression, metadata?: Metadata): any;
     /** Shortcut for `this.fn("Divide", [1, expr])`
      *
      * The result is canonical.
      */
-    inverse(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    inv(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Negate", [expr])`
      *
      * The result is canonical.
      */
-    negate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Divide", [num, denom])`
      *
      * The result is canonical.
      */
-    divide(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
     /** Shortcut for `this.fn("Pair"...)`
      *
      * The result is canonical.
@@ -1730,16 +1728,12 @@ export interface IComputeEngine {
     /** {@inheritDoc  JsonSerializationOptions} */
     get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
     set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
-    pushScope(symbolTable?: Readonly<IDTable> | Readonly<IDTable>[], scope?: Partial<Scope>): void;
+    pushScope(identifiers?: Readonly<IdTable> | Readonly<IdTable>[], scope?: Partial<Scope>): void;
     popScope(): void;
     /** Assign a value to an identifier in the current scope. Use `null` to reset the identifier to no value */
-    set(identifiers: {
-        [identifier: string]: SemiBoxedExpression | null;
-    }): void;
-    /** Declare identifiers (specify their domain without necessarily assigning them a value in the current scope*/
-    let(identifiers: {
-        [identifier: string]: SymbolDefinition | FunctionDefinition;
-    }): void;
+    set(identifiers: Substitution<SemiBoxedExpression | null | undefined>): void;
+    /** Declare identifiers (specify their domain without necessarily assigning them a value in the current scope) */
+    let(identifiers: IdTable): void;
     /**
      * Add an assumption.
      *
@@ -1762,16 +1756,6 @@ export interface IComputeEngine {
     forget(symbol?: string | string[]): void;
     get assumptions(): ExpressionMapInterface<boolean>;
     ask(pattern: LatexString | SemiBoxedExpression): BoxedSubstitution[];
-    /**
-     * When `condition` is false, signal.
-     *
-     * - `condition` - If `true`, do nothing. If `false`, signal.
-     *
-     * @experimental
-     */
-    assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): any;
-    signal(expr: BoxedExpression, msg: string, code?: SignalMessage): void;
-    signal(sig: WarningSignal): void;
     /** @internal */
     shouldContinueExecution(): boolean;
     /** @internal */

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

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 /**
  * Go through all the rules in the rule set, and for all the rules that match
  * return the rhs of the rule applied to `expr`.

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

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

package/dist/types/compute-engine/symbolic/expand.d.ts

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 /**
  * Return the expansion of ['Multiply', lhs, rhs]
  * - lhs = 'a + b', rhs = '2'

package/dist/types/compute-engine/symbolic/flatten.d.ts

@@ -1,8 +1,9 @@
-/* 0.11.0 */
+/* 0.12.1 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.
  */
 export declare function flatten(expr: BoxedExpression, head: string): BoxedExpression;
-export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[] | null;
+export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[];
 export declare function flattenSequence(xs: BoxedExpression[]): BoxedExpression[];
+export declare function canonical(xs: BoxedExpression[]): BoxedExpression[];

package/dist/types/compute-engine/symbolic/negate.d.ts

@@ -1,12 +1,10 @@
-/* 0.11.0 */
+/* 0.12.1 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
- * addition or another `Negate`.
+ * addition or multiplication or another `Negate`.
  *
- * This is appropriate to call during a `canonical` chain.
- *
- * For more thorough distribution (including multiplication), see `distributeNegate`,
- * applicable  during a `simplify` or `evaluate` chain.
+ * It is important to do all these to handle cases like
+ * `-3x` -> ["Negate, ["Multiply", 3, "x"]] -> ["Multiply, -3, x]
  */
 export declare function canonicalNegate(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
 export declare function processNegate(_ce: IComputeEngine, x: BoxedExpression, _mode?: 'simplify' | 'evaluate' | 'N'): BoxedExpression;

package/dist/types/compute-engine/symbolic/polynomials.d.ts

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

package/dist/types/compute-engine/symbolic/product.d.ts

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 /**
  * Group terms in a product by common term.
  *

package/dist/types/compute-engine/symbolic/sum.d.ts

@@ -1,14 +1,15 @@
-/* 0.11.0 */
+/* 0.12.1 */
 export declare class Sum {
     private engine;
+    private _isCanonical;
     private _rational;
     private _imaginary;
     private _number;
     private _bignum;
     private _posInfinityCount;
     private _negInfinityCount;
+    private _naNCount;
     private _terms;
-    private _isCanonical;
     constructor(ce: IComputeEngine, xs?: BoxedExpression[], options?: {
         canonical?: boolean;
     });

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

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
 import Decimal from 'decimal.js';
 import { BoxedExpression, Rational } from '../public';
 /**

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

@@ -1,4 +1,3 @@
-/* 0.11.0 */
+/* 0.12.1 */
+export declare const version = "0.12.1";
 export { ComputeEngine } from './compute-engine/compute-engine';
-export declare const version = "0.11.0";
-export { getVars } from './compute-engine/boxed-expression/utils';

package/dist/types/math-json/math-json-format.d.ts

@@ -1,4 +1,4 @@
-/* 0.11.0 */
+/* 0.12.1 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;

package/dist/types/math-json/utils.d.ts

@@ -1,4 +1,5 @@
-/* 0.11.0 */
+/* 0.12.1 */
+export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumber;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;
 export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
 export declare function isStringObject(expr: Expression | null): expr is MathJsonString;

package/dist/types/math-json.d.ts

@@ -1,4 +1,3 @@
-/* 0.11.0 */
+/* 0.12.1 */
 export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
-export type { LatexToken, ParseHandler, SerializeHandler, LatexDictionaryEntry, LatexDictionary, ParseLatexOptions, SerializeLatexOptions, NumberFormattingOptions, } from './compute-engine/latex-syntax/public';
-export declare const version = "0.11.0";
+export declare const version = "0.12.1";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.11.0",
+  "version": "0.12.1",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",