@cortex-js/compute-engine 0.8.0 → 0.9.0

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 import { IndexedLatexDictionary, InfixEntry, PostfixEntry, PrefixEntry, SymbolEntry } from './dictionary/definitions';
 import { IComputeEngine } from '../public';
 import { Expression } from '../../math-json/math-json-format';
@@ -67,11 +67,17 @@ export declare class _Parser implements Parser {
     peekDefinitions(kind: 'infix'): [InfixEntry, number][] | null;
     peekDefinitions(kind: 'prefix'): [PrefixEntry, number][] | null;
     peekDefinitions(kind: 'operator'): [InfixEntry | PrefixEntry | PostfixEntry, number][] | null;
+    /** Skip strictly `<space>` tokens.
+     * To also skip `{}` see `skipSpace()`.
+     * To skip visual space (e.g. `\,`) see `skipVisualSpace()`.
+     */
     skipSpaceTokens(): void;
-    /** While parsing in math mode, skip applicable spaces.
-     * Do not use to skip spaces e.g. while parsing a string. See `skipSpaceTokens()` instead.
+    /** While parsing in math mode, skip applicable spaces, which includes `{}`.
+     * Do not use to skip spaces while parsing a string. See  `skipSpaceTokens()`
+     * instead.
      */
     skipSpace(): boolean;
+    skipVisualSpace(): void;
     matchChar(): string | null;
     matchColor(_background?: boolean): string | null;
     matchLatexDimension(): string | null;
@@ -109,6 +115,13 @@ export declare class _Parser implements Parser {
      *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
      */
     matchArguments(kind: undefined | '' | 'enclosure' | 'implicit'): Expression[] | null;
+    /**
+     * A function can be followed by the following suffixes:
+     * - a `\prime`, `\doubleprime`, `'`, `(n)` to indicate a derivative
+     * - a subscript to indicate an argument
+     * - an argument, optionally inside an enclosure
+     */
+    matchFunctionSuffix(): Expression | null;
     /** If matches the normalized open delimiter, return the
      * expected closing delimiter.
      *
@@ -119,6 +132,11 @@ export declare class _Parser implements Parser {
      */
     matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): LatexToken[] | null;
     matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
+    /** For error handling, when there is potentially a mismatched delimiter.
+     * Return a LaTeX fragment of the expected closing delimiter
+     */
+    matchEnclosureOpen(): string | null;
+    matchEnclosureClose(): string | null;
     /**
      * An enclosure is an opening matchfix operator, an optional expression,
      * optionally followed multiple times by a separator and another expression,
@@ -126,15 +144,13 @@ export declare class _Parser implements Parser {
      */
     matchEnclosure(): Expression | null;
     /**
-     * Match a single variable name. It can be:
+     * Match an identifier. It can be:
      * - a symbol
      * - a simple multi-letter identifier: `\mathrm{speed}`
-     * - a complex multi-letter identifier: `\alpha_12` or `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
+     * - a complex multi-letter identifier: `\mathrm{\alpha_{12}}` or `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
      * - a command: `\alpha`  @todo
-     * - a complex name such as `\alpha_12` or `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}` (see serializer.ts) @todo:
-     * @todo: matchSymbol should use matchIdentifier
      */
-    matchIdentifier(): string | null;
+    matchIdentifier(): string | Expression | null;
     /**
      * A function is a function identifier followed by arguments
      * - a function with explicit arguments `f(x)`
@@ -151,7 +167,7 @@ export declare class _Parser implements Parser {
      */
     matchSymbol(): Expression | null;
     matchOptionalLatexArgument(): Expression | null;
-    matchRequiredLatexArgument(): Expression | null;
+    matchRequiredLatexArgument(excluding?: string[]): Expression | null;
     matchSupsub(lhs: Expression | null): Expression | null;
     matchPostfix(lhs: Expression | null): Expression | null;
     /** Match a string used as a LaTeX identifier, for example an environment

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -255,7 +255,7 @@ export declare type ParseLatexOptions = {
      * When a number is encountered, parse it.
      *
      * Otherwise, return each token making up the number (minus sign, digits,
-     * decimal separator, etc...).
+     * decimal marker, etc...).
      *
      * **Default**: `true`
      */
@@ -276,7 +276,7 @@ export declare type ParseLatexOptions = {
      *
      * - `error`, an error condition is raised.
      */
-    parseUnknownSymbol: (symbol: string, parser: Parser) => 'symbol' | 'function' | 'unknown';
+    parseUnknownIdentifier: (symbol: string, parser: Parser) => 'symbol' | 'function' | 'unknown';
     /**
      * If true, the expression will be decorated with the LaTeX
      * fragments corresponding to each elements of the expression.
@@ -364,7 +364,7 @@ export declare type NumberFormattingOptions = {
     truncationMarker: LatexString;
     beginRepeatingDigits: LatexString;
     endRepeatingDigits: LatexString;
-    imaginaryNumber: LatexString;
+    imaginaryUnit: LatexString;
     avoidExponentsInRange: [negativeExponent: number, positiveExponent: number];
 };
 /**
@@ -512,18 +512,26 @@ export interface Parser {
     /**
      * Match a required LaTeX argument:
      * - either enclosed in `{}`
-     * - or a single token.
+     * - or a single token (except if token is in `excluding`)
+     *
+     * The `excluding` option is useful to fail early when encountering a likely
+     * syntax error, for example `x^(2)` (instead of `x^{2}`). With `(` in the list
+     * of excluded tokens, the match will fail and the error can be recovered.
+     *
+     * If none is provided, `excluding` is `!"#$%&(),/;:?@[]`|~", `\left` and `\bigl`
+     *
      *
      * Return null if no argument was found
      * Return `['Sequence']` if an empty argument `{}` was found
      */
-    matchRequiredLatexArgument(): Expression | null;
+    matchRequiredLatexArgument(excluding?: string[]): Expression | null;
     /**
      * - 'enclosure' : will look for an argument inside an enclosure (an open/close fence)
      * - 'implicit': either an expression inside a pair of `()`, or just a primary
      *    (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
      */
     matchArguments(kind: '' | 'implicit' | 'enclosure'): Expression[] | null;
+    matchStringArgument(): string | null;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 import { NumberFormattingOptions } from './public';
 export declare function serializeNumber(expr: Expression | null, options: NumberFormattingOptions): string;
 export declare function serializeEngineeringNotationNumber(value: number, options: NumberFormattingOptions): string;

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

@@ -1,8 +1,8 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare function getApplyFunctionStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getGroupStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getRootStyle(_expr: Expression | null, level: number): 'radical' | 'quotient' | 'solidus';
-export declare function getFractionStyle(_expr: Expression, level: number): 'quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+export declare function getFractionStyle(expr: Expression, level: number): 'quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
 export declare function getLogicStyle(_expr: Expression, _level: number): 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
 export declare function getPowerStyle(_expr: Expression, _level: number): 'root' | 'solidus' | 'quotient';
 export declare function getNumericSetStyle(_expr: Expression, _level: number): 'compact' | 'regular' | 'interval' | 'set-builder';

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

@@ -1,7 +1,7 @@
-/* 0.8.0 */
+/* 0.9.0 */
+import { WarningSignalHandler } from '../../common/signals';
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions, FunctionEntry } from './public';
 import { IndexedLatexDictionary, SymbolEntry } from './dictionary/definitions';
-import { WarningSignalHandler } from '../../common/signals';
 export declare class Serializer {
     readonly onError: WarningSignalHandler;
     options: NumberFormattingOptions & SerializeLatexOptions;

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

package/dist/types/compute-engine/library/arithmetic-add.d.ts

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)
@@ -6,6 +6,6 @@
 export declare function canonicalAdd(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
 export declare function domainAdd(_ce: IComputeEngine, args: BoxedDomain[]): BoxedDomain | null;
 export declare function simplifyAdd(ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression | undefined;
-export declare function evalAdd(ce: IComputeEngine, args: BoxedExpression[], mode?: 'N' | 'eval'): BoxedExpression;
-export declare function canonicalSummation(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression | undefined): BoxedExpression;
+export declare function evalAdd(ce: IComputeEngine, ops: BoxedExpression[], mode?: 'N' | 'evaluate'): BoxedExpression;
+export declare function canonicalSummation(ce: IComputeEngine, body: BoxedExpression, range: BoxedExpression | undefined): BoxedExpression;
 export declare function evalSummation(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;

package/dist/types/compute-engine/library/arithmetic-divide.d.ts

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1

package/dist/types/compute-engine/library/arithmetic-multiply.d.ts

@@ -1,19 +1,18 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /** The canonical form of `Multiply`:
  * - remove `1`
- * - combine literal small integers and rationals
+ * - combine literal integers and rationals
  * - any arg is literal 0 -> return 0
- * - simplify signs
  * - combine terms with same base
  *    `a a^3` -> `a^4`
  * - simplify the signs:
- *    - i.e. `-2 \times -3` -> `2 \times 3`
+ *    - i.e. `-y \times -x` -> `x \times y`
  *    - `2 \times -x` -> `-2 \times x`
  *
  * The ops must be canonical, the result is canonical.
  */
 export declare function canonicalMultiply(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
-export declare function simplifyMultiply(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression | undefined;
+export declare function simplifyMultiply(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
 export declare function evalMultiply(ce: IComputeEngine, ops: BoxedExpression[], mode?: 'N' | 'evaluate'): BoxedExpression | undefined;
-export declare function canonicalMultiplication(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression | undefined): BoxedExpression;
+export declare function canonicalMultiplication(ce: IComputeEngine, body: BoxedExpression | undefined, range: BoxedExpression | undefined): BoxedExpression;
 export declare function evalMultiplication(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;

package/dist/types/compute-engine/library/arithmetic-power.d.ts

@@ -1,9 +1,10 @@
-/* 0.8.0 */
+/* 0.9.0 */
 /**
  *
  * Return `null` if there is no canonicalization necessary and the result is
  * simply `ce._fn('Power', [base, exponent])`
  */
-export declare function canonicalPower(ce: IComputeEngine, base: BoxedExpression, exponent: BoxedExpression, metadata?: Metadata): BoxedExpression | null;
+export declare function canonicalPower(ce: IComputeEngine, base: BoxedExpression | undefined, exponent: BoxedExpression | undefined, metadata?: Metadata): BoxedExpression | null;
 export declare function square(ce: IComputeEngine, base: BoxedExpression): BoxedExpression;
 export declare function processPower(ce: IComputeEngine, base: BoxedExpression, exponent: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;
+export declare function processSqrt(ce: IComputeEngine, base: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const ARITHMETIC_LIBRARY: SymbolTable[];

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const CALCULUS_LIBRARY: SymbolTable[];

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const COLLECTIONS_LIBRARY: SymbolTable;

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const CORE_LIBRARY: SymbolTable[];

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
     NumericFunction: (string | string[])[];

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

@@ -1,4 +1,4 @@
-/* 0.8.0 */
+/* 0.9.0 */
 import { IComputeEngine, SymbolTable } from '../public';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): Readonly<SymbolTable>[];
 export declare const LIBRARIES: {

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const LOGIC_LIBRARY: SymbolTable;

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const POLYNOMIALS_LIBRARY: SymbolTable[];

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const RELOP_LIBRARY: SymbolTable;

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const SETS_LIBRARY: SymbolTable;

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

@@ -1,2 +1,2 @@
-/* 0.8.0 */
+/* 0.9.0 */
 export declare const TRIGONOMETRY_LIBRARY: SymbolTable[];

package/dist/types/compute-engine/numerics/{numeric-decimal.d.ts → numeric-bignum.d.ts}

@@ -1,16 +1,20 @@
-/* 0.8.0 */
+/* 0.9.0 */
 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 reducedRational([a, b]: [Decimal, Decimal]): [
-    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;
 /**
- * If the exponent of the decimal number is in the range of the exponents
+ * If the exponent of the bignum is in the range of the exponents
  * for machine numbers,return true.
  */
 export declare function isInMachineRange(d: Decimal): boolean;

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

@@ -1,3 +1,3 @@
-/* 0.8.0 */
+/* 0.9.0 */
 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,7 @@
-/* 0.8.0 */
+/* 0.9.0 */
+import Decimal from 'decimal.js';
+import { BoxedExpression } from '../public';
+export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;
 export declare const MACHINE_TOLERANCE_BITS = 7;
 export declare const MACHINE_TOLERANCE: number;
@@ -25,13 +28,14 @@ export declare function primeFactors(n: number): {
  */
 export declare function factorPower(n: number, exponent: number): [factor: number, root: number];
 export declare function gcd(a: number, b: number): number;
-export declare function rationalGcd([a, b]: [number, number], [c, d]: [number, number]): [number, number];
 export declare function lcm(a: number, b: number): number;
-export declare function rationalLcm([a, b]: [number, number], [c, d]: [number, number]): [number, number];
-export declare function reducedRational([a, b]: [number, number]): [number, number];
 export declare function factorial(n: number): number;
 export declare function lngamma(z: number): number;
 export declare function gamma(z: number): number;
 export declare function fromDigits(s: string, base?: number): [value: number, rest: string];
-/** Return a rational approximation of x */
-export declare function rationalize(x: number): [n: number, d: number] | number;
+export declare function asFloat(expr: BoxedExpression): number | null;
+export declare function asBignum(expr: BoxedExpression): Decimal | null;
+export declare function asSmallInteger(expr: BoxedExpression): number | null;
+export declare function chop(n: number, tolerance: number): number;
+export declare function chop(n: Decimal, tolerance: number): 0 | Decimal;
+export declare function chop(n: Complex, tolerance: number): 0 | Complex;

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

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

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

@@ -0,0 +1,56 @@
+/* 0.9.0 */
+import Decimal from 'decimal.js';
+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 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 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
+ * (no need to check `bignumPreferred()`).
+ * @param lhs
+ * @param rhs
+ * @returns
+ */
+export declare function add(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
+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: 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`
+ */
+export declare function signDiff(lhs: BoxedExpression, rhs: BoxedExpression, tolerance?: number): -1 | 0 | 1 | undefined;