@cortex-js/compute-engine 0.15.0 → 0.17.0

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

@@ -1,24 +1,7 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { Decimal } from 'decimal.js';
-import { BoxedExpression, Rational } from './public';
-/** Quickly determine the numeric domain of a number or constant
- * For the symbols, this is a hard-coded optimization that doesn't rely on the
- * dictionaries. The regular path is in `internalDomain()`
- */
-export declare function inferNumericDomain(value: number | Decimal | Complex | Rational): string;
+import { DomainLiteral, Rational } from './public';
 /**
- * Simple description of a numeric domain as a base domain, a min and
- * max value, possibly open ends, and some excluded values.
+ * Determine the numeric domain of a number.
  */
-export type NumericDomainInfo = {
-    domain?: string;
-    min?: number;
-    max?: number;
-    open?: 'left' | 'right' | 'both';
-    /** Values from _excludedValues_ are considered not in this domain */
-    excludedValues?: number[];
-    /** If defined, the values in this domain must follow the relation
-     * _period_ * _n_ + _phase_ when _n_ is in _domain_.
-     */
-    multiple?: [period: number, domain: BoxedExpression, phase: number];
-};
+export declare function inferNumericDomain(value: number | Decimal | Complex | Rational): DomainLiteral;

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

@@ -0,0 +1,124 @@
+/* 0.17.0 */
+/***
+ * ## THEORY OF OPERATIONS
+ *
+ * A `["Function"]` expression has its own scope.
+ * This scope includes the parameters and local variables.
+ *
+ * Some expressions with anonymous parameters (e.g. `["Add", "_", 1]`)
+ * are rewritten to a `["Function"]` expression with anonymous parameters
+ * (e.g. `["Function", ["Add", "_", 1], "_"]`).
+ *
+ * The **body** of a `["Function"]` expression may have its own scope
+ * (for example if it's a `["Block"]` expression) or may not have a scope
+ * at all (if it's a number, i.e. `["Function", 1]`). the function body may
+ * be a number, a symbol or (more commonly) an function expression.
+ *
+ *
+ * ### DURING BOXING (in makeLambda())
+ *
+ * During the boxing/canonicalization phase of a function
+ * (`["Function"]` expression or head expression):
+ *
+ * 1/ If not a `["Function"]` expression, the expression is rewritten
+ *    to a `["Function"]` expression with anonymous parameters
+ * 2/ A new scope is created
+ * 3/ The function parameters are declared in the scope
+ * 4/ The function body is boxed in the context of the scope and the scope
+ *    is associated with the function
+ *
+ *
+ * ### DURING EVALUATION (executing the result of makeLambda())
+ *
+ * 1/ The arguments are evaluated in the current scope
+ * 2/ The context is swapped to the function scope
+ * 3/ The values of all the ids in this scope are reset
+ * 4/ The parameters are set to the value of the arguments
+ * 5/ The function body is evaluated in the context of the function scope
+ * 6/ The context is swapped back to the current scope
+ * 7/ The result of the function body is returned
+ *
+ */
+/**
+ * From an expression, create an iterator that can be used
+ * to enumerate values.
+ *
+ * `expr` can be a collection, a function, an expression, a string.
+ *
+ * - ["Range", 5]
+ * - ["List", 1, 2, 3]
+ * - "'hello world'"
+ *
+ */
+export declare function iterable(expr: BoxedExpression): Iterator<BoxedExpression> | undefined;
+/**
+ * indexable(expr) return a JS function with one argument.
+ *
+ * Evaluate expr.
+ * If expr is indexable function (def with at handler), return handler.
+ * Otherwise, call makeLambda, then return function that set scope
+ * with one arg, then evaluate result of makeLambda.
+ */
+export declare function indexable(expr: BoxedExpression): ((index: number) => BoxedExpression | undefined) | undefined;
+/**
+ * From an expression, return a predicate function, which can be used to filter.
+ */
+export declare function predicate(_expr: BoxedExpression): (...args: BoxedExpression[]) => boolean;
+/**
+ * From an expression, create an ordering function, which can be used to sort.
+ */
+export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: BoxedExpression) => -1 | 0 | 1;
+/**
+ * Given an expression, rewrite it to a canonical Function form.
+ *
+ *
+ * - explicit parameters (no change)
+ *      ["Function", ["Add, "x", 1], "x"]
+ *      -> ["Function", ["Add, "x", 1], "x"]
+ *
+ * - single anonymous parameters:
+ *      ["Add", "_", 1]
+ *      -> ["Function", ["Add", "_", 1], "_"]
+ *
+ * - multiple anonymous parameters:
+ *      ["Add", "_1", "_2"]
+ *      -> ["Function", ["Add", "_1", "_2"], "_1", "_2"]
+ *
+ */
+export declare function canonicalFunctionExpression(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply arguments to an expression which is either
+ * - a '["Function"]' expression
+ * - an expression with anonymous parameters, e.g. ["Add", "_", 1]
+ * - the identifier for a function, e.g. "Sin".
+ */
+export declare function apply(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;
+/**
+ * Return a lambda function, assuming a scoped environment has been
+ * created and there is a single numeric argument
+ */
+export declare function makeLambdaN1(expr: BoxedExpression): ((arg: number) => number) | undefined;
+/**
+ * Given an expression such as:
+ * - ["Function", ["Add", 1, "x"], "x"]
+ * - ["Function", ["Divide", "_", 2]]
+ * - ["Multiply, "_", 3]
+ * - ["Add, "_1", "_2"]
+ * - "Sin"
+ *
+ * return a JS function that can be called with arguments.
+ */
+export declare function applicable(fn: BoxedExpression): (args: BoxedExpression[]) => BoxedExpression | undefined;
+/**
+ * Use applicableN when the function is known to be a function of a single
+ * variable and the argument is a number.
+ *
+ * Unlike "apply", applicable returns a function  that can be called
+ * with an argument.
+ *
+ */
+export declare function applicableN1(fn: BoxedExpression): (x: number) => number;
+/**
+ * Give a string like "f(x,y)" return, ["f", ["x", "y"]]
+ */
+export declare function parseFunctionSignature(s: string): [id: string, args: string[] | undefined];

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { WarningSignal } from '../../../common/signals';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';
@@ -19,7 +19,7 @@ export declare class LatexSyntax {
     get dictionary(): readonly LatexDictionaryEntry[];
     set dictionary(val: readonly LatexDictionaryEntry[]);
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
-    static getDictionary(category?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(category?: LibraryCategory | 'all'): readonly Readonly<object>[];
     parse(latex: LatexString): Expression;
     serialize(expr: Expression, options?: {
         canonical?: boolean;

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { Parser } from './public';
 /** For error handling, if we have a identifier prefix, assume
  * the identifier is invalid (it would have been captured by

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.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';

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -19,35 +19,45 @@ export type LatexString = string;
  */
 export type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor';
 export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'complex' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
-/** Theory of operations:
+/**
+ *
+ * ## THEORY OF OPERATIONS
  *
  * The precedence of an operator is a number that indicates the order in which
- * operators are applied. For example, in `1 + 2 * 3`, the `*` operator has
- * a higher precedence than the `+` operator, so it is applied first.
+ * operators are applied.
  *
- * The precendence range from 0 to 1000. The higher the number, the higher the
+ * For example, in `1 + 2 * 3`, the `*` operator has a **higher** precedence
+ * than the `+` operator, so it is applied first.
+ *
+ * The precedence range from 0 to 1000. The larger the number, the higher the
  * precedence, the more "binding" the operator is.
  *
  * Here are some rough ranges for the precedence:
  *
- * - 800: prefix and postfix operators,
- *        e.g. `\lnot`, `!`, `'`, `\degree`, `++`, etc...
- * - 700: some relational operators: `<`
- * - 600: some binary operators: `\div`
+ * - 800: prefix and postfix operators: `\lnot` etc...
+ *    - `POSTFIX_PRECEDENCE` = 810: `!`, `'`
+ * - 700: some arithmetic operators
+ *    - `EXPONENTIATION_PRECEDENCE` = 700: `^`
+ * - 600: some binary operators
+ *    - `DIVISION_PRECEDENCE` = 600: `\div`
  * - 500: not used
  * - 400: not used
  * - 300: some logic and arithmetic operators:
  *        `\land`, `\lor`, `\times`, etc...
+ *   - `MULTIPLICATION_PRECEDENCE` = 390: `\times`
  * - 200: arithmetic operators, inequalities:
- *        `+`, `-`, `=`, `<`, etc...
- *   - 260: `=`
- *   - 245: `\lt`, `\gt`
+ *   - `ADDITION_PRECEDENCE` = 275: `+` `-`
+ *   - `ARROW_PRECEDENCE` = 270: `\to` `\rightarrow`
+ *   - `ASSIGNMENT_PRECEDENCE` = 260: `:=`
+ *   - `COMPARISON_PRECEDENCE` = 245: `\lt` `\gt`
  *   - 241: `\leq`
  * - 100: not used
  * - 0: `,`, `;`, etc...
  *
+ * Some constants are defined below for common precedence values.
+ *
  *
- * Note: MathML defines some operator precendence, but it has some
+ * Note: MathML defines some operator precedence, but it has some
  * issues and inconsistencies. However, whenever possible we adopted the
  * MathML precedence. See https://www.w3.org/TR/2009/WD-MathML3-20090924/appendixc.html
  *
@@ -55,6 +65,14 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence
  */
 export type Precedence = number;
+export declare const COMPARISON_PRECEDENCE: Precedence;
+export declare const ASSIGNMENT_PRECEDENCE: Precedence;
+export declare const ARROW_PRECEDENCE: Precedence;
+export declare const ADDITION_PRECEDENCE: Precedence;
+export declare const MULTIPLICATION_PRECEDENCE: Precedence;
+export declare const DIVISION_PRECEDENCE: Precedence;
+export declare const EXPONENTIATION_PRECEDENCE: Precedence;
+export declare const POSTFIX_PRECEDENCE: Precedence;
 /**
  * This indicates a condition under which parsing should stop:
  * - an operator of a precedence higher than specified has been encountered

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.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,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.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';

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 import { WarningSignalHandler } from '../../common/signals';
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
 import { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.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,10 +1,10 @@
-/* 0.15.0 */
+/* 0.17.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)
  * */
 export declare function canonicalAdd(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
-export declare function domainAdd(_ce: IComputeEngine, args: BoxedDomain[]): BoxedDomain | null;
+export declare function domainAdd(_ce: IComputeEngine, args: (undefined | BoxedDomain)[]): BoxedDomain | null | undefined;
 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;

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.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.15.0 */
+/* 0.17.0 */
 /** The canonical form of `Multiply`:
  * - remove `1`
  * - combine literal integers and rationals

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

@@ -1,4 +1,4 @@
-/* 0.15.0 */
+/* 0.17.0 */
 /**
  *
  */

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

@@ -1,2 +1,3 @@
-/* 0.15.0 */
-export declare const ARITHMETIC_LIBRARY: IdTable[];
+/* 0.17.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.15.0 */
-export declare const CALCULUS_LIBRARY: IdTable[];
+/* 0.17.0 */
+export declare const CALCULUS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
-export declare const COLLECTIONS_LIBRARY: IdTable;
+/* 0.17.0 */
+export declare const COLLECTIONS_LIBRARY: IdentifierDefinitions;

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
-export declare const COMPLEX_LIBRARY: IdTable[];
+/* 0.17.0 */
+export declare const COMPLEX_LIBRARY: IdentifierDefinitions[];

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

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

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

@@ -1,2 +1,2 @@
-/* 0.15.0 */
-export declare const CORE_LIBRARY: IdTable[];
+/* 0.17.0 */
+export declare const CORE_LIBRARY: IdentifierDefinitions[];

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

@@ -1,16 +1,16 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
-    NumericFunction: (string | string[])[];
-    RealFunction: (string | string[])[];
-    TrigonometricFunction: string[];
-    LogicOperator: (string | string[])[];
-    Predicate: (string | string[])[];
-    RelationalOperator: string[];
+    Functions: (string | string[])[];
+    NumericFunctions: (string | string[])[];
+    RealFunctions: (string | string[])[];
+    LogicOperators: (string | string[])[];
+    Predicates: (string | string[])[];
+    RelationalOperators: string[];
 };
 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 domainSetsLibrary(): IdTable;
+export declare function ancestors(dom: DomainLiteral): DomainLiteral[];
+export declare function domainSetsLibrary(): IdentifierDefinitions;

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

@@ -1,8 +1,8 @@
-/* 0.15.0 */
-import { IComputeEngine, IdTable } from '../public';
-export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): Readonly<IdTable>[];
+/* 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]?: Readonly<IdTable> | Readonly<IdTable>[];
+    [category in LibraryCategory]?: IdentifierDefinitions | IdentifierDefinitions[];
 };
 /**
  * Set the symbol table of the current context (`engine.context`) to `table`
@@ -14,4 +14,6 @@ export declare const LIBRARIES: {
  * or function name that has not yet been added to the symbol table.
  *
  */
-export declare function setCurrentContextSymbolTable(engine: IComputeEngine, table: IdTable): void;
+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

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

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

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

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

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

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

@@ -1,2 +1,2 @@
-/* 0.15.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.15.0 */
-export declare const RELOP_LIBRARY: IdTable;
+/* 0.17.0 */
+export declare const RELOP_LIBRARY: IdentifierDefinitions;

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

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

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

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

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

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

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

@@ -1,4 +1,2 @@
-/* 0.15.0 */
-export declare function isSymbolDefinition(def: BoxedSymbolDefinition | BoxedFunctionDefinition | SymbolDefinition | FunctionDefinition | undefined | null): def is BoxedSymbolDefinition;
-export declare function isFunctionDefinition(def: BoxedSymbolDefinition | BoxedFunctionDefinition | SymbolDefinition | FunctionDefinition | undefined | null): def is BoxedFunctionDefinition;
+/* 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.15.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,9 +1,10 @@
-/* 0.15.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;
 export declare function factorial(ce: IComputeEngine, n: Decimal): Decimal;
-export declare function lngamma(ce: IComputeEngine, z: Decimal): Decimal;
+export declare function factorial2(ce: IComputeEngine, n: Decimal): Decimal;
+export declare function gammaln(ce: IComputeEngine, z: Decimal): Decimal;
 export declare function gamma(ce: IComputeEngine, z: Decimal): Decimal;
 /**
  * If the exponent of the bignum is in the range of the exponents

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

@@ -1,3 +1,3 @@
-/* 0.15.0 */
+/* 0.17.0 */
 export declare function gamma(c: Complex): Complex;
-export declare function lngamma(c: Complex): Complex;
+export declare function gammaln(c: Complex): Complex;