@cortex-js/compute-engine 0.22.0 → 0.23.0

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

@@ -1,4 +1,6 @@
-/* 0.22.0 */
+/* 0.23.0 */
+import { Expression } from '../../math-json.js';
+export declare function bigintValue(expr: Expression | null | undefined): bigint | null;
 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;

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;

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

@@ -1,3 +1,3 @@
-/* 0.22.0 */
+/* 0.23.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function gammaln(c: Complex): Complex;

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;
@@ -109,3 +109,10 @@ export declare function monteCarloEstimate(f: (x: number) => number, a: number,
 export declare function limit(f: (x: number) => number, x: number, dir?: number): number;
 export declare function fromRoman(roman: string): [result: number, rest: string];
 export declare function fromDigits(s: string, baseInput?: string | number): [result: number, rest: string];
+/**
+ *
+ * @param lhs
+ * @param rhs
+ * @returns the sign (-1, 0, 1) of the difference between `lhs` and `rhs`
+ */
+export declare function signDiff(lhs: BoxedExpression, rhs: BoxedExpression, tolerance?: number): -1 | 0 | 1 | undefined;

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

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

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

@@ -1,9 +1,10 @@
-/* 0.22.0 */
+/* 0.23.0 */
 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 [bigint, bigint];
 export declare function isRationalZero(x: Rational): boolean;
 export declare function isRationalOne(x: Rational): boolean;
+export declare function isRationalInteger(x: Rational): boolean;
 export declare function isRationalNegativeOne(x: Rational): boolean;
 export declare function machineNumerator(x: Rational): number;
 export declare function machineDenominator(x: Rational): number;
@@ -17,7 +18,7 @@ export declare function inverse(x: Rational): Rational;
 export declare function asRational(expr: BoxedExpression): Rational | undefined;
 /**
  * Add a literal numeric value to a rational.
- * If the rational is a bignum, this is a hint to do the calculation in bignum
+ * If the rational is a bigint, this is a hint to do the calculation in bigint
  * (no need to check `bignumPreferred()`).
  * @param lhs
  * @param rhs
@@ -25,30 +26,15 @@ export declare function asRational(expr: BoxedExpression): Rational | undefined;
  */
 export declare function add(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
 export declare function mul(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
+export declare function div(lhs: Rational, rhs: Rational): Rational;
 export declare function pow(r: Rational, exp: number): Rational;
+export declare function sqrt(r: Rational): Rational | undefined;
 export declare function reducedRational(r: [number, number]): [number, number];
 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;
-/**
- * Attempt to factor a rational coefficient `c` and a `rest` out of a
- * canonical expression `expr` such that `ce.mul(c, rest)` is equal to `expr`.
- *
- * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
- *
- *
- * ['Multiply', 2, 'x', 3, 'a', ['Sqrt', 5]]
- *    -> [[6, 1], ['Multiply', 'x', 'a', ['Sqrt', 5]]]
- *
- * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
- *    -> [[2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
- */
-export declare function asCoefficient(expr: BoxedExpression): [coef: Rational, rest: BoxedExpression];
-/**
- *
- * @param lhs
- * @param rhs
- * @returns the sign (-1, 0, 1) of the difference between `lhs` and `rhs`
+/** Return [factor, root] such that factor * sqrt(root) = n
+ * when factor and root are rationals
  */
-export declare function signDiff(lhs: BoxedExpression, rhs: BoxedExpression, tolerance?: number): -1 | 0 | 1 | undefined;
+export declare function reduceRationalSquareRoot(n: Rational): [factor: Rational, root: Rational];

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 
     Translated from https://github.com/JuliaMath/Richardson.jl/blob/master/src/Richardson.jl
 

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

@@ -0,0 +1,14 @@
+/* 0.23.0 */
+export declare class Terms {
+    private engine;
+    private terms;
+    constructor(ce: IComputeEngine, terms: BoxedExpression[]);
+    sub(term: BoxedExpression): void;
+    add(term2: BoxedExpression, coef2?: Rational): void;
+    find(term: BoxedExpression): number;
+    /** If `exact` is true, keep exact numbers */
+    reduceNumbers({ exact }?: {
+        exact: boolean;
+    }): void;
+    asExpression(): BoxedExpression;
+}

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -434,6 +434,11 @@ export interface BoxedExpression {
      * An exact value is not further transformed when evaluated. To get an
      * approximate evaluation of an exact value, use `.N()`.
      *
+     * Exact numbers are:
+     * - rationals (including integers)
+     * - complex numbers with integer real and imaginary parts (Gaussian integers)
+     * - square root of rationals
+     *
      * Non-exact values includes:
      * - numbers with a fractional part
      * - complex numbers with a real or imaginary fractional part
@@ -1645,21 +1650,29 @@ export interface IComputeEngine {
     chop(n: Complex): Complex | 0;
     chop(n: number | Decimal | Complex): number | Decimal | Complex;
     bignum: (a: Decimal.Value | bigint) => Decimal;
-    complex: (a: number | Complex, b?: number) => Complex;
     isBignum(a: unknown): a is Decimal;
+    complex: (a: number | Complex, b?: number) => Complex;
     isComplex(a: unknown): a is Complex;
     set precision(p: number | 'machine');
     get precision(): number;
     costFunction: (expr: BoxedExpression) => number;
+    /** In strict mode the compute engine performs additional checks,
+     * for example to ensure the correct number and domain of arguments. These
+     * checks may impact performance.
+     */
     strict: boolean;
-    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
-    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
-    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
-    lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
+    /** Return a canonical version of an array of semi-boxed-expressions. */
+    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
+    /** Return as boxed expression from a number, string or semiboxed expression.
+     * Calls `function()`, `number()` or `symbol()` as appropriate.
+     */
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression, options?: {
         canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
-    canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
+    function(head: string | BoxedExpression, ops: SemiBoxedExpression[], options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    }): BoxedExpression;
     number(value: number | bigint | string | MathJsonNumber | Decimal | Complex | Rational, options?: {
         metadata?: Metadata;
         canonical?: boolean;
@@ -1670,45 +1683,35 @@ export interface IComputeEngine {
     }): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
     domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
-    /**
-     * Create a boxed function expression.
-     *
-     * @param head
-     * @param ops
-     * @param options
-     */
-    fn(head: string | SemiBoxedExpression, ops: SemiBoxedExpression[], options?: {
-        canonical: boolean;
-    }): BoxedExpression;
-    /**
-     * This is a primitive to create a boxed function. It doesn't perform
-     * any checks or normalization on its arguments.
-     *
-     * In general, consider using `ce.fn()` or `ce.box()` instead.
-     *
-     * The result is canonical, but the caller has to ensure that all the
-     * conditions are met (i.e. `ops` properly normalized and sorted, all
-     * `ops` canonical, etc..) so that the result is actually canonical.
-     *
-     * @internal
-     */
-    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
     hold(expr: SemiBoxedExpression): BoxedExpression;
-    add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
-    sqrt(base: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    inv(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    neg(expr: BoxedExpression, metadata?: Metadata): BoxedExpression;
-    div(num: BoxedExpression, denom: BoxedExpression, metadata?: Metadata): BoxedExpression;
+    add(...ops: BoxedExpression[]): BoxedExpression;
+    mul(...ops: BoxedExpression[]): BoxedExpression;
+    pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression): BoxedExpression;
+    sqrt(base: BoxedExpression): BoxedExpression;
+    inv(expr: BoxedExpression): BoxedExpression;
+    neg(expr: BoxedExpression): BoxedExpression;
+    div(num: BoxedExpression, denom: BoxedExpression): BoxedExpression;
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
     tuple(elements: number[], metadata?: Metadata): BoxedExpression;
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     array(elements: ArrayValue[] | ArrayValue[][], metadata?: Metadata): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
+    /**
+     * This is a primitive to create a boxed function.
+     *
+     * In general, consider using `ce.box()` or `canonicalXXX()` instead.
+     *
+     * The caller must ensure that the arguments are in canonical form:
+     * - arguments are `canonical()`
+     * - arguments are sorted
+     * - arguments are flattened and desequenced
+     *
+     * @internal
+     */
+    _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     parse(s: LatexString | string, options?: {
         canonical?: boolean | CanonicalForm | CanonicalForm[];
     }): BoxedExpression;
@@ -1729,6 +1732,10 @@ export interface IComputeEngine {
     popScope(): IComputeEngine;
     swapScope(scope: RuntimeScope | null): RuntimeScope | null;
     resetContext(): void;
+    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
+    lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
+    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
+    lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
     assign(ids: {
         [id: string]: AssignValue;
     }): IComputeEngine;
@@ -1754,6 +1761,7 @@ export interface IComputeEngine {
     checkContinueExecution(): void;
     /** @internal */
     cache<T>(name: string, build: () => T, purge?: (T: any) => T | undefined): T;
+    /** @internal */
     readonly stats: ComputeEngineStats;
     /** @internal */
     reset(): void;

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 /**
  * For each rules in the rule set that match, return the `replace` of the rule
  *

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

@@ -1,4 +1,14 @@
-/* 0.22.0 */
+/* 0.23.0 */
+/**
+ * @todo: a set to "tidy" an expression. Different from a canonical form, but
+ * inline with the user's expectations.
+ *
+ * Example:
+ *
+ * - a^n * a^m -> a^(n+m)
+ * - a / √b -> (a * √b) / b
+ *
+ */
 /**
  * A set of simplification rules.
  *

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

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

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 /**
  *
  * @param fn The function to differentiate, a `["Function"]` expression or

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 export declare function distribute(expr: BoxedExpression[]): BoxedExpression;
 /** Use the multinomial theorem (https://en.wikipedia.org/wiki/Multinomial_theorem) to expand the expression.
  * The expression must be a power of a sum of terms.
@@ -9,6 +9,10 @@ export declare function distribute(expr: BoxedExpression[]): BoxedExpression;
  *    -> 'a^3 + 3a^2b + 3ab^2 + b^3'
  */
 export declare function expandMultinomial(expr: BoxedExpression): BoxedExpression | null;
+/** Expand all
+ * Recursive expand of all terms in the expression
+ */
+export declare function expandAll(expr: BoxedExpression): BoxedExpression | null;
 /** Apply the distributive law if the expression is a product of sums.
  * For example, a(b + c) = ab + ac
  * Expand the expression if it is a power of a sum.

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 /**
  * Flatten the arguments.
  */

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.
@@ -6,5 +6,6 @@
  * 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 evalNegate(expr: BoxedExpression): BoxedExpression;
+export declare function canonicalNegate(expr: BoxedExpression): 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.22.0 */
+/* 0.23.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 /**
  * Group terms in a product by common term.
  *
@@ -21,10 +21,11 @@ export declare class Product {
     };
     engine: IComputeEngine;
     private _sign;
-    private _rational;
+    private _number;
     private _complex;
     private _bignum;
-    private _number;
+    private _rational;
+    private _rationalSqrt;
     private _terms;
     private _hasInfinity;
     private _hasZero;
@@ -40,6 +41,10 @@ export declare class Product {
      * Otherwise, terms and their exponent are tallied.
      */
     addTerm(term: BoxedExpression): void;
+    /** Return all ther terms with an exponent of 1 and
+     * the square root of rationals (which technically have an
+     * exponent of 1/2, but are considered as degree 1 terms)
+     */
     unitTerms(mode: 'rational' | 'expression' | 'numeric'): {
         exponent: Rational;
         terms: BoxedExpression[];

package/dist/types/compute-engine/symbolic/tensor-fields.d.ts

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 import { BoxedExpression, IComputeEngine } from '../public';
 export type DataTypeMap = {
     float64: number;

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 import { DataTypeMap, TensorDataType, TensorField } from './tensor-fields';
 export interface TensorData<DT extends keyof DataTypeMap = 'float64'> {
     dtype: DT;

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

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

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

@@ -1,3 +1,3 @@
-/* 0.22.0 */
-export declare const version = "0.22.0";
+/* 0.23.0 */
+export declare const version = "0.23.0";
 export { ComputeEngine } from './compute-engine/compute-engine';

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

@@ -1,4 +1,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
     /** 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,4 @@
-/* 0.22.0 */
+/* 0.23.0 */
 export declare const MISSING: Expression;
 export declare function isNumberExpression(expr: Expression | null): expr is number | string | MathJsonNumber;
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;

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

@@ -1,3 +1,3 @@
-/* 0.22.0 */
+/* 0.23.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
-export declare const version = "0.22.0";
+export declare const version = "0.23.0";

package/package.json

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

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

@@ -1,33 +0,0 @@
-/* 0.22.0 */
-export declare class Sum {
-    private engine;
-    private _isCanonical;
-    private _rational;
-    private _imaginary;
-    private _number;
-    private _bignum;
-    private _posInfinityCount;
-    private _negInfinityCount;
-    private _naNCount;
-    private _terms;
-    constructor(ce: IComputeEngine, xs?: BoxedExpression[], options?: {
-        canonical?: boolean;
-    });
-    get isEmpty(): boolean;
-    /**
-     * Add a term to the sum.
-     *
-     * A term is a rational coefficient and an expression.
-     * Optionally, the term is multiplied by the constant `c` before being added.
-     *
-     * If the sum already has this term, the coefficient is added
-     * to the previous one. Otherwise, a new entry is added.
-     *
-     * E.g. "2x + x + 1/5 y"
-     *  -> [['x', [3, 1]], ['y', [1, 5]]]
-     */
-    addTerm(term: BoxedExpression, c?: Rational): void;
-    toString(): string;
-    terms(mode: 'expression' | 'numeric'): BoxedExpression[];
-    asExpression(mode: 'expression' | 'numeric'): BoxedExpression;
-}