@cortex-js/compute-engine 0.16.0 → 0.17.0

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

@@ -1,6 +1,7 @@
-/* 0.16.0 */
+/* 0.17.0 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
+    Functions: (string | string[])[];
     NumericFunctions: (string | string[])[];
     RealFunctions: (string | string[])[];
     LogicOperators: (string | string[])[];
@@ -11,5 +12,5 @@ export declare function isDomainLiteral(s: string | null): s is DomainLiteral;
 export declare function isSubdomainLiteral(lhs: string, rhs: string): boolean;
 /** Return all the domain literals that are an ancestor of `dom`
  */
-export declare function ancestors(dom: string): string[];
+export declare function ancestors(dom: DomainLiteral): DomainLiteral[];
 export declare function domainSetsLibrary(): IdentifierDefinitions;

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

@@ -1,5 +1,5 @@
-/* 0.16.0 */
-import { IComputeEngine, IdentifierDefinitions } from '../public';
+/* 0.17.0 */
+import { FunctionDefinition, IComputeEngine, IdentifierDefinitions, SymbolDefinition } from '../public';
 export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
 export declare const LIBRARIES: {
     [category in LibraryCategory]?: IdentifierDefinitions | IdentifierDefinitions[];
@@ -15,3 +15,5 @@ export declare const LIBRARIES: {
  *
  */
 export declare function setIdentifierDefinitions(engine: IComputeEngine, table: IdentifierDefinitions): void;
+export declare function isSymbolDefinition(def: any): def is SymbolDefinition;
+export declare function isFunctionDefinition(def: any): def is FunctionDefinition;

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

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

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.17.0 */
 export declare const LOGIC_LIBRARY: IdentifierDefinitions;

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

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

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

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

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.17.0 */
 export declare const RELOP_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.16.0 */
+/* 0.17.0 */
 export declare const SETS_LIBRARY: IdentifierDefinitions;

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

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

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

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

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

@@ -1,4 +1,2 @@
-/* 0.16.0 */
-export declare function isSymbolDefinition(def: any): def is SymbolDefinition;
-export declare function isFunctionDefinition(def: any): def is FunctionDefinition;
+/* 0.17.0 */
 export declare function normalizeLimits(range: BoxedExpression): [index: string, lower: number, upper: number, isFinite: boolean];

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.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.16.0 */
+/* 0.17.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.16.0 */
+/* 0.17.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,5 +1,5 @@
-/* 0.16.0 */
-import Decimal from 'decimal.js';
+/* 0.17.0 */
+import { Decimal } from 'decimal.js';
 import { BoxedExpression } from '../public';
 export declare const MACHINE_PRECISION_BITS = 53;
 export declare const MACHINE_PRECISION: number;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.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/public.d.ts

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -7,8 +7,8 @@
  *
  * @module ComputeEngine
  */
-import type { Decimal } from 'decimal.js';
 import type { Complex } from 'complex.js';
+import type { Decimal } from 'decimal.js';
 import type { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
 import type { LatexDictionaryEntry, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
 export * from './latex-syntax/public';
@@ -35,6 +35,7 @@ export type Metadata = {
 </div>
  */
 export type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
+export type Hold = 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
 /** Options for `BoxedExpression.simplify()` */
 export type SimplifyOptions = {
     recursive?: boolean;
@@ -42,9 +43,10 @@ export type SimplifyOptions = {
 };
 /** Options for `BoxedExpression.evaluate()`
  *
- * @internal
  */
-export type EvaluateOptions = {};
+export type EvaluateOptions = {
+    numericMode?: boolean;
+};
 /** Options for `BoxedExpression.N()`
  * @internal
  */
@@ -126,50 +128,24 @@ export type BoxedRule = [
 export type BoxedRuleSet = Set<BoxedRule>;
 export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
 /** A domain constructor is the head of a domain expression. */
-export type DomainConstructor = 'InvalidDomain' | 'Functions' | 'List' | 'Dictionary' | 'Tuple' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
-export type DomainLiteral = string;
-export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | ['InvalidDomain', string] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Functions', ...DomainExpression<T>[]];
+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 interface BoxedDomain extends BoxedExpression {
-    is(s: BoxedDomain): boolean;
+    get canonical(): BoxedDomain;
+    get json(): Expression;
     /** True if a valid domain, and compatible with `dom`
-     * kind is 'covariant' by default, i.e. `this <: dom`
+     * `kind` is '"covariant"' by default, i.e. `this <: dom`
      */
     isCompatible(dom: BoxedDomain | DomainLiteral, kind?: DomainCompatibility): boolean;
-    get literal(): string | null;
+    get base(): DomainLiteral;
     get ctor(): DomainConstructor | null;
-    get domainArgs(): (DomainExpression<BoxedExpression> | BoxedExpression | string)[] | null;
-    get codomain(): BoxedDomain | null;
-    get canonical(): BoxedDomain;
-    get json(): Expression;
-    readonly isNothing: boolean;
+    get params(): BoxedDomain[];
+    get optParams(): BoxedDomain[];
+    get restParam(): BoxedDomain | null;
+    get result(): BoxedDomain | null;
     readonly isNumeric: boolean;
     readonly isFunction: boolean;
-    /**
-     * If true, when all the arguments are numeric, the result of the
-     * evaluation is numeric. Numeric is any value with a domain of `Number`.
-     *
-     * Example of numeric functions: `Add`, `Multiply`, `Power`, `Abs`
-     *
-     * Default: `false`
-     */
-    /**
-     * If true, when all the arguments are boolean, the result of the
-     * evaluation is a boolean. Boolean is any value with a domain of `MaybeBoolean`.
-     *
-     * Example of logic functions: `And`, `Or`, `Not`, `Implies`
-     *
-     * **Default:** `false`
-     */
-    /**
-     * The function represent a relation between the first argument and
-     * the second argument, and evaluates to a boolean indicating if the relation
-     * is satisfied.
-     *
-     * For example, `Equal`, `Less`, `Approx`, etc...
-     *
-     * **Default:** `false`
-     */
-    readonly isRelationalOperator: boolean;
 }
 /**
  * Options to control the serialization to MathJSON when using `BoxedExpression.json`.
@@ -495,21 +471,6 @@ export interface BoxedExpression {
      *
      */
     get canonical(): BoxedExpression;
-    /**
-     * If this expression is a function, apply the function `fn` to all its operands.
-     *
-     * Replace the head of this expression with `head`, if defined.
-     *
-     * If this expression is a dictionary, return a new dictionary with the values
-     * modified by `fn`.
-     *
-     * If `head` is provided, return a function expression with the modified
-     * dictionary as operand, otherwise return the  modified dictionary.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     *
-     * */
-    apply(fn: (x: BoxedExpression) => SemiBoxedExpression, head?: string): BoxedExpression;
     /**
      * Replace all the symbols in the expression as indicated.
      *
@@ -787,29 +748,28 @@ export interface BoxedExpression {
      *
      * If the domain was not set, set it to the inferred domain, return `true`
      * If the domain was previously inferred, adjust it by widening it,
-     *    return `true
+     *    return `true`
      *
      * @internal
      */
     infer(domain: BoxedDomain): boolean;
     /**
-     * Update the definition associated with this expression, taking
-     * into account the specified scope.
-     *
-     * If no scope is specified, the scope of when the expression was boxed is used.
-     *
-     * If the scope is `null`, the definition is removed.
-     *
-     * **Note**: applicable only to canonical expressions
+     * Update the definition associated with this expression, using the
+     * current scope (`ce.context`).
      *
      * @internal
      */
-    bind(scope?: RuntimeScope | null): void;
+    bind(): void;
     /**
+     *
+     * Reset the cached value associated with this expression.
+     *
+     * Use when the environment has changed, for example the numeric mode
+     * or precision, to force the expression to be re-evaluated.
      *
      * @internal
      */
-    unbind(): void;
+    reset(): void;
     /**
      * Return a simpler form of the canonical form of this expression.
      *
@@ -897,25 +857,28 @@ export interface BoxedExpression {
      *
      */
     set value(value: BoxedExpression | number | undefined);
-    /** The domain of the value of this expression.
+    /**
+     *
+     * The domain of the value of this expression.
      *
-     * If a function expression, the domain  of the value of the function (the codomain of the function).
+     * If a function expression, the domain  of the value of the function
+     * (the codomain of the function).
      *
      * If a symbol the domain of the value of the symbol.
      *
-     * Use `expr.head` to determine if an expression is a symbol or function.
+     * Use `expr.head` to determine if an expression is a symbol or function
+     * expression.
+     *
+     * **Note**: if non-canonical or not valid, return `undefined`.
      *
-     * **Note**: If non-canonical, return the domain of its canonical
-     * counterpart
      */
-    get domain(): BoxedDomain;
-    /** Modify the domain of a symbol that represent a variable
-     * (or a function name).
+    get domain(): BoxedDomain | undefined;
+    /** Modify the domain of a symbol.
      *
      * **Note**: If non-canonical, does nothing.
      *
      */
-    set domain(domain: BoxedExpression | DomainExpression | BoxedDomain);
+    set domain(domain: DomainExpression | BoxedDomain | undefined);
     /** `true` if the value of this expression is a number.
      *
      * `isExtendedComplex || isNaN` = `isReal || isImaginary || isInfinity || isNaN`
@@ -1235,7 +1198,7 @@ export type FunctionSignature = {
     /** An optional handler to determine the codomain of the function.
      * If not provided, the codomain of the function is determined from `domain`
      */
-    codomain?: (ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null;
+    codomain?: (ce: IComputeEngine, args: BoxedDomain[]) => BoxedDomain | null | undefined;
     /**
      * Return the canonical form of the expression with the arguments `args`.
      *
@@ -1243,11 +1206,14 @@ export type FunctionSignature = {
      * can be put in canonical form.
      *
      * This handler should validate the domain and number of the arguments.
+     *
      * If a required argument is missing, it should be indicated with a
      * `["Error", "'missing"]` expression. If more arguments than expected
-     * are present, this should be indicated with a `unexpected-argument` error.
+     * are present, this should be indicated with an
+     * ["Error", "'unexpected-argument'"]` error expression
+     *
      * If the domain of an argument is not compatible, it should be indicated
-     * with a `incompatible-domain` error.
+     * with an `incompatible-domain` error.
      *
      * `["Sequence"]` expressions are not folded and need to be handled
      *  explicitly.
@@ -1257,8 +1223,8 @@ export type FunctionSignature = {
      * arguments should be sorted in canonical order.
      *
      * The handler can make transformations based on the value of the arguments
-     * that are exact and literal
-     * (i.e. `arg.numericValue !== null && arg.isExact`).
+     * that are exact and literal (i.e.
+     * `arg.numericValue !== null && arg.isExact`).
      *
      * Values of symbols should not be substituted, unless they have
      * a `holdUntil` attribute of `"never"`.
@@ -1380,7 +1346,7 @@ export type FunctionSignature = {
 };
 export type BoxedFunctionSignature = {
     domain: BoxedDomain;
-    codomain?: BoxedDomain | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedDomain | null);
+    codomain?: 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;
@@ -1476,12 +1442,12 @@ export type FunctionDefinition = BaseDefinition & Partial<CollectionHandlers> &
      *
      * **Default**: `"none"`
      */
-    hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    hold?: Hold;
     signature: FunctionSignature;
 };
 export type BoxedFunctionDefinition = BoxedBaseDefinition & Partial<CollectionHandlers> & FunctionDefinitionFlags & {
     complexity: number;
-    hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
+    hold: Hold;
     signature: BoxedFunctionSignature;
 };
 /**
@@ -1493,7 +1459,7 @@ export type BoxedFunctionDefinition = BoxedBaseDefinition & Partial<CollectionHa
  * For example, it might be useful to override `algebraic = false`
  * for a transcendental number.
  */
-export type SymbolFlags = {
+export type NumericFlags = {
     number: boolean | undefined;
     integer: boolean | undefined;
     rational: boolean | undefined;
@@ -1559,7 +1525,7 @@ export type SymbolAttributes = {
  * (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14... domain = TranscendentalNumbers)
  */
 export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
-    domain?: string | BoxedDomain;
+    domain?: DomainLiteral | BoxedDomain;
     /** If true, the domain is inferred, and could be adjusted later
      * as more information becomes available or if the symbol is explicitly
      * declared.
@@ -1569,9 +1535,9 @@ export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
      * `Pi`, the actual value depends on the `precision` setting of the
      * `ComputeEngine` and possible other environment settings */
     value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
-    flags?: Partial<SymbolFlags>;
+    flags?: Partial<NumericFlags>;
 };
-export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttributes, Partial<SymbolFlags> {
+export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttributes, Partial<NumericFlags> {
     get value(): BoxedExpression | undefined;
     set value(val: SemiBoxedExpression | number | undefined);
     domain: BoxedDomain | undefined;
@@ -1592,24 +1558,25 @@ export type AssignValue = boolean | number | string | Decimal | Complex | LatexS
 /** @internal */
 export interface IComputeEngine {
     latexDictionary: readonly LatexDictionaryEntry[];
-    /** @internal */
-    readonly _ZERO: BoxedExpression;
-    /** @internal */
-    readonly _ONE: BoxedExpression;
-    /** @internal */
-    readonly _HALF: BoxedExpression;
-    /** @internal */
-    readonly _NEGATIVE_ONE: BoxedExpression;
-    /** @internal */
-    readonly _I: BoxedExpression;
-    /** @internal */
-    readonly _NAN: BoxedExpression;
-    /** @internal */
-    readonly _POSITIVE_INFINITY: BoxedExpression;
-    /** @internal */
-    readonly _NEGATIVE_INFINITY: BoxedExpression;
-    /** @internal */
-    readonly _COMPLEX_INFINITY: BoxedExpression;
+    readonly Anything: BoxedDomain;
+    readonly Void: BoxedDomain;
+    readonly Strings: BoxedDomain;
+    readonly Booleans: BoxedDomain;
+    readonly Numbers: BoxedDomain;
+    readonly True: BoxedExpression;
+    readonly False: BoxedExpression;
+    readonly Pi: BoxedExpression;
+    readonly E: BoxedExpression;
+    readonly Nothing: BoxedExpression;
+    readonly Zero: BoxedExpression;
+    readonly One: BoxedExpression;
+    readonly Half: BoxedExpression;
+    readonly NegativeOne: BoxedExpression;
+    readonly I: BoxedExpression;
+    readonly NaN: BoxedExpression;
+    readonly PositiveInfinity: BoxedExpression;
+    readonly NegativeInfinity: BoxedExpression;
+    readonly ComplexInfinity: BoxedExpression;
     /** @internal */
     readonly _BIGNUM_NAN: Decimal;
     /** @internal */
@@ -1636,7 +1603,6 @@ export interface IComputeEngine {
     readonly iterationLimit: number;
     /** @experimental */
     readonly recursionLimit: number;
-    defaultDomain: null | BoxedDomain;
     /** {@inheritDoc  NumericMode} */
     numericMode: NumericMode;
     tolerance: number;
@@ -1802,7 +1768,7 @@ export interface IComputeEngine {
      * If the domain is invalid, may return an `["Error"]` expression
      *
      */
-    domain(domain: SemiBoxedExpression | BoxedDomain | string, metadata?: Metadata): BoxedDomain;
+    domain(domain: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
     /**
      * Return a canonical expression.
      *
@@ -1832,6 +1798,7 @@ export interface IComputeEngine {
      * The result is canonical.
      */
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
+    domainError(expectedDomain: BoxedDomain | DomainLiteral, actualDomain: undefined | BoxedDomain, where?: SemiBoxedExpression): BoxedExpression;
     /**
      * Add a`["Hold"]` wrapper to `expr.
      */
@@ -1851,6 +1818,10 @@ export interface IComputeEngine {
      * The result is canonical.
      */
     pow(base: BoxedExpression, exponent: number | Rational | BoxedExpression, metadata?: Metadata): BoxedExpression;
+    /** Shortcut for `this.fn("Sqrt"...)`
+     *
+     * The result is canonical.
+     */
     sqrt(base: BoxedExpression, metadata?: Metadata): any;
     /** Shortcut for `this.fn("Divide", [1, expr])`
      *
@@ -1897,7 +1868,9 @@ export interface IComputeEngine {
     /** Serialize a `BoxedExpression` or a `MathJSON` expression to
      * a LaTeX string
      */
-    serialize(expr: SemiBoxedExpression): LatexString;
+    serialize(expr: SemiBoxedExpression, options?: {
+        canonical?: boolean;
+    }): LatexString;
     /**
      * Options to control the serialization of MathJSON expression to LaTeX
      * when using `this.latex` or `this.engine.serialize()`.
@@ -1920,6 +1893,11 @@ export interface IComputeEngine {
     popScope(): IComputeEngine;
     /** Set the current scope, return the previous scope. */
     swapScope(scope: RuntimeScope | null): RuntimeScope | null;
+    /**
+     * Reset the value of any identifiers that have been assigned a value
+     * in the current scope.
+     * @internal */
+    resetContext(): void;
     /** Assign a value to an identifier in the current scope.
      * Use `undefined` to reset the identifier to no value.
      *
@@ -1955,12 +1933,12 @@ export interface IComputeEngine {
      *
      */
     declare(identifiers: {
-        [id: string]: DomainExpression | SymbolDefinition | FunctionDefinition;
+        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
     }): IComputeEngine;
-    declare(id: string, def: DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
+    declare(id: string, def: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
     declare(arg1: string | {
-        [id: string]: DomainExpression | SymbolDefinition | FunctionDefinition;
-    }, arg2?: DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
+        [id: string]: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition;
+    }, arg2?: BoxedDomain | DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
     /**
      * Add an assumption.
      *

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.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.16.0 */
+/* 0.17.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.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,6 +1,20 @@
-/* 0.16.0 */
+/* 0.17.0 */
+/**
+ *
+ * @param fn The function to differentiate, a `["Function"]` expression or
+ * an identifier for a function name.
+ *
+ * @param degrees
+ * @returns a function expression representing the derivative of `fn` with
+ * respect to the variables in `degrees`.
+ */
+export declare function differentiateFunction(fn: BoxedExpression, degrees: number[]): BoxedExpression | undefined;
 /**
  * Calculate the partial derivative of an expression with respect to a
  * variable, `v`.
+ *
+ * All expressions that do not explicitly depend on `v` are taken to have zero
+ * partial derivative.
+ *
  */
-export declare function partialDerivative(expr: BoxedExpression, v: string): BoxedExpression | undefined;
+export declare function differentiate(expr: BoxedExpression, v: string): BoxedExpression | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.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.16.0 */
+/* 0.17.0 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.
@@ -6,4 +6,3 @@
 export declare function flatten(expr: BoxedExpression, head: string): BoxedExpression;
 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,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.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.16.0 */
+/* 0.17.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

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

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

@@ -1,4 +1,4 @@
-/* 0.16.0 */
+/* 0.17.0 */
 export declare class Sum {
     private engine;
     private _isCanonical;

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

@@ -1,6 +1,6 @@
-/* 0.16.0 */
-import Decimal from 'decimal.js';
-import { BoxedExpression, Rational } from '../public';
+/* 0.17.0 */
+import { Decimal } from 'decimal.js';
+import { BoxedExpression, Hold, Rational } from '../public';
 /**
  * Return a rational coef and constant such that `coef * mod + constant = expr`
  */
@@ -23,3 +23,5 @@ export declare function apply(expr: BoxedExpression, fn: (x: number) => number |
 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[];

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

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