@cortex-js/compute-engine 0.6.0 → 0.8.0

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -18,17 +18,15 @@ export declare type LatexString = string;
  * record to define new LaTeX dictionary entries.
  */
 export declare type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor';
-export declare type DictionaryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'combinatorics' | 'core' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'symbols' | 'trigonometry' | 'units';
+export declare type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'core' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
 /**
  * This indicates a condition under which parsing should stop:
- * - a specific string of tokens has been encountered
  * - an operator of a precedence higher than specified has been encountered
  * - the last token has been reached
  * - or if a function is provided, the function returns true;
  */
 export declare type Terminator = {
     minPrec: number;
-    tokens?: LatexToken[];
     condition?: (parser: Parser) => boolean;
 };
 /**
@@ -54,11 +52,13 @@ export declare type Terminator = {
  */
 export declare type EnvironmentParseHandler = (parser: Parser, reqArgs: Expression[], optArgs: Expression[]) => Expression | null;
 export declare type SymbolParseHandler = (parser: Parser) => Expression | null;
+export declare type FunctionParseHandler = (parser: Parser) => Expression | null;
 export declare type PostfixParseHandler = (parser: Parser, lhs: Expression) => Expression | null;
 export declare type PrefixParseHandler = (parser: Parser, until: Terminator) => Expression | null;
 export declare type InfixParseHandler = (parser: Parser, until: Terminator, lhs: Expression) => Expression | null;
 export declare type MatchfixParseHandler = (parser: Parser, body: Expression) => Expression | null;
-export declare type ParseHandler = SymbolParseHandler | EnvironmentParseHandler | PostfixParseHandler | PrefixParseHandler | InfixParseHandler | MatchfixParseHandler;
+export declare type ParseHandler = SymbolParseHandler | FunctionParseHandler | EnvironmentParseHandler | PostfixParseHandler | PrefixParseHandler | InfixParseHandler | MatchfixParseHandler;
+export declare type LatexArgumentType = '{expression}' /** A required math mode expression */ | '[expression]' /** An optional math mode expression */ | '{text}' /** A required expression in text mode */ | '[text]' /** An optional expression in text mode */ | '{unit}' /** A required unit expression, e.g. `3em` */ | '[unit]' /** An optional unit expression, e.g. `3em` */ | '{glue}' /** A required glue expression, e.g. `25 mu plus 3em ` */ | '[glue]' /** An optional glue expression, e.g. `25 mu plus 3em ` */ | '{string}' /** A required text string, terminated by a non-literal token */ | '[string]' /** An optional text string, terminated by a non-literal token */ | '{color}' /** A required color expression, e.g. `red` or `#00ff00` */ | '[color]'; /** An optional color expression, e.g. `red` or `#00ff00` */
 /**
  * Maps a string of LaTeX tokens to a function or symbol and vice-versa.
  *
@@ -163,6 +163,10 @@ export declare type SymbolEntry = BaseEntry & {
     kind: 'symbol';
     /** Used for appropriate wrapping (i.e. when to surround it with parens) */
     precedence?: number;
+    parse: Expression | SymbolParseHandler;
+};
+export declare type FunctionEntry = BaseEntry & {
+    kind: 'function';
     /**
      * Indicate if this symbol can be followed by arguments.
      *
@@ -188,41 +192,21 @@ export declare type SymbolEntry = BaseEntry & {
      * "f x" -> `["f", "x"]`
      *
      */
-    /**
-     *
-     * If a LaTeX command (i.e. the trigger starts with `\`, e.g. `\sqrt`)
-     * indicates the number of optional arguments expected (indicate with
-     * square brackets).
-     *
-     * For example, for the `\sqrt` command, 1: `\sqrt[3]{x}`
-     *
-     */
-    optionalLatexArg?: number;
-    /**
-     *
-     * If a LaTeX command (i.e. the trigger starts with `\`, e.g. `\frac`)
-     * indicates the number of required arguments expected (indicated with
-     * curly braces).
-     *
-     * For example, for the `\frac` command, 2: `\frac{1}{n}`
-     *
-     */
-    requiredLatexArg?: number;
-    parse: Expression | SymbolParseHandler;
+    parse: Expression | FunctionParseHandler;
 };
 /**
  * A simple LaTeX dictionary entry, for example for a command like `\pi`.
  */
 export declare type DefaultEntry = BaseEntry & {
     precedence?: number;
-    optionalLatexArg?: number;
-    requiredLatexArg?: number;
     parse?: Expression | SymbolParseHandler;
 };
-export declare type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | EnvironmentEntry;
+export declare type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | FunctionEntry | EnvironmentEntry;
 /** @internal */
 export declare function isSymbolEntry(entry: LatexDictionaryEntry): entry is SymbolEntry;
 /** @internal */
+export declare function isFunctionEntry(entry: LatexDictionaryEntry): entry is FunctionEntry;
+/** @internal */
 export declare function isMatchfixEntry(entry: LatexDictionaryEntry): entry is MatchfixEntry;
 /** @internal */
 export declare function isInfixEntry(entry: LatexDictionaryEntry): entry is InfixEntry;
@@ -254,7 +238,7 @@ export declare type ParseLatexOptions = {
     /**
      * If true, ignore space characters.
      *
-     * Default: `true`
+     * **Default**: `true`
      *
      */
     skipSpace: boolean;
@@ -273,7 +257,7 @@ export declare type ParseLatexOptions = {
      * Otherwise, return each token making up the number (minus sign, digits,
      * decimal separator, etc...).
      *
-     * Default: `true`
+     * **Default**: `true`
      */
     parseNumbers: boolean;
     /**
@@ -302,6 +286,8 @@ export declare type ParseLatexOptions = {
      * may contain a slightly different LaTeX, for example with consecutive spaces
      * replaced by one, with comments removed and with some low-level LaTeX
      * commands replaced, for example `\egroup` and `\bgroup`.
+     *
+     * **Default:** `false`
      */
     preserveLatex: boolean;
 };
@@ -330,8 +316,8 @@ export declare type SerializeLatexOptions = {
      */
     multiply: LatexString;
     /**
-     * When an expression contains the symbol `Missing`, serialize it
-     * with this LaTeX string
+     * When an expression contains the error expression `["Error", 'missing']`,
+     * serialize it with this LaTeX string
      */
     missingSymbol: LatexString;
     applyFunctionStyle: (expr: Expression, level: number) => 'paren' | 'leftright' | 'big' | 'none';
@@ -353,10 +339,10 @@ export declare type NumberFormattingOptions = {
      * the '.' in '3.1415'.
      *
      * Some countries use a comma rather than a dot. In this case it is
-     * recommended to use `"{,}"` as the marker: the surrounding bracket ensure
+     * recommended to use `"{,}"` as the marker: the surrounding brackets ensure
      * there is no additional gap after the comma.
      *
-     * Default: `"."`
+     * **Default**: `"."`
      */
     decimalMarker: LatexString;
     /**
@@ -365,10 +351,10 @@ export declare type NumberFormattingOptions = {
      *
      * If you change it to another value, be aware that this may lead to
      * unexpected results. For example, if changing it to `,` the expression
-     * `x_{1,2}` will parse as `x` with a subscript of `1.2`, rather than `x`
-     * with two subscripts, `1` and `2`.
+     * `\mathrm{Hypot}(1,2)` will parse as `["Hypot", 1.2]` rather than
+     * `["Hypot", 1, 2]`.
      *
-     * Default: `"\\,"` (thin space, 3/18mu) (Resolution 7 of the 1948 CGPM)
+     * **Default**: `"\\,"` (thin space, 3/18mu) (Resolution 7 of the 1948 CGPM)
      */
     groupSeparator: LatexString;
     exponentProduct: LatexString;
@@ -416,7 +402,7 @@ export declare class LatexSyntax {
      * Use the value returned by this function to the `options` argument of the
      * constructor.
      */
-    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(domain?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
     parse(latex: LatexString): Expression;
     serialize(expr: Expression): LatexString;
 }
@@ -436,7 +422,11 @@ export interface Serializer {
     level: number;
     /** Output a LaTeX string representing the expression */
     serialize: (expr: Expression | null) => string;
-    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none'): string;
+    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none', fence?: string): string;
+    /** A string with the arguments of expr fenced appropriately and separated by
+     * commas.
+     */
+    wrapArguments(expr: Expression): string;
     /** Add a group fence around the expression if it is
      * an operator of precedence less than or equal to `prec`.
      */
@@ -456,7 +446,6 @@ export interface Serializer {
 }
 export declare type SerializeHandler = (serializer: Serializer, expr: Expression) => string;
 export interface Parser {
-    readonly onError: WarningSignalHandler;
     readonly options: Required<ParseLatexOptions>;
     readonly computeEngine?: IComputeEngine;
     index: number;
@@ -478,6 +467,10 @@ export interface Parser {
     latexAfter(): string;
     /** If there are any space, advance the index until a non-space is encountered */
     skipSpace(): boolean;
+    addBoundary(boundary: LatexToken[]): void;
+    removeBoundary(): void;
+    matchBoundary(): boolean;
+    boundaryError(msg: string | [string, ...Expression[]]): Expression;
     /** If the next token is a character, return it and advance the index
      * This includes plain characters (e.g. 'a', '+'...), characters
      * defined in hex (^^ and ^^^^), the `\char` and `\unicode` command.
@@ -497,17 +490,17 @@ export interface Parser {
     match(tokens: LatexToken): boolean;
     matchAll(tokens: LatexToken | LatexToken[]): boolean;
     matchAny(tokens: LatexToken[]): LatexToken;
-    matchWhile(tokens: LatexToken[]): LatexToken[];
+    matchSequence(tokens: LatexToken[]): LatexToken[];
     /** If the next token matches a `+` or `-` sign, return it and advance the index.
      * Otherwise return `''` and do not advance */
-    matchSign(): string;
+    matchOptionalSign(): string;
     matchDecimalDigits(): string;
     matchSignedInteger(): string;
     matchExponent(): string;
     matchNumber(): string;
     /** Parse a tabular environment, until `\end{endName}`
      */
-    matchTabular(endName: string): null | Expression;
+    matchTabular(endName: string): null | Expression[][];
     applyInvisibleOperator(terminator: Terminator, lhs: Expression | null): Expression | null;
     /** If the next tokens correspond to an optional LaTeX argument,
      * enclosed with `[` and `]` return the content of the argument
@@ -516,14 +509,21 @@ export interface Parser {
      * Otherwise, return `null`.
      */
     matchOptionalLatexArgument(): Expression | null;
+    /**
+     * Match a required LaTeX argument:
+     * - either enclosed in `{}`
+     * - or a single token.
+     *
+     * Return null if no argument was found
+     * Return `['Sequence']` if an empty argument `{}` was found
+     */
     matchRequiredLatexArgument(): Expression | null;
     /**
      * - 'enclosure' : will look for an argument inside an enclosure (an open/close fence)
-     * - 'group': arguments follow directly the symbol, until an end of group token `<}>`
      * - '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: '' | 'group' | 'implicit' | 'enclosure'): Expression[] | null;
+    matchArguments(kind: '' | 'implicit' | 'enclosure'): Expression[] | null;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *
@@ -533,6 +533,17 @@ export interface Parser {
      */
     matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): LatexToken[] | null;
     matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
+    /**
+     *  Match a sequence superfix/subfix operator, e.g. `^{*}`
+     *
+     * Superfix and subfix need special handling:
+     *
+     * - they act mostly like an infix operator, but they are commutative, i.e.
+     * `x_a^b` should be parsed identically to `x^b_a`.
+     *
+     * - furthermore, in LaTeX `x^a^b` parses the same as `x^a{}^b`.
+     *
+     */
     matchSupsub(lhs: Expression | null): Expression | null;
     /**
      *
@@ -554,6 +565,12 @@ export interface Parser {
      * If not a primary, return `null` and do not advance the index.
      */
     matchPrimary(): Expression | null;
+    /**
+     * A symbol can be:
+     * - a single-letter variable: `x`
+     * - a single LaTeX command: `\pi`
+     */
+    matchSymbol(): Expression | null;
     /**
      * Parse an expression:
      *
@@ -572,4 +589,6 @@ export interface Parser {
      * `until` is `{ minPrec:0 }` by default.
      */
     matchExpression(until?: Partial<Terminator>): Expression | null;
+    /** Return an error expression with the specified code and arguments */
+    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
 }

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.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,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.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,5 +1,5 @@
-/* 0.6.0 */
-import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
+/* 0.8.0 */
+import { NumberFormattingOptions, LatexString, SerializeLatexOptions, FunctionEntry } from './public';
 import { IndexedLatexDictionary, SymbolEntry } from './dictionary/definitions';
 import { WarningSignalHandler } from '../../common/signals';
 export declare class Serializer {
@@ -19,8 +19,10 @@ export declare class Serializer {
      *
      */
     wrapShort(expr: Expression | null): string;
-    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none'): string;
-    serializeSymbol(expr: Expression, def?: SymbolEntry): string;
+    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none', fence?: string): string;
+    wrapArguments(expr: Expression): string;
+    serializeSymbol(expr: Expression, def?: SymbolEntry | FunctionEntry): string;
+    serializeFunction(expr: Expression, def?: FunctionEntry | SymbolEntry): string;
     serializeDictionary(dict: {
         [key: string]: Expression;
     }): string;

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.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

@@ -0,0 +1,11 @@
+/* 0.8.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 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 evalSummation(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;

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

@@ -0,0 +1,15 @@
+/* 0.8.0 */
+/**
+ * Canonical form of 'Divide' (and 'Rational')
+ * - remove denominator of 1
+ * - simplify the signs
+ * - factor out negate (make the numerator and denominator positive)
+ * - if numerator and denominator are integer literals, return a rational number
+ *   or Rational experssion
+ * - if Divide, transform into Multiply/Power
+ */
+export declare function canonicalDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;
+/**
+ * Simplify form of 'Divide' (and 'Rational')
+ */
+export declare function simplifyDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression | undefined;

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

@@ -0,0 +1,19 @@
+/* 0.8.0 */
+/** The canonical form of `Multiply`:
+ * - remove `1`
+ * - combine literal small 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`
+ *    - `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 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 evalMultiplication(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression, mode: 'simplify' | 'evaluate' | 'N'): BoxedExpression | undefined;

package/dist/types/compute-engine/{dictionary → library}/arithmetic-power.d.ts

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
 /**
  *
  * Return `null` if there is no canonicalization necessary and the result is

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+/* 0.8.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[];
+};
+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[];

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

@@ -0,0 +1,17 @@
+/* 0.8.0 */
+import { IComputeEngine, SymbolTable } from '../public';
+export declare function getStandardLibrary(categories: LibraryCategory[] | LibraryCategory | 'all'): Readonly<SymbolTable>[];
+export declare const LIBRARIES: {
+    [category in LibraryCategory]?: Readonly<SymbolTable> | Readonly<SymbolTable>[];
+};
+/**
+ * Set the symbol table of the current context (`engine.context`) to `table`
+ *
+ * `table` can be an array of symbol tables, in order to deal with circular
+ * dependencies: it is possible to partition a library into multiple
+ * symbol tables, to control the order in which they are processed and
+ * avoid having expressions in the definition of an entry reference a symbol
+ * or function name that has not yet been added to the symbol table.
+ *
+ */
+export declare function setCurrentContextSymbolTable(engine: IComputeEngine, table: SymbolTable): void;

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

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +1,3 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function lngamma(c: Complex): Complex;

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

@@ -1,7 +1,11 @@
-/* 0.6.0 */
+/* 0.8.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 factorial(ce: IComputeEngine, n: Decimal): Decimal;
 export declare function lngamma(ce: IComputeEngine, z: Decimal): Decimal;
 export declare function gamma(ce: IComputeEngine, z: Decimal): Decimal;

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

@@ -1,9 +1,11 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const MACHINE_PRECISION: number;
 export declare const MACHINE_TOLERANCE_BITS = 7;
 export declare const MACHINE_TOLERANCE: number;
 export declare const NUMERIC_TOLERANCE: number;
-export declare const SMALL_INTEGERS = 1000000;
+export declare const SMALL_INTEGER = 1000000;
+export declare const MAX_ITERATION = 1000000;
+export declare const MAX_SYMBOLIC_TERMS = 200;
 /**
  * Returns the smallest floating-point number greater than x.
  * Denormalized values may not be supported.

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

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