@cortex-js/compute-engine 0.18.0 → 0.19.0

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 import { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { IComputeEngine } from '../public';
 import { Expression } from '../../math-json/math-json-format';
@@ -94,38 +94,18 @@ export declare class _Parser implements Parser {
     matchAll(tokens: LatexToken[]): boolean;
     matchAny(tokens: LatexToken[]): LatexToken;
     matchChar(): string | null;
-    /** If the next token matches the open delimiter, set a boundary with
+    /**
+     *
+     * If the next token matches the open delimiter, set a boundary with
      * the close token and return true.
      *
-     * Note this method handles generic delimiters, i.e. '(' will math both
-     * '(', '\left(', '\bigl(', etc...
-     *
-     * Note that the definitions for matchfix may need to include synonyms
-     * for example:
-     *
-     * {
-     *    openDelimiter: '(',
-     *    closeDelimiter: ')'
-     * }
-     *
-     * and
-     *
-     * {
-     *   openDelimiter: '\\lparen',
-     *   closeDelimiter: '\\rparen'
-     * }
-     *
-     * For:
-     * - '[': '\\lbrack' and '\\['
-     * - ']': '\\rbrack' and '\\]'
-     * - '{': '\\lbrace' and '\\}'
-     * - '}': '\\rbrace' and '\\}'
-     * - '<': '\\langle'
-     * - '>': '\\rangle'
-     * - '|': '\\vert'
-     * - '||': '\\Vert'
-     * - '|': '\\lvert' and '\\rvert'
-     * - '||': '\\lVert' and '\\rVert'
+     * Note this method handles "shorthand" delimiters, i.e. '(' will match both
+     * `(` and `\lparen`. If a shorthand is used for the open delimiter, the
+     * corresponding shorthand will be used for the close delimiter.
+     * See DELIMITER_SHORTHAND.
+     *
+     * It also handles prefixes like `\left` and `\bigl`.
+     *
      */
     private matchDelimiter;
     parseGroup(): Expression | null;
@@ -192,16 +172,6 @@ export declare class _Parser implements Parser {
      * @internal
      */
     private matchOpenDelimiter;
-    /** For error handling, when there is potentially a mismatched delimiter.
-     * Return a LaTeX fragment of the expected closing delimiter
-     *
-     * @internal
-     */
-    matchEnclosureOpen(): string | null;
-    /**
-     * Used for error handling
-     * @internal */
-    matchEnclosureClose(): string | null;
     /**
      * An enclosure is an opening matchfix operator, an optional expression,
      * optionally followed multiple times by a separator and another expression,
@@ -263,12 +233,18 @@ export declare class _Parser implements Parser {
      */
     private applyInvisibleOperator;
     /**
-     * This is an error handling method. We've encountered a LaTeX command
-     * but were not able to match it to any entry in the LaTeX dictionary,
-     * or ran into it in an unexpected context (postfix operator lacking an
-     * argument, for example)
+     * This method can be invoked when we know we're in an error situation.
+     *
+     * In general, if a context does not apply, we return `null` to give
+     * the chance to some other option to be considered. However, in some cases
+     * we know we've exhausted all posibilities, and in this case this method
+     * will return an error expression as informative as possible.
+     *
+     * We've encountered a LaTeX command or symbol but were not able to match it
+     * to any entry in the LaTeX dictionary, or ran into it in an unexpected
+     * context (postfix operator lacking an argument, for example)
      */
-    private parseUnexpectedLatexCommand;
+    parseSyntaxError(): Expression;
     /**
      * <primary> :=
      *  (<number> | <symbol> | <environment> | <matchfix-expr>)

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -124,7 +124,7 @@ export type LatexArgumentType = '{expression}' /** A required math mode expressi
  *  being the `identifierTrigger`.
  *
  *
- * `matchfix` operators use `openDelimiter` and `closeDelimiter` instead.
+ * `matchfix` operators use `openTrigger` and `closeTrigger` instead.
  *
  */
 export type Trigger = {
@@ -167,11 +167,11 @@ export type ExpressionEntry = BaseEntry & Trigger & {
 export type MatchfixEntry = BaseEntry & {
     kind: 'matchfix';
     /**
-     * If `kind` is `'matchfix'`: the `closeDelimiter` and `openDelimiter`
-     * property are required
+     * If `kind` is `'matchfix'`: the `openTrigger` and `closeTrigger`
+     * properties are required.
      */
-    openTrigger?: Delimiter | LatexToken[];
-    closeTrigger?: Delimiter | LatexToken[];
+    openTrigger: Delimiter | LatexToken[];
+    closeTrigger: Delimiter | LatexToken[];
     /** When invoked, the parser is pointing after the close delimiter.
      * The argument of the handler is the body, i.e. the content between
      * the open delimiter and the close delimiter.
@@ -383,7 +383,7 @@ export type SerializeLatexOptions = {
     applyFunctionStyle: (expr: Expression, level: number) => 'paren' | 'leftright' | 'big' | 'none';
     groupStyle: (expr: Expression, level: number) => 'paren' | 'leftright' | 'big' | 'none';
     rootStyle: (expr: Expression, level: number) => 'radical' | 'quotient' | 'solidus';
-    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
     logicStyle: (expr: Expression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
     powerStyle: (expr: Expression, level: number) => 'root' | 'solidus' | 'quotient';
     numericSetStyle: (expr: Expression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
@@ -503,7 +503,7 @@ export interface Serializer {
     applyFunctionStyle: (expr: Expression, level: number) => 'paren' | 'leftright' | 'big' | 'none';
     groupStyle: (expr: Expression, level: number) => 'paren' | 'leftright' | 'big' | 'none';
     rootStyle: (expr: Expression, level: number) => 'radical' | 'quotient' | 'solidus';
-    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
     logicStyle: (expr: Expression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
     powerStyle: (expr: Expression, level: number) => 'root' | 'solidus' | 'quotient';
     numericSetStyle: (expr: Expression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';

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

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

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

@@ -1,8 +1,8 @@
-/* 0.18.0 */
+/* 0.19.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' | 'block-quotient' | 'inline-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,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 import { WarningSignalHandler } from '../../common/signals';
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
 import { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
@@ -37,7 +37,7 @@ export declare class Serializer {
     applyFunctionStyle(expr: Expression, level: number): 'paren' | 'leftright' | 'big' | 'none';
     groupStyle(expr: Expression, level: number): 'paren' | 'leftright' | 'big' | 'none';
     rootStyle(expr: Expression, level: number): 'radical' | 'quotient' | 'solidus';
-    fractionStyle(expr: Expression, level: number): 'quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    fractionStyle(expr: Expression, level: number): 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
     logicStyle(expr: Expression, level: number): 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
     powerStyle(expr: Expression, level: number): 'root' | 'solidus' | 'quotient';
     numericSetStyle(expr: Expression, level: number): 'compact' | 'regular' | 'interval' | 'set-builder';

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.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.18.0 */
+/* 0.19.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)
@@ -8,4 +8,4 @@ export declare function domainAdd(_ce: IComputeEngine, args: (undefined | BoxedD
 export declare function simplifyAdd(ce: IComputeEngine, args: BoxedExpression[]): 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;
+export declare function evalSummation(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression | undefined, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 /** The canonical form of `Multiply`:
  * - remove `1`
  * - combine literal integers and rationals
@@ -15,4 +15,4 @@ export declare function canonicalMultiply(ce: IComputeEngine, ops: BoxedExpressi
 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 canonicalProduct(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;
+export declare function evalMultiplication(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression | undefined, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 /**
  *
  */

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

@@ -1,3 +1,3 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export type CanonicalArithmeticFunctions = 'Add' | 'Negate' | 'Sqrt' | 'Multiply' | 'Divide' | 'Power' | 'Ln';
 export declare const ARITHMETIC_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const CALCULUS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,3 @@
-/* 0.18.0 */
+/* 0.19.0 */
+export declare const DEFAULT_LINSPACE_COUNT = 50;
 export declare const COLLECTIONS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const COMPLEX_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const CONTROL_STRUCTURES_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const CORE_LIBRARY: IdentifierDefinitions[];

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
     Functions: (string | string[])[];

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 import { FunctionDefinition, IComputeEngine, IdentifierDefinitions, SymbolDefinition } from '../public';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
 export declare const LIBRARIES: {

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const LINEAR_ALGEBRA_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const LOGIC_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const POLYNOMIALS_LIBRARY: IdentifierDefinitions[];

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

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

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const RELOP_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const SETS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const STATISTICS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.18.0 */
+/* 0.19.0 */
 export declare const TRIGONOMETRY_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,29 @@
-/* 0.18.0 */
-export declare function normalizeLimits(range: BoxedExpression): [index: string, lower: number, upper: number, isFinite: boolean];
+/* 0.19.0 */
+/**
+ * Assume the caller has setup a scope. The index
+ * variable will be declared in that scope.
+ *
+ * @param limits
+ *
+ */
+export declare function canonicalLimits(limits: BoxedExpression | undefined): BoxedExpression | undefined;
+/**
+ * Limits is an expression describing an index variable
+ * and a range of values for that variable.
+ *
+ * This can take several valid forms:
+ * - a symbol, e.g. `n`, the upper and lower bounds are assumed ot be infinity
+ * - a tuple, e.g. `["Pair", "n", 1]` or `["Tuple", "n", 1, 10]` with one or two bounds
+ *
+ * The result is a normalized version that includes the
+ * index, the lower and upper bounds of the range, and
+ * a flag indicating whether the range is finite.
+ * @param limits
+ * @returns
+ */
+export declare function normalizeLimits(limits: BoxedExpression | undefined): [
+    index: string | undefined,
+    lower: number,
+    upper: number,
+    isFinite: boolean
+];

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 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.18.0 */
+/* 0.19.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.18.0 */
+/* 0.19.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.18.0 */
+/* 0.19.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;
@@ -34,9 +34,9 @@ export declare function factorial2(n: number): number;
 export declare function gammaln(z: number): number;
 export declare function gamma(z: number): number;
 export declare function fromDigits(s: string, base?: number): [value: number, rest: string];
-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 asFloat(expr: BoxedExpression | undefined): number | null;
+export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;
+export declare function asSmallInteger(expr: BoxedExpression | undefined): 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;
@@ -69,7 +69,7 @@ export declare function erfInv(x: number): number;
  * first derivative is given by:
  *
  * \[
- * f'(x) \approx \frac{-f(x-4h) + 9f(x-3h) - 45f(x-2h) + 186f(x-h) - 186f(x+h) + 45f(x+2h) - 9f(x+3h) + f(x+4h)}{60h}
+ * f'(x) \approx \frac{1}{280h} \left[ -f(x-4h) + \frac{4}{3}f(x-3h) - \frac{1}{5}f(x-2h) + \frac{8}{5}f(x-h) - \frac{8}{5}f(x+h) + \frac{1}{5}f(x+2h) - \frac{4}{3}f(x+3h) + f(x+4h) \right]
  * \]
  *
  * Note: Mathematica uses an 8th order approximation for the first derivative
@@ -77,6 +77,8 @@ export declare function erfInv(x: number): number;
  * f: the function
  * x: the point at which to approximate the derivative
  * h: the step size
+ *
+ * See https://en.wikipedia.org/wiki/Finite_difference_coefficient
  */
 export declare function centeredDiff8thOrder(f: (number: any) => number, x: number, h?: number): number;
 /**

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

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

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.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];

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

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

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -130,7 +130,7 @@ export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' |
 /** A domain constructor is the head of a domain expression. */
 export type DomainConstructor = 'FunctionOf' | 'ListOf' | 'DictionaryOf' | 'TupleOf' | 'Intersection' | 'Union' | 'OptArg' | 'VarArg' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
 export type DomainLiteral = 'Anything' | 'Values' | 'Domains' | 'Void' | 'NothingDomain' | 'Booleans' | 'Strings' | 'Symbols' | 'Collections' | 'Lists' | 'Dictionaries' | 'Sequences' | 'Tuples' | 'Sets' | 'Functions' | 'Predicates' | 'LogicOperators' | 'RelationalOperators' | 'NumericFunctions' | 'RealFunctions' | 'Numbers' | 'ComplexNumbers' | 'ExtendedRealNumbers' | 'ImaginaryNumbers' | 'Integers' | 'Rationals' | 'PositiveNumbers' | 'PositiveIntegers' | 'NegativeNumbers' | 'NegativeIntegers' | 'NonNegativeNumbers' | 'NonNegativeIntegers' | 'NonPositiveNumbers' | 'NonPositiveIntegers' | 'ExtendedComplexNumbers' | 'TranscendentalNumbers' | 'AlgebraicNumbers' | 'RationalNumbers' | 'RealNumbers';
-export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | ['Union', ...(DomainExpression<T> | BoxedExpression)[]] | ['Intersection', ...(DomainExpression<T> | BoxedExpression)[]] | ['ListOf', DomainExpression<T>] | ['DictionaryOf', DomainExpression<T>] | ['TupleOf', ...DomainExpression<T>[]] | ['OptArg', ...DomainExpression<T>[]] | ['VarArg', DomainExpression<T>] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['FunctionOf', ...DomainExpression<T>[]];
+export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['ListOf', DomainExpression<T>] | ['DictionaryOf', DomainExpression<T>] | ['TupleOf', ...DomainExpression<T>[]] | ['OptArg', ...DomainExpression<T>[]] | ['VarArg', DomainExpression<T>] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['FunctionOf', ...DomainExpression<T>[]];
 export interface BoxedDomain extends BoxedExpression {
     get canonical(): BoxedDomain;
     get json(): Expression;
@@ -140,10 +140,7 @@ export interface BoxedDomain extends BoxedExpression {
     isCompatible(dom: BoxedDomain | DomainLiteral, kind?: DomainCompatibility): boolean;
     get base(): DomainLiteral;
     get ctor(): DomainConstructor | null;
-    get params(): BoxedDomain[];
-    get optParams(): BoxedDomain[];
-    get restParam(): BoxedDomain | null;
-    get result(): BoxedDomain | null;
+    get params(): DomainExpression[];
     readonly isNumeric: boolean;
     readonly isFunction: boolean;
 }
@@ -215,15 +212,15 @@ export interface BoxedExpression {
     /** From `Object.valueOf()`, return a primitive value for the expression.
      *
      * If the expression is a machine number, or bignum or rational that can be
-     * converted to a machine number, return a `number`.
+     * converted to a machine number, return a JavaScript `number`.
      *
      * If the expression is a symbol, return the name of the symbol as a `string`.
      *
-     * Otherwise return a LaTeX representation of the expression.
+     * Otherwise return a JavaScript primitive representation of the expression.
      *
      * @category Primitive Methods
      */
-    valueOf(): number | string | boolean;
+    valueOf(): number | any[] | string | boolean;
     /** From `Object.toString()`, return a string representation of the
      *  expression. This string is suitable to be output to the console
      * for debugging, for example. To get a LaTeX representation of the
@@ -342,11 +339,8 @@ export interface BoxedExpression {
     readonly unknowns: string[];
     /**
      *
-     * All the identifiers (symbols and functions) in the expression that are a
-     * free variable.
-     *
-     * A free variable is an identifier that is used in a function but is not a
-     * local variable or a parameter of that function.
+     * All the identifiers (symbols and functions) in the expression that are
+     * not a local variable or a parameter of that function.
      *
      */
     readonly freeVariables: string[];
@@ -838,15 +832,12 @@ export interface BoxedExpression {
     }): ((args: Record<string, any>) => any | undefined) | undefined;
     solve(vars: Iterable<string>): null | BoxedExpression[];
     /**
-     * Synonym for `evaluate()`. If the expression is pure, the value may be
-     * cached.
+     * Return a JavaScript primitive representing the value of this expression.
      *
-     * It returns `undefined` for expressions that are not pure or that may
-     * not be evaluated.
+     * Equivalent to `expr.N().valueOf()`.
      *
-     * **Note**: If non-canonical, return the value of its canonical counterpart
      */
-    get value(): BoxedExpression | undefined;
+    get value(): number | boolean | string | number[] | undefined;
     /**
      * Only the value of variables can be changed (symbols that are not
      * constants).
@@ -856,7 +847,13 @@ export interface BoxedExpression {
      * **Note**: If non-canonical, does nothing.
      *
      */
-    set value(value: BoxedExpression | number | undefined);
+    set value(value: boolean | string | Decimal | Complex | {
+        re: number;
+        im: number;
+    } | {
+        num: number;
+        denom: number;
+    } | number[] | BoxedExpression | number | undefined);
     /**
      *
      * The domain of the value of this expression.
@@ -1191,14 +1188,19 @@ export type FunctionDefinitionFlags = {
  *
  */
 export type FunctionSignature = {
-    /** The domain of this signature, a domain compatible with the `Function`
-     * domain) */
-    domain?: BoxedDomain | DomainExpression;
-    /** The minimum and maximum values of the result of the function */
-    /** An optional handler to determine the codomain of the function.
-     * If not provided, the codomain of the function is determined from `domain`
+    /** The domain of this signature, a domain compatible with the `Functions`
+     * domain).
+     *
+     * @deprecated Use params, optParams, restParam and result instead
+     */
+    domain?: DomainExpression;
+    params?: DomainExpression[];
+    optParams?: DomainExpression[];
+    restParam?: DomainExpression;
+    /** The domain of the result of the function. Either a domain
+     * expression, or a function that returns a boxed domain.
      */
-    codomain?: (ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null | undefined;
+    result?: DomainExpression | ((ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null | undefined);
     /**
      * Return the canonical form of the expression with the arguments `args`.
      *
@@ -1345,8 +1347,11 @@ export type FunctionSignature = {
     compile?: (expr: BoxedExpression) => CompiledExpression;
 };
 export type BoxedFunctionSignature = {
-    domain: BoxedDomain;
-    codomain?: BoxedDomain | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedDomain | null | undefined);
+    inferredSignature: boolean;
+    params: BoxedDomain[];
+    optParams: BoxedDomain[];
+    restParam?: BoxedDomain;
+    result: BoxedDomain | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedDomain | null | undefined);
     canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | null;
     simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
     evaluate?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
@@ -1959,6 +1964,8 @@ export interface IComputeEngine {
     forget(symbol?: string | string[]): void;
     get assumptions(): ExpressionMapInterface<boolean>;
     ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
+    /** Using the current assumptions, answer a query. */
+    verify(query: SemiBoxedExpression): boolean;
     /** @internal */
     shouldContinueExecution(): boolean;
     /** @internal */

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 /**
  * 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.18.0 */
+/* 0.19.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.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.18.0 */
+/* 0.19.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.18.0 */
+/* 0.19.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.

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

@@ -1,4 +1,4 @@
-/* 0.18.0 */
+/* 0.19.0 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.

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

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