@cortex-js/compute-engine 0.24.1 → 0.25.0

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.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,4 @@
-/* 0.24.1 */
+/* 0.25.0 */
 /**
  * @todo: a set to "tidy" an expression. Different from a canonical form, but
  * inline with the user's expectations.

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

@@ -1,4 +1,5 @@
-/* 0.24.1 */
+/* 0.25.0 */
+import { Rule } from './public';
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality
@@ -6,7 +7,7 @@ export declare const UNIVARIATE_ROOTS: Rule[];
  * Return the roots of that variable
  *
  */
-export declare function findUnivariateRoots(expr: BoxedExpression, x: string): BoxedExpression[];
+export declare function findUnivariateRoots(expr: BoxedExpression, x: string): ReadonlyArray<BoxedExpression>;
 /** Expr is an equation with a head of
  * - `Equal`, `Less`, `Greater`, `LessEqual`, `GreaterEqual`
  *
@@ -14,5 +15,5 @@ export declare function findUnivariateRoots(expr: BoxedExpression, x: string): B
  * a variable, if possible:
  * `2x < 4` => `x < 2`
  */
-export declare function univariateSolve(expr: BoxedExpression, x: string): SemiBoxedExpression[] | null;
+export declare function univariateSolve(expr: BoxedExpression, x: string): ReadonlyArray<SemiBoxedExpression> | null;
 export declare const HARMONIZATION_RULES: Rule[];

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

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

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

@@ -1,5 +1,5 @@
-/* 0.24.1 */
-export declare function distribute(expr: BoxedExpression[]): BoxedExpression;
+/* 0.25.0 */
+export declare function distribute(expr: ReadonlyArray<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.
  * The power must be a positive integer.

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

@@ -1,7 +1,9 @@
-/* 0.24.1 */
+/* 0.25.0 */
 /**
  * Flatten the arguments.
  */
-export declare function flattenOps(ops: BoxedExpression[], head: string): BoxedExpression[];
-export declare function flattenSequence(xs: BoxedExpression[]): BoxedExpression[];
-export declare function flattenDelimiter(ce: IComputeEngine, body: undefined | BoxedExpression): BoxedExpression;
+export declare function flattenOps(ops: ReadonlyArray<BoxedExpression>, head: string): ReadonlyArray<BoxedExpression>;
+/**
+ * @todo: this function should probably not be recursive. As it, it is semi-recursive.
+ */
+export declare function flattenSequence(xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.0 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or multiplication or another `Negate`.

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

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

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

@@ -1,4 +1,5 @@
-/* 0.24.1 */
+/* 0.25.0 */
+import { Rational } from '../numerics/rationals';
 /**
  * Group terms in a product by common term.
  *
@@ -30,7 +31,7 @@ export declare class Product {
     private _hasInfinity;
     private _hasZero;
     private _isCanonical;
-    constructor(ce: IComputeEngine, xs?: BoxedExpression[], options?: {
+    constructor(ce: IComputeEngine, xs?: ReadonlyArray<BoxedExpression>, options?: {
         canonical?: boolean;
     });
     get isEmpty(): boolean;
@@ -41,7 +42,7 @@ 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
+    /** Return all the 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)
      */

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.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.24.1 */
+/* 0.25.0 */
 import { DataTypeMap, TensorDataType, TensorField } from './tensor-fields';
 /**
  * @noInheritDoc

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

@@ -1,6 +1,7 @@
-/* 0.24.1 */
+/* 0.25.0 */
 import { Decimal } from 'decimal.js';
-import { BoxedExpression, Hold, Rational } from '../public';
+import { Rational } from '../numerics/rationals';
+import { BoxedExpression, Hold, IComputeEngine, SemiBoxedExpression } from '../public';
 /**
  * Return a rational coef and constant such that `coef * mod + constant = expr`
  */
@@ -11,17 +12,11 @@ import { BoxedExpression, Hold, Rational } from '../public';
  *
  * Return null if no `coef`/`constant` can be found.
  */
-/**
- * Apply the operator `op` to the left-hand-side and right-hand-side
- * expression. Applies the associativity rule specified by the definition,
- * i.e. 'op(a, op(b, c))` -> `op(a, b, c)`, etc...
- *
- */
-export declare function applyAssociativeOperator(op: string, lhs: BoxedExpression, rhs: BoxedExpression, associativity?: 'right' | 'left' | 'non' | 'both'): BoxedExpression;
 export declare function makePositive(expr: BoxedExpression): [sign: number, expr: BoxedExpression];
 export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): number | Decimal | Complex;
 export declare function applyN(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;
 export declare function apply2(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex | Rational, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | Rational | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): number | Decimal | Complex | Rational;
 export declare function apply2N(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex | Rational, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number | Rational, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): BoxedExpression | undefined;
 export declare function shouldHold(skip: Hold, count: number, index: number): boolean;
-export declare function canonical(xs: BoxedExpression[]): BoxedExpression[];
+export declare function semiCanonical(ce: IComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>): BoxedExpression[];
+export declare function canonical(xs: ReadonlyArray<BoxedExpression>): ReadonlyArray<BoxedExpression>;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.0 */
 /** @category MathJSON */
 export type Attributes = {
     /** A human readable string to annotate this expression, since JSON does not
@@ -96,7 +96,7 @@ export type MathJsonString = {
 } & Attributes;
 /** @category MathJSON */
 export type MathJsonFunction = {
-    fn: [Expression, ...Expression[]];
+    fn: [MathJsonIdentifier | MathJsonFunction, ...Expression[]];
 } & Attributes;
 /** @category MathJSON */
 export type MathJsonDictionary = {
@@ -112,4 +112,4 @@ export type MathJsonDictionary = {
  *
  * @category MathJSON
  */
-export type Expression = number | MathJsonIdentifier | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];
+export type Expression = number | MathJsonIdentifier | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [MathJsonIdentifier | MathJsonFunction, ...Expression[]];

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.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;
@@ -68,12 +68,10 @@ export declare function subs(expr: Expression, s: {
  */
 export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T): T[];
 /**
- * Apply the operator `op` to the left-hand-side and right-hand-side
- * expression. Applies the associativity rule specified by the definition,
- * i.e. 'op(a, op(b, c))` -> `op(a, b, c)`, etc...
- *
+ * Assuming that op is an associative operator, fold lhs or rhs
+ * if either are the same operator.
  */
-export declare function applyAssociativeOperator(op: string, lhs: Expression, rhs: Expression, associativity?: 'right' | 'left' | 'non' | 'both'): Expression;
+export declare function foldAssociativeOperator(op: string, lhs: Expression, rhs: Expression): Expression;
 /** Return the elements of a sequence, or null if the expression is not a sequence. The sequence can be optionally enclosed by a`["Delimiter"]` expression  */
 export declare function getSequence(expr: Expression | null): Expression[] | null;
 export declare function isEmptySequence(expr: Expression | null): boolean;

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

@@ -1,3 +1,3 @@
-/* 0.24.1 */
+/* 0.25.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.24.1";
+export declare const version = "0.25.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.24.1",
+  "version": "0.25.0",
   "scripts": {
     "doc": "bash ./scripts/doc.sh",
     "build": "bash ./scripts/build.sh",

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

@@ -1,28 +0,0 @@
-/* 0.24.1 */
-import { Serializer } from './serializer';
-import { Expression } from '../../math-json/math-json-format';
-import { WarningSignalHandler } from '../../common/signals';
-import { IComputeEngine } from '../public';
-export declare const DEFAULT_SERIALIZE_LATEX_OPTIONS: Required<SerializeLatexOptions>;
-export declare class LatexSyntax {
-    onError: WarningSignalHandler;
-    readonly options: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
-    readonly computeEngine: IComputeEngine;
-    private _dictionary;
-    private _dictionaryInput;
-    private _serializer?;
-    constructor(options: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions> & {
-        computeEngine: IComputeEngine;
-        dictionary?: readonly LatexDictionaryEntry[];
-        onError?: WarningSignalHandler;
-    });
-    get dictionary(): readonly LatexDictionaryEntry[];
-    set dictionary(val: readonly LatexDictionaryEntry[]);
-    updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
-    static getDictionary(category?: LibraryCategory | 'all'): readonly Readonly<object>[];
-    parse(latex: LatexString): Expression;
-    serialize(expr: Expression, options?: {
-        canonical?: boolean;
-    }): LatexString;
-    get serializer(): Serializer;
-}

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

@@ -1,27 +0,0 @@
-/* 0.24.1 */
-import Decimal from 'decimal.js';
-import { BoxedExpression, Rational } from '../public';
-/**
- * Attempt to factor a numeric 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).
- *
- * The numeric coefficient could be an expression, for example:
- * ['Multiply', 2, ['Sqrt', 5], 'x']
- *    -> [['Multiply', 2, ['Sqrt', 5]], 'x']
- *
- * ['Multiply', 2, 'x', 3, 'a']
- *    -> [6, ['Multiply', 'x', 'a']]
- *
- * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
- *    -> [['Rational', 2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
- */
-export declare function asCoefficient(expr: BoxedExpression): [coef: Rational, rest: BoxedExpression];
-export declare function applyCoefficient(value: number | Decimal | Complex | Rational | null, coef: Rational): number | Decimal | Complex | Rational | null;
-/** Combine rational expressions into a single fraction */
-export declare function together(op: BoxedExpression): BoxedExpression;
-/**
- * Return a list of expressions that multiply together to form `expr`.
- */
-export declare function factor(expr: BoxedExpression): BoxedExpression;