# Compute Engine

### interface BoxedBaseDefinitionProperties / Methods

• | string
• | string[]

reset(): any

When the environment changes, for example the numerical precision, call reset() so that any cached values can be recalculated.

### interface BoxedBaseDefinitionscope: undefined | RuntimeScope Permalink

The scope this definition belongs to.

This field is usually undefined, but its value is set by getDefinition()

### Other

is(s: BoxedDomain): boolean

From Object.is(). Equivalent to BoxedExpression.isSame()

isCompatible(dom: string | BoxedDomain, kind?: DomainCompatibility): boolean

True if a valid domain, and compatible with dom

If this is the Nothing symbol, return true.

Note applicable to canonical and non-canonical expressions.

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

### Relational Operator

Extended by BoxedDomain, Pattern

Theory of Operations

The BoxedExpression interface includes most of the member functions applicable to any kind of expression, for example get symbol() or get ops().

When a member function is not applicable to this BoxedExpression, for example get symbol() on a BoxedNumber, it returns null.

This convention makes it convenient to manipulate expressions without having to check what kind of instance they are before manipulating them.

### Dictionary Expression

getKey(key: string): undefined | BoxedExpression

If this expression is a dictionary, return the value of the key entry.

If this expression is a dictionary, return true if the dictionary has a key entry.

• | null
• | IterableIterator<string>

The keys of the dictionary.

If this expression not a dictionary, return null

### interface BoxedExpressionisAlgebraic: undefined | boolean Permalink

The value of this expression is a number that is the root of a non-zero univariate polynomial with rational coefficients.

All integers and rational numbers are algebraic.

Transcendental numbers, such as $$\pi$$ or $$e$$ are not algebraic.

### interface BoxedExpressionisComplex: undefined | boolean Permalink

The value of this expression is a number, but not NaN or any Infinity

isReal || isImaginary

### interface BoxedExpressionisExtendedComplex: undefined | boolean Permalink

isReal || isImaginary || isInfinity

### interface BoxedExpressionisExtendedReal: undefined | boolean Permalink

Real or ±Infinity

isReal || isInfinity

### interface BoxedExpressionisImaginary: undefined | boolean Permalink

The value of this expression is a number with a imaginary part

### interface BoxedExpressionisInteger: undefined | boolean Permalink

The value of this expression is an element of the set ℤ: …,-2, -1, 0, 1, 2…

### interface BoxedExpressionisNumber: undefined | boolean Permalink

true if the value of this expression is a number.

isExtendedComplex || isNaN = isReal || isImaginary || isInfinity || isNaN

Note that in a fateful twist of cosmic irony, NaN (“Not a Number”) is a number.

### interface BoxedExpressionisRational: undefined | boolean Permalink

The value of this expression is an element of the set ℚ, p/q with p ∈ ℕ, q ∈ ℤ ⃰ q >= 1

Note that every integer is also a rational.

### interface BoxedExpressionisReal: undefined | boolean Permalink

The value of this expression is real number: finite and not imaginary.

isFinite && !isImaginary

### interface BoxedExpressionisFinite: undefined | boolean Permalink

This expression is a number, but not ±Infinity and not NaN

### interface BoxedExpressionisInfinity: undefined | boolean Permalink

The numeric value of this expression is ±Infinity or Complex Infinity

### interface BoxedExpressionisNaN: undefined | boolean Permalink

“Not a Number”.

A value representing undefined result of computations, such as 0/0, as per the floating point format standard IEEE-754.

Note that if isNaN is true, isNumber is also true (yes, NaN is a number).

### interface BoxedExpressionisNegative: undefined | boolean Permalink

The numeric value of this expression is < 0, same as isLess(0)

### interface BoxedExpressionisNegativeOne: undefined | boolean Permalink

The numeric value of this expression is not -1.

### interface BoxedExpressionisNonNegative: undefined | boolean Permalink

The numeric value of this expression is >= 0, same as isGreaterEqual(0)

### interface BoxedExpressionisNonPositive: undefined | boolean Permalink

The numeric value of this expression is <= 0, same as isLessEqual(0)

### interface BoxedExpressionisNotZero: undefined | boolean Permalink

The numeric value of this expression is not 0.

### interface BoxedExpressionisOne: undefined | boolean Permalink

The numeric value of this expression is not 1.

### interface BoxedExpressionisPositive: undefined | boolean Permalink

The numeric value of this expression is > 0, same as isGreater(0)

### interface BoxedExpressionisZero: undefined | boolean Permalink

The numeric value of this expression is 0.

### Function Expression

If this expression is a function, the number of operands, otherwise 0.

Note that a function can have 0 operands, so to check if this expression is a function, check if this.ops !== null instead.

Note applicable to canonical and non-canonical expressions.

First operand, i.e.this.ops[0]

Note applicable to canonical and non-canonical expressions.

Second operand, i.e.this.ops[1]

Note applicable to canonical and non-canonical expressions.

Third operand, i.e. this.ops[2]

Note applicable to canonical and non-canonical expressions.

The list of arguments of the function, its “tail”.

If the expression is not a function, return null.

Note applicable to canonical and non-canonical expressions.

### Numeric Expression

• | null
• | number
• | Decimal
• | Complex
• | Rational

Return the value of this expression, if a number literal.

Note it is possible for numericValue to be null, and for isNotZero to be true. For example, when a symbol has been defined with an assumption.

• | undefined
• | null
• | 0
• | 1
• | -1

Return the following, depending on the value of this expression:

• -1 if it is < 0
• 0 if it is = 0
• +1 if it is > 0
• undefined this value may be positive, negative or zero. We don’t know right now (a symbol with an Integer domain, but no currently assigned value, for example)
• null this value will never be positive, negative or zero (NaN, a string or a complex number for example)

Note that complex numbers have no natural ordering, so if the value is a complex number, sgn is either 0, or null

If a symbol, this does take assumptions into account, that is this.sgn will return 1 if isPositive is true, even if this expression has no value

### interface BoxedExpressionstring: null | string Permalink

If this expression is a string, return the value of the string. Otherwise, return null.

Note applicable to canonical and non-canonical expressions.

### Symbol Expression

true if this expression or any of its subexpressions is an ["Error"] expression.

Note applicable to canonical and non-canonical expressions. For non-canonical expression, this may indicate a syntax error while parsing LaTeX. For canonical expression, this may indicate argument domain mismatch, or missing or unexpected arguments.

### interface BoxedExpressionsymbol: null | string Permalink

If this expression is a symbol, return the name of the symbol as a string. Otherwise, return null.

Note applicable to canonical and non-canonical expressions.

### Other

N(options?: NOptions): BoxedExpression

Return a numeric approximation of the canonical form of this expression.

Any necessary calculations, including on decimal numbers (non-integers), are performed.

The calculations are performed according to the numericMode and precision properties of the ComputeEngine.

To only perform exact calculations, use this.evaluate() instead.

If the function is not numeric, the result of this.N() is the same as this.evaluate().

The result is in canonical form.

apply(fn: (x: BoxedExpression): SemiBoxedExpression, head?: string): 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.

### interface BoxedExpressionbasedDefinition: undefined | BoxedBaseDefinition Permalink

For symbols and functions, a possible definition associated with the expression. basedDefinition is the base class of symbol and function definition.

Note undefined if not a canonical expression.

### interface BoxedExpressioncomplexity: undefined | number Permalink

Expressions with a higher complexity score are sorted first in commutative functions

Note undefined if not a canonical expression.

• | undefined
• | string[]

An optional short description if the symbol or function head.

May include markdown. Each string is a paragraph.

Note undefined if not a canonical expression.

The Compute Engine associated with this expression provides a context in which to interpret it, such as definition of symbols and functions.

All the ["Error"] subexpressions

Note applicable to canonical and non-canonical expressions.

evaluate(options?: EvaluateOptions): BoxedExpression

Return the value of the canonical form of this expression.

A pure expression always return the same value and has no side effects. If expr.isPure is true, expr.value and expr.evaluate() are synonyms.

For an impure expression, expr.value is undefined.

Evaluating an impure expression may have some side effects, for example modifying the ComputeEngine environment, such as its set of assumptions.

Only exact calculations are performed, no approximate calculations on decimal numbers (non-integer numbers). Constants, rational numbers and square root of rational numbers are preserved.

To perform approximate calculations, use expr.N() instead.

The result of expr.evaluate() may be the same as expr.simplify().

The result is in canonical form.

### interface BoxedExpressionexplicitDomain: undefined | BoxedDomain Permalink

The domain of this expression, without accounting for any inferred domain or ce.defaultDomain. If no domain has been explicitly set via assignment or via an .assume() directive, the expr.explicitDomain is undefined.

This is useful to determine if the domain of an expression is inferred.

In most cases you’ll want to use expr.domain instead.

Note undefined if not a canonical expression or not a function.

All the free variables in the expression, recursively, that is all the symbols with no value

### interface BoxedExpressionfunctionDefinition: undefined | BoxedFunctionDefinition Permalink

For functions, a possible definition associated with the expression.

Note undefined if not a canonical expression or not a function.

All the subexpressions matching the head

Note applicable to canonical and non-canonical expressions.

has(v: string | string[]): boolean

True if the expression includes a symbol v or a function head v.

Note applicable to canonical and non-canonical expressions.

All boxed expressions have a head.

If not a function this can be Symbol, String, Number or Dictionary.

If the head expression can be represented as a string, it is returned as a string.

Note applicable to canonical and non-canonical expressions. The head of a non-canonical expression may be different than the head of its canonical counterpart. For example the canonical counterpart of ["Divide", 5, 7] is ["Rational", 5, 5].

True if the expression is a constant, that is a symbol with an immutable value

An exact value is not further transformed when evaluated. To get an approximate evaluation of an exact value, use .N().

Non-exact values includes:

• numbers with a fractional part
• complex numbers with a real or imaginary fractional part

True if the expression is a free variable, that is a symbol with no value

If this is the Nothing symbol, return true.

Note applicable to canonical and non-canonical expressions.

If true, the value of the expression never changes and evaluating it has no side-effects. If false, the value of the expression may change, if the value of other expression changes or for other reasons.

If this.isPure is false, this.value is undefined. Call this.evaluate() to determine the value of the expression instead.

As an example, the Random function is not pure.

Note applicable to canonical and non-canonical expressions.

MathJSON representation of this expression.

Note applicable to canonical and non-canonical expressions.

Attempt to match this expression to the rhs expression.

If rhs does not match, return null.

Otherwise return an object literal.

If this expression includes wildcards (symbols with a name that starts with _), the object literal will include a prop for each matching named wildcard.

If rhs matches this pattern but there are no named wildcards, return the empty object literal, {}.

Note applicable to canonical and non-canonical expressions.

replace(rules: BoxedRuleSet, options?: ReplaceOptions): null | BoxedExpression

Transform the expression by applying the rules: if the lhs of a rule matches, it is replaced by its rhs.

If no rules apply, return null.

See also subs for a simple substitution.

Note applicable to canonical and non-canonical expressions.

### interface BoxedExpressionscope: null | RuntimeScope Permalink

The scope in which this expression has been defined. Is null when the expression is not canonical.

simplify(options?: {recursive: boolean; rules: BoxedRuleSet}): BoxedExpression

Return a simpler form of the canonical form of this expression.

A series of rewriting rules are applied repeatedly, until no more rules apply.

If a custom simplify handler is associated with this function definition, it is invoked.

The values assigned to symbols and the assumptions about symbols may be used, for example arg.isInteger or arg.isPositive.

No calculations involving decimal numbers (numbers that are not integers) are performed but exact calculations may be performed, for example:

$$\sin(\frac{\pi}{4}) \longrightarrow \frac{\sqrt{2}}{2}$$.

The result is in canonical form.

solve(vars: Iterable<string>): null | BoxedExpression[]

All the subexpressions in this expression, recursively

Note applicable to canonical and non-canonical expressions.

subs(sub: Substitution<SemiBoxedExpression>, options?: {canonical: boolean}): BoxedExpression

Replace all the symbols in the expression as indicated.

Note the same effect can be achieved with this.replace(), but using this.subs() is more efficient, and simpler.

Note applicable to canonical and non-canonical expressions.

### interface BoxedExpressionsymbolDefinition: undefined | BoxedSymbolDefinition Permalink

For symbols, a possible definition associated with the expression.

Note undefined if not a symbol

All the symbols in the expression, recursively

Note applicable to canonical and non-canonical expressions.

### interface BoxedExpressionurl: undefined | string Permalink

Note undefined if not a canonical expression.

Return the canonical form of this expression.

If this is a function expressin, a definition is associated with the canonical expression.

When determining the canonical form the following function definition flags are applied:

• associative: $$f(a, f(b), c) \longrightarrow f(a, b, c)$$
• idempotent: $$f(f(a)) \longrightarrow f(a)$$
• involution: $$f(f(a)) \longrightarrow a$$
• commutative: sort the arguments.

If his expression is already canonical, the value of canonical is this.

get domain(): BoxedDomain

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 symbol the domain of the value of the symbol.

Use expr.head to determine if an expression is a symbol or function.

Note: If non-canonical, return the domain of its canonical counterpart

Modify the domain of a symbol that represent a variable (or a function name).

Note: If non-canonical, does nothing.

If true, this expression is in a canonical form.

Note applicable to canonical and non-canonical expressions.

LaTeX representation of this expression.

The serialization can be customized with ComputeEngine.latexOptions

Note applicable to canonical and non-canonical expressions.

get value(): undefined | BoxedExpression
set value(undefined | number | BoxedExpression)

Synonym for evaluate(). If the expression is pure, the value may be cached.

It returns undefined for expressions that are not pure or that may not be evaluated.

Note: If non-canonical, return the value of its canonical counterpart

Only the value of variables can be changed (symbols that are not constants).

Note: If non-canonical, does nothing.

### interface BoxedExpressionwikidata: undefined | string Permalink

Wikidata identifier.

Note undefined if not a canonical expression.

### Primitive Methods

[toPrimitive](hint: "string" | "number" | "default"): null | string | number

Similar toexpr.valueOf() but includes a hint.

is(rhs: unknown): boolean

From Object.is(). Equivalent to BoxedExpression.isSame()

toJSON(): Expression

Used by JSON.stringify() to serialize this object to JSON.

Method version of expr.json.

toString(): string

From Object.toString(), return a LaTeX representation of the expression.

Used when coercing a BoxedExpression to a String.

valueOf(): string | number | boolean

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.

If the expression is a symbol, return the name of the symbol as a string.

Otherwise return a LaTeX representation of the expression.

### Relational Operator

isEqual(rhs: BoxedExpression): boolean

Mathematical equality (strong equality), that is the value of this expression and of rhs are numerically equal.

The numeric value of both expressions are compared.

Numbers whose difference is less than engine.tolerance are considered equal. This tolerance is set when the engine.precision is changed to be such that the last two digits are ignored.

isGreater(rhs: BoxedExpression): undefined | boolean

The numeric value of both expressions are compared.

isGreaterEqual(rhs: BoxedExpression): undefined | boolean

The numeric value of both expressions are compared.

isLess(rhs: BoxedExpression): undefined | boolean

If the expressions cannot be compared, return undefined

The numeric value of both expressions are compared.

isLessEqual(rhs: BoxedExpression): undefined | boolean

The numeric value of both expressions are compared.

isSame(rhs: BoxedExpression): boolean

Structural/symbolic equality (weak equality).

ce.parse('1+x').isSame(ce.parse('x+1')) is false

Note applicable to canonical and non-canonical expressions.

### interface BoxedSymbolDefinitionProperties / Methods

at(index: string | number): undefined | BoxedExpression

### interface BoxedSymbolDefinitiondomain: undefined | BoxedDomain Permalink

get value(): undefined | BoxedExpression
set value(undefined | SemiBoxedExpression)

expressions: null | Set<BoxedExpression>
highwaterMark: number
symbols: Set<BoxedExpression>

[iterator](): IterableIterator<[BoxedExpression, U]>
clear(): void
delete(expr: BoxedExpression): void
get(expr: BoxedExpression): undefined | U
has(expr: BoxedExpression): boolean
set(expr: BoxedExpression, value: U): void

To customize the parsing and serializing of LaTeX syntax, create a LatexSyntax instance.

new LatexSyntax(options?: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions & {dictionary: LatexDictionary; onError: WarningSignalHandler}): LatexSyntax

### class LatexSyntaxMethods / Properties

getDictionary(domain?: LibraryCategory | "all"): readonly LatexDictionaryEntry[]

Return a LaTeX dictionary suitable for the specified category, or "all" for all categories ("arithmetic", "algebra", etc…).

A LaTeX dictionary is needed to translate between LaTeX and MathJSON.

Each entry in the dictionary indicate how a LaTeX token (or string of tokens) should be parsed into a MathJSON expression.

For example an entry can define that the \pi LaTeX token should map to the symbol "Pi", or that the token - should map to the function ["Negate",...] when in a prefix position and to the function ["Subtract", ...] when in an infix position.

Furthermore, the information in each dictionary entry is used to serialize the LaTeX string corresponding to a MathJSON expression.

Use the value returned by this function to the options argument of the constructor.

parse(latex: string): Expression

serialize(expr: Expression): string

### interface ParserProperties / Methods

applyInvisibleOperator(terminator: Terminator, lhs: null | Expression): null | Expression

True if the last token has been reached

atTerminator(t: Terminator): boolean

Return true if the terminator condition is met

boundaryError(msg: string | [string, ...Expression[]]): Expression

error(code, fromToken)
code:
• | string
• | [string, ...Expression[]]
fromToken: number
Expression

Return an error expression with the specified code and arguments

latexAfter(): string

Return a LaTeX string after the index

latexBefore(): string

Return a LaTeX string before the index

Return an array of string corresponding to tokens ahead. The index is unchanged.

match(tokens: string): boolean

If the next token matches the target advance and return true. Otherwise return false

matchAll(tokens: string | string[]): boolean

matchAny(tokens: string[]): string

matchArguments(kind: "" | "implicit" | "enclosure"): null | Expression[]
• ‘enclosure’ : will look for an argument inside an enclosure (an open/close fence)
• ‘implicit’: either an expression inside a pair of (), or just a primary (i.e. we interpret \cos x + 1 as \cos(x) + 1)

matchBoundary(): boolean

matchChar(): null | string

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.

matchColor(background?: boolean): null | string

Return a CSS color. Handle the various color formats supported by the xcolor package.

matchDecimalDigits(): string

matchExponent(): string

matchExpression(until?: Partial<Terminator>): null | Expression

Parse an expression:

<expression> ::=
| <prefix-op> <expression>
| <primary>
| <primary> <infix-op> <expression>


This is the top-level parsing entry point.

Stop when an operator of precedence less than until.minPrec or the sequence of tokens until.tokens is encountered

until is { minPrec:0 } by default.

matchLatexDimension(): null | string

Return a LaTeX dimension.

matchMiddleDelimiter(delimiter: string): boolean

matchNumber(): string

matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): null | string[]

If matches the normalized open delimiter, returns the expected closing delimiter.

For example, if openDelim is (, and closeDelim is ) it would match \left\lparen and return ['\right', '\rparen'], which can be matched with matchAll()

matchOptionalLatexArgument(): null | Expression

If the next tokens correspond to an optional LaTeX argument, enclosed with [ and ] return the content of the argument as an expression and advance the index past the closing ].

Otherwise, return null.

matchOptionalSign(): string

If the next token matches a + or - sign, return it and advance the index. Otherwise return '' and do not advance

matchPrimary(): null | Expression
   <primary> :=
(<number> | <symbol> | <latex-command> | <function-call> | <matchfix-expr>)
(<subsup> | <postfix-operator>)*

   <matchfix-expr> :=
<matchfix-op-open> <expression> <matchfix-op-close>

   <function-call> ::=
| <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>


If not a primary, return null and do not advance the index.

matchRequiredLatexArgument(excluding?: string[]): null | Expression

Match a required LaTeX argument:

• either enclosed in {}
• or a single token (except if token is in excluding)

The excluding option is useful to fail early when encountering a likely syntax error, for example x^(2) (instead of x^{2}). With ( in the list of excluded tokens, the match will fail and the error can be recovered.

If none is provided, excluding is !"#$%&(),/;:[email protected][]|~", \left and \bigl Return null if no argument was found Return ['Sequence'] if an empty argument {} was found ### interface ParsermatchSequence() Permalink matchSequence(tokens: string[]): string[] ### interface ParsermatchSignedInteger() Permalink matchSignedInteger(): string ### interface ParsermatchStringArgument() Permalink matchStringArgument(): null | string ### interface ParsermatchSupsub() Permalink matchSupsub(lhs: null | Expression): null | Expression 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. ### interface ParsermatchSymbol() Permalink matchSymbol(): null | Expression A symbol can be: • a single-letter variable: x • a single LaTeX command: \pi ### interface ParsermatchTabular() Permalink matchTabular(endName: string): null | Expression[][] Parse a tabular environment, until \end{endName} ### interface Parsernext() Permalink next(): string Return the next token and advance the index ### interface Parseroptions: Required<ParseLatexOptions> Permalink ### interface Parserpeek: string Permalink Return the next token, without advancing the index ### interface ParserremoveBoundary() Permalink removeBoundary(): void ### interface ParserskipSpace() Permalink skipSpace(): boolean If there are any space, advance the index until a non-space is encountered ## interface Pattern Permalink ### interface PatternProperties / Methods #### Dictionary Expression #### Domain Properties #### Expression Properties #### Function Expression #### Numeric Expression #### String Expression #### Symbol Expression #### Other #### Primitive Methods #### Relational Operator ### Dictionary Expression ### Domain Properties ### Expression Properties ### Function Expression ### Numeric Expression ### String Expression ### Symbol Expression ### Other ### interface Patterncount() Permalink count(exprs: Iterable<BoxedExpression>, options?: PatternMatchOptions): number Return the number of exprs that matched the pattern ### interface Patterntest() Permalink test(expr: BoxedExpression, options?: PatternMatchOptions): boolean If expr matches the pattern, return true, otherwise false ### Primitive Methods ### Relational Operator ## interface Serializer Permalink ### interface SerializerProperties / Methods ### interface SerializerapplyFunctionStyle() Permalink applyFunctionStyle(expr: Expression, level: number): "paren" | "leftright" | "big" | "none" Styles ### interface SerializerfractionStyle() Permalink fractionStyle(expr: Expression, level: number): "quotient" | "inline-solidus" | "nice-solidus" | "reciprocal" | "factor" ### interface SerializergroupStyle() Permalink groupStyle(expr: Expression, level: number): "paren" | "leftright" | "big" | "none" ### interface Serializerlevel: number Permalink “depth” of the expression: • 0 for the root • 1 for the arguments of the root • 2 for the arguments of the arguments of the root • etc… This allows for variation of the LaTeX serialized based on the depth of the expression, for example using \Bigl( for the top level, and \bigl( or ( for others. ### interface SerializerlogicStyle() Permalink logicStyle(expr: Expression, level: number): "boolean" | "word" | "uppercase-word" | "punctuation" ### interface SerializernumericSetStyle() Permalink numericSetStyle(expr: Expression, level: number): "compact" | "regular" | "interval" | "set-builder" ### interface SerializeronError: WarningSignalHandler Permalink ### interface Serializeroptions: Required<SerializeLatexOptions> Permalink ### interface SerializerpowerStyle() Permalink powerStyle(expr: Expression, level: number): "quotient" | "solidus" | "root" ### interface SerializerrootStyle() Permalink rootStyle(expr: Expression, level: number): "radical" | "quotient" | "solidus" ### interface Serializerserialize() Permalink serialize(expr: null | Expression): string Output a LaTeX string representing the expression ### interface Serializerwrap() Permalink wrap(expr: null | Expression, prec?: number): string Add a group fence around the expression if it is an operator of precedence less than or equal to prec. ### interface SerializerwrapArguments() Permalink wrapArguments(expr: Expression): string A string with the arguments of expr fenced appropriately and separated by commas. ### interface SerializerwrapShort() Permalink wrapShort(expr: null | Expression): string Add a group fence around the expression if it is short (not a function) ### interface SerializerwrapString() Permalink wrapString(s, style, fence?) s: string style: • | "paren" • | "leftright" • | "big" • | "none" fence?: string string ### version Permalink version: "" ### module compute-engineTypes ### AssumeResult Permalink • | "internal-error" • | "not-a-predicate" • | "contradiction" • | "tautology" • | "ok" ### BaseDefinition Permalink description: string | string[]; A short (about 1 line) description. May contain Markdown. url: string; A URL pointing to more information about this symbol or head. wikidata: string; A short string representing an entry in a wikibase. For example Q167 is the wikidata entry for the Pi constant. ### BaseEntry Permalink Maps a string of LaTeX tokens to a function or symbol and vice-versa. name: string; Map a MathJSON function or symbol name to this entry. Each entry should have at least a name or a parse handler. An entry with no name cannot be serialized: the name is used to map a MathJSON function or symbol name to the appropriate entry for serializing. However, an entry with no name can be used to define a synonym (for example for the symbol \varnothing which is a synonym for \emptyset). If not parse handler is provided, only the trigger is used to select this entry. Otherwise, if the trigger of the entry matches the current token, the parse handler is invoked. serialize: LatexString | SerializeHandler; Transform an expression into a LaTeX string. If no serialize handler is provided, the trigger property is used trigger: LatexString | LatexToken[]; The trigger is the set of tokens that will make this record eligible for attempting to parse the stream and generate an expression. After the trigger matches, the parse handler is called, if available. matchfix operators use openDelimiter and closeDelimiter instead. ### BoxedFunctionDefinition Permalink ### BoxedFunctionSignature Permalink codomain: BoxedDomain | (ce: IComputeEngine, args: BoxedExpression[]): BoxedDomain | null; domain: BoxedDomain; evaluate: BoxedExpression | (ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression | undefined; N?: (ce: IComputeEngine, args: BoxedExpression[]): undefined | BoxedExpression; canonical?: (ce: IComputeEngine, args: BoxedExpression[]): null | BoxedExpression; compile?: (expr: BoxedExpression): CompiledExpression; evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression; sgn?: (ce: IComputeEngine, args: BoxedExpression[]): undefined | 0 | 1 | -1; simplify?: (ce: IComputeEngine, args: BoxedExpression[]): undefined | BoxedExpression; ### BoxedRule Permalink [lhs: Pattern, rhs: BoxedExpression, priority: number, condition: undefined | (wildcards: BoxedSubstitution): boolean] ### BoxedRuleSet Permalink ### BoxedSubstitution Permalink ### CompiledExpression Permalink evaluate?: (scope: {[symbol: string]: BoxedExpression}): number | BoxedExpression; ### DefaultEntry Permalink A simple LaTeX dictionary entry, for example for a command like \pi. ### Delimiter Permalink Open and close delimiters that can be used with MatchfixEntry record to define new LaTeX dictionary entries. • | ")" • | "(" • | "]" • | "[" • | "{" • | "}" • | "<" • | ">" • | "|" • | "||" • | "\lceil" • | "\rceil" • | "\lfloor" • | "\rfloor" ### DomainCompatibility Permalink • | "covariant" • | "contravariant" • | "bivariant" • | "invariant" ### DomainConstructor Permalink A domain constructor is the head of a domain expression. • | "Error" • | "Matrix" • | "SquareMatrix" • | "Vector" • | "Function" • | "List" • | "Dictionary" • | "Tuple" • | "Range" • | "Interval" • | "Intersection" • | "Union" • | "Maybe" • | "Sequence" • | "Head" • | "Symbol" • | "Value" • | "Covariant" • | "Contravariant" • | "Bivariant" • | "Invariant" ### DomainExpression Permalink <T> = ### DomainLiteral Permalink string ### EnvironmentEntry Permalink A LaTeX dictionary entry for an environment, that is a LaTeX construct using \begin{...}...\end{...}. ### EnvironmentParseHandler Permalink (parser: Parser, reqArgs: Expression[], optArgs: Expression[]): Expression | null ### FunctionDefinition Permalink Definition record for a function. • BaseDefinition & • Partial<FunctionDefinitionFlags> & • complexity: number; A number used to order arguments. Argument with higher complexity are placed after arguments with lower complexity when ordered canonically in commutative functions. • Additive functions: 1000-1999 • Multiplicative functions: 2000-2999 • Root and power functions: 3000-3999 • Log functions: 4000-4999 • Trigonometric functions: 5000-5999 • Hypertrigonometric functions: 6000-6999 • Special functions (factorial, Gamma, …): 7000-7999 • Collections: 8000-8999 • Inert and styling: 9000-9999 • Logic: 10000-10999 • Relational: 11000-11999 Default: 100,000 hold: "none" | "all" | "first" | "rest" | "last" | "most"; • "none" Each of the arguments is evaluated (default) • "all" None of the arguments are evaluated and they are passed as is • "first" The first argument is not evaluated, the others are • "rest" The first argument is evaluated, the others aren’t • "last": The last argument is not evaluated, the others are • "most": All the arguments are evaluated, except the last one Default: "none" signature: FunctionSignature; ### FunctionDefinitionFlags Permalink A function definition can have some flags to indicate specific properties of the function. associative: boolean; If true, ["f", ["f", a], b] simplifies to ["f", a, b] Default: false commutative: boolean; If true, ["f", a, b] equals ["f", b, a]. The canonical version of the function will order the arguments. Default: false idempotent: boolean; If true, ["f", ["f", x]] simplifies to ["f", x]. Default: false inert: boolean; An inert function evaluates directly to one of its argument, typically the first one. They may be used to provide formating hints, but do not affect simplification or evaluation. Default: false involution: boolean; If true, ["f", ["f", x]] simplifies to x. Default: false numeric: boolean; All the arguments of a numeric function are numeric, and its value is numeric. pure: boolean; If true, the value of this function is always the same for a given set of arguments and it has no side effects. An expression using this function is pure if the function and all its arguments are pure. For example Sin is pure, Random isn’t. This information may be used to cache the value of expressions. Default: true threadable: boolean; If true, the function is applied element by element to lists, matrices (["List"] or ["Tuple"] expressions) and equations (relational operators). Default: false ### FunctionEntry Permalink • BaseEntry & • kind: "function"; parse: Expression | FunctionParseHandler; Indicate if this symbol can be followed by arguments. The presence of arguments will indicate that the arguments should be applied to the symbol. Otherwise, the invisible operator is applied to the symbol and the arguments. If arguments is "group": “f(x)” -> ["f", "x"] “f x” -> ["Multiply", "f", "x"] If arguments is "": “f(x)” -> ["Multiply", "f", "x"] “f x” -> ["Multiply", "f", "x"] If arguments is "implicit" and the symbol is followed either by a group or by a primary (prefix + symbol + subsupfix + postfix). Used for trig functions. i.e. \sin x vs \sin(x): “f(x)” -> ["f", "x"] “f x” -> ["f", "x"] ### FunctionParseHandler Permalink (parser: Parser): Expression | null ### FunctionSignature Permalink domain: BoxedDomain | DomainExpression; The domain of this signature, a domain compatible with the Function domain) evaluate: SemiBoxedExpression | (ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression | undefined; Evaluate symbolically a function expression. The arguments have been symbolically evaluated, except the arguments to which a hold apply. It is not necessary to further simplify or evaluate the arguments. If performing numerical calculations, if all the arguments are exact, return an exact expression. If any of the arguments is not exact, that is if it is a literal decimal (non-integer) number, return an approximation. In this case, the value may be the same as expr.N(). When doing an exact calculation: • do not reduce rational numbers to decimal (floating point approximation) • do not down convert bignums to machine numbers • do not reduce square roots of rational numbers • do not reduce constants with a hold attribute If the expression cannot be evaluated, due to the values, domains, or assumptions about its arguments, for example, return undefined or an ["Error"] expression. N?: (ce: IComputeEngine, args: BoxedExpression[]): undefined | BoxedExpression; Evaluate numerically a function expression. The arguments args have been simplified and evaluated, numerically if possible, except the arguments to which a hold apply. The arguments may be a combination of numbers, symbolic expressions and other expressions. Perform as many calculations as possible, and return the result. Return undefined if there isn’t enough information to perform the evaluation, for example one of the arguments is a symbol with no value. If the handler returns undefined, symbolic evaluation of the expression will be returned instead to the caller. Return NaN if there is enough information to perform the evaluation, but a literal argument is out of range or not of the expected type. Note that regardless of the current value of ce.numericMode, the arguments may be boxed numbers representing machine numbers, bignum numbers, complex numbers, rationals or big rationals. Use the value of ce.numericMode to determine how to perform the numeric evaluation. If the numeric mode does not allow complex numbers (the engine.numericMode is not "complex" or "auto") and the result of the evaluation would be a complex number, return NaN instead. If ce.numericMode is "bignum" or "auto" the evaluation should be done using bignums. Otherwise, ce.numericMode is “machine”, the evaluation should be performed using machine numbers. You may perform any necessary computations, including approximate calculations on floating point numbers. canonical?: (ce: IComputeEngine, args: BoxedExpression[]): null | BoxedExpression; Return the canonical form of the expression with the arguments args. The arguments (args) may not be in canonical form. If necessary, they 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. If the domain of an argument is not compatible, it should be indicated with a incompatible-domain error. ["Sequence"] expressions are not folded and need to be handled explicitly. If the function is associative, idempotent or an involution, this handler should account for it. Notably, if it is commutative, the 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). Values of symbols should not be substituted. The handler should not consider the value or any assumptions about any of the arguments that are symbols or functions (i.e. arg.isZero, arg.isInteger, etc…) since those may change over time. The result of the handler should be a canonical expression. If the arguments do not match, they should be replaced with an appropriate ["Error"] expression. If the expression cannot be put in canonical form, the handler should return null. codomain?: (ce: IComputeEngine, args: BoxedDomain[]): null | BoxedDomain; An optional handler to determine the codomain of the function. If not provided, the codomain of the function is determined from domain compile?: (expr: BoxedExpression): CompiledExpression; Return a compiled (optimized) expression. evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression; experimental Dimensional analysis sgn?: (ce: IComputeEngine, args: BoxedExpression[]): undefined | 0 | 1 | -1; Return the sign of the function expression. simplify?: (ce: IComputeEngine, args: BoxedExpression[]): undefined | BoxedExpression; Rewrite an expression into a simpler form. The arguments are in canonical form and have been simplified. The handler can use the values assigned to symbols and the assumptions about symbols, for example with arg.numericValue, arg.isInteger or arg.isPositive. Even though a symbol may not have a value, there may be some information about it reflected for example in this.isZero or this.isPrime. The handler should not perform approximate numeric calculations, such as calculations involving decimal numbers (non-integers). Making exact calculations on integers or rationals is OK. This handler should not have any side-effects: do not modify the environment of the ComputeEngine instance, do not perform I/O, do not do calculations that depend on random values. If no simplification can be performed due to the values, domains or assumptions about its arguments, for example, return undefined. ### IdTable Permalink An ID table contains definitions for symbols and functions. The index of the table is an identifier, the name of the symbol or function for this definition The name of a symbol or function is an arbitrary string of Unicode characters, however the following conventions are recommended: • Use only letters, digits and -: /[a-zA-Z0-9-]+/ • The first character should be a letter: /^[a-zA-Z]/ • Functions and symbols exported from a library should start with an uppercase letter /^[A-Z]/ ### InfixEntry Permalink • BaseEntry & • associativity: "right" | "left" | "non" | "both"; • both: a + b + c +(a, b, c) • left: a / b / c -> /(/(a, b), c) • right: a = b = c -> =(a, =(b, c)) • non: a < b < c -> syntax error • a both-associative operator has an unlimited number of arguments • a left, right or non associative operator has at most two arguments kind: "infix"; Infix position, with an operand before and an operand after: a ⊛ b. Example: +, \times. parse: string | InfixParseHandler; precedence: number; ### InfixParseHandler Permalink (parser: Parser, until: Terminator, lhs: Expression): Expression | null ### JsonSerializationOptions Permalink Options to control the serialization to MathJSON when using BoxedExpression.json. exclude: string[]; A list of space separated function names that should be excluded from the JSON output. Those functions are replaced with an equivalent, for example, Square with Power, etc… Possible values include Sqrt, Root, Square, Exp, Subtract, Rational, Complex Default: [] (none) metadata: ("all" | "wikidata" | "latex")[]; A list of space separated keywords indicating which metadata should be included in the MathJSON. If metadata is included, shorthand notation is not used. Default: [] (none) precision: "auto" | "max" | number; Number literals are serialized with this precision. If "auto", the same precision as the compute engine calculations is used If "max", all available digits are serialized Default: "auto" repeatingDecimals: boolean; If true, repeating decimals are detected and serialized accordingly For example: • 1.3333333333333333 ( \to ) 1.(3) • 0.142857142857142857142857142857142857142857142857142 ( \to ) 0.(1428571) Default: true shorthands: ("all" | "number" | "symbol" | "function" | "dictionary" | "string")[]; A list of space separated keywords indicating which MathJSON expressions can use a shorthand. Default: ["all"] ### LatexArgumentType Permalink • | "{expression}" • | "[expression]" • | "{text}" • | "[text]" • | "{unit}" • | "[unit]" • | "{glue}" • | "[glue]" • | "{string}" • | "[string]" • | "{color}" • | "[color]" ### LatexDictionary Permalink ### LatexDictionaryEntry Permalink ### LatexString Permalink A LaTeX string starts and end with $, for example "$\frac{\pi}{2}$".

string

A LatexToken is a token as returned by Scanner.peek.

It can be one of the indicated tokens, or a string that starts with a \ for LaTeX commands, or a LaTeX character which includes digits, letters and punctuation.

• | string
• | "<{>"
• | "<}>"
• | "<space>"
• | "<$>" • | "<$\$>"

• | "algebra"
• | "arithmetic"
• | "calculus"
• | "collections"
• | "control-structures"
• | "combinatorics"
• | "core"
• | "data-structures"
• | "dimensions"
• | "domains"
• | "linear-algebra"
• | "logic"
• | "numeric"
• | "other"
• | "physics"
• | "polynomials"
• | "relop"
• | "sets"
• | "statistics"
• | "styling"
• | "symbols"
• | "trigonometry"
• | "units"

• BaseEntry &
• closeDelimiter: Delimiter | LatexToken[];
kind: "matchfix";
openDelimiter: Delimiter | LatexToken[];

If kind is 'matchfix': the closeDelimiter and openDelimiter property are required

parse: MatchfixParseHandler;

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.

(parser: Parser, body: Expression): Expression | null

Metadata that can be associated with a BoxedExpression

latex: string;
wikidata: string;

avoidExponentsInRange: undefined | null | [negativeExponent: number, positiveExponent: number];
beginExponentMarker: LatexString;
beginRepeatingDigits: LatexString;
decimalMarker: LatexString;

A string representing the decimal marker, the string separating the whole portion of a number from the fractional portion, i.e. 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 brackets ensure there is no additional gap after the comma.

Default: "."

endExponentMarker: LatexString;
endRepeatingDigits: LatexString;
exponentProduct: LatexString;
groupSeparator: LatexString;

A string representing the separator between groups of digits, used to improve readability of numbers with lots of digits.

If you change it to another value, be aware that this may lead to unexpected results. For example, if changing it to , the expression \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)

imaginaryUnit: LatexString;
negativeInfinity: LatexString;
notANumber: LatexString;
notation: "engineering" | "auto" | "scientific";
positiveInfinity: LatexString;
precision: number;
truncationMarker: LatexString;

The numeric evaluation mode:

Mode
"auto" Use bignum or complex numbers.
"machine" IEEE 754-2008, 64-bit floating point numbers: 52-bit mantissa, about 15 digits of precision
"bignum" Arbitrary precision floating point numbers, as provided by the “decimal.js” library
"complex" Complex number represented by two machine numbers, a real and an imaginary part, as provided by the “complex.js” library

• | "auto"
• | "machine"
• | "bignum"
• | "complex"

applyInvisibleOperator: "auto" | null | (parser: Parser, lhs: Expression, rhs: Expression): Expression | null;

This function is invoked when a number is followed by a symbol, an open delimiter or a function.

If this function is set to null, the lhs and rhs are joined as a Sequence.

If this function is set to undefined it behaves in the following way:

• a number followed by a numeric expression is considered as separated with an invisible multiplication sign, and the two are joined as [‘Multiply’, lhs, rhs].
• a number followed by a rational number is considered to be separated with an invisible plus, and the two are joined as [‘Add’, lhs,

For example with 2\frac{3}{4}: ["Add", 2, ["Divide", 3, 4]]

parseArgumentsOfUnknownLatexCommands: boolean;

When an unknown LaTeX command is encountered, attempt to parse any arguments it may have.

For example, \foo{x+1} would produce ['\foo', ['Add', 'x', 1]] if this property is true, ['LatexSymbols', '\foo', '<{>', 'x', '+', 1, '<{>'] otherwise.

parseNumbers: boolean;

When a number is encountered, parse it.

Otherwise, return each token making up the number (minus sign, digits, decimal marker, etc…).

Default: true

preserveLatex: boolean;

If true, the expression will be decorated with the LaTeX fragments corresponding to each elements of the expression.

The top-level expression, that is the one returned by parse(), will include the verbatim LaTeX input that was parsed. The sub-expressions 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

skipSpace: boolean;

If true, ignore space characters.

Default: true

parseUnknownIdentifier: (symbol: string, parser: Parser): "symbol" | "function" | "unknown";

This handler is invoked when the parser encounter a set of tokens at a position that could be a symbol or function.

The symbol argument is one or more tokens.

The handler can return:

• symbol to indicate the string represent a constant or variable.

• function to indicate the string is a function name. If an apply function operator (typically, parentheses) follow, parse them as arguments to the function.

• error, an error condition is raised.

exact: boolean;
numericTolerance: number;
recursive: boolean;
substitution: BoxedSubstitution;

• BaseEntry &
• kind: "postfix";

Postfix position, with an operand before: a ⊛

Example: !.

parse: PostfixParseHandler;
precedence: number;

(parser: Parser, lhs: Expression): Expression | null

• BaseEntry &
• kind: "prefix";

Prefix position, with an operand after: ⊛ a

Example: -, \not.

parse: PrefixParseHandler;
precedence: number;

(parser: Parser, until: Terminator): Expression | null

• | [number, number]
• | [bigint, bigint]

iterationLimit: number;

If iterationLimit > 1, the rules will be repeatedly applied until no rules apply, up to maxIterations times.

Note that if once is true, maxIterations has no effect.

Default: 1

once: boolean;

If true, stop after the first rule that matches.

If false, apply all the remaining rules even after the first match.

Default: true

recursive: boolean;

If true, apply replacement rules to all sub-expressions. If false, only consider the top-level expression.

Default: true

A rule describes how to modify an expressions that matches a lhs pattern into a new expressions matching rhs.

x-1 ( \to ) 1-x (x+1)(x-1) ( \to ) x^2-1

The lhs can be expressed as a LaTeX string or a MathJSON expression.

Unbound variables (x, but not Pi) are matched structurally with a a target expression, then the expression is rewritten as the rhs, with the corresponding unbound variables in the rhs replaced by their values in the lhs.

Pattern symbols (e.g. _1, _a) can be used as well.

• __1 (__a, etc…) match a sequence of one or more expressions
• ___1 (___a, etc…) match a sequence of zero or more expressions

[lhs: LatexString | SemiBoxedExpression | Pattern, rhs: LatexString | SemiBoxedExpression, options: {condition: LatexString | (wildcards: BoxedSubstitution): boolean; priority: number}]

The entries of a RuntimeIdentifierTable have been validated and optimized for faster evaluation.

When a new scope is created with pushScope() or when creating a new engine instance, new instances of RuntimeIdentifierTable are created as needed.

• Scope &
• assumptions: undefined | ExpressionMapInterface<boolean>;
idTable: RuntimeIdentifierTable;
lowWaterMark: number;

Free memory should not go below this level for execution to proceed

origin: {column: number; line: number; name: string};

The location of the call site that created this scope

parentScope: RuntimeScope;

A scope is a set of names in a dictionary that are bound (defined) in a MathJSON expression.

Scopes are arranged in a stack structure. When an expression that defined a new scope is evaluated, the new scope is added to the scope stack. Outside of the expression, the scope is removed from the scope stack.

The scope stack is used to resolve symbols, and it is possible for a scope to ‘mask’ definitions from previous scopes.

Scopes are lexical (also called a static scope): they are defined based on where they are in an expression, they are not determined at runtime.

iterationLimit: number;
experimental

Signal iteration-limit-exceeded when the iteration limit for this scope is exceeded. Default: no limits.

memoryLimit: number;
experimental

Signal out-of-memory when the memory usage for this scope is exceeded. Memory in Megabytes, default: 1Mb.

recursionLimit: number;
experimental

Signal recursion-depth-exceeded when the recursion depth for this scope is exceeded.

timeLimit: number;
experimental

Signal timeout when the execution time for this scope is exceeded. Time in seconds, default 2s.

A semi boxed expression is an MathJSON expression which can include some boxed terms.

This is convenient when creating new expressions from portions of an existing BoxedExpression while avoiding unboxing and reboxing.

• | number
• | string
• | Decimal
• | Complex
• | MathJsonNumber
• | MathJsonString
• | MathJsonSymbol
• | MathJsonFunction
• | MathJsonDictionary
• | SemiBoxedExpression[]
• | BoxedExpression

(serializer: Serializer, expr: Expression): string

invisibleMultiply: LatexString;

LaTeX string used to render an invisible multiply, e.g. in ‘2x’. Leave it empty to join the adjacent terms, or use \cdot to insert a \cdot operator between them, i.e. 2\cdot x.

Empty by default.

invisiblePlus: LatexString;

LaTeX string used for an invisible plus, e.g. in ‘1 3/4’. Leave it empty to join the main number and the fraction, i.e. render it as 1\frac{3}{4}, or use + to insert a + operator between them, i.e. 1+\frac{3}{4}

Empty by default.

missingSymbol: LatexString;

When an expression contains the error expression ["Error", 'missing'], serialize it with this LaTeX string

multiply: LatexString;

LaTeX string used for an explicit multiply operator,

Default: \times

applyFunctionStyle: (expr: Expression, level: number): "paren" | "leftright" | "big" | "none";
fractionStyle: (expr: Expression, level: number): "quotient" | "inline-solidus" | "nice-solidus" | "reciprocal" | "factor";
groupStyle: (expr: Expression, level: number): "paren" | "leftright" | "big" | "none";
logicStyle: (expr: Expression, level: number): "boolean" | "word" | "uppercase-word" | "punctuation";
numericSetStyle: (expr: Expression, level: number): "compact" | "regular" | "interval" | "set-builder";
powerStyle: (expr: Expression, level: number): "quotient" | "solidus" | "root";
rootStyle: (expr: Expression, level: number): "radical" | "quotient" | "solidus";

Options for BoxedExpression.simplify()

A substitution describes the values of the wildcards in a pattern so that the pattern is equal to a target expression.

A substitution can also be considered a more constrained version of a rule whose lhs is always a symbol.

<T> =
[symbol: string]: T}

constant: boolean;

If true the value of the symbol is constant. The value or domain of symbols with this attribute set to true cannot be changed.

If false, the symbol is a variable.

Default: false

holdUntil: "never" | "simplify" | "evaluate" | "N";

If the symbol has a value, it is held as indicated in the table below. A green checkmark indicate that the symbol is substituted.

| Operation | "never" | "simplify" | "evaluate" | "N" | | :— | :----- | | canonical()| (X) | | | | | simplify() | (X) | (X) | | | | evaluate() | (X) | (X) | (X) | | | "N()" | (X) | (X) | (X) | (X) |

Some examples:

• i has holdUntil: 'never'
• GoldenRatio has holdUntil: 'simplify' (symbolic constant)
• x has holdUntil: 'evaluate' (variables)
• Pi has holdUntil: 'N' (special numeric constant)

Default: simplify

A bound symbol (i.e. one with an associated definition) has either a domain (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14… domain = TranscendentalNumber)

• BaseEntry &
• kind: "symbol";
parse: Expression | SymbolParseHandler;
precedence: number;

Used for appropriate wrapping (i.e. when to surround it with parens)

When used in a SymbolDefinition, these flags are optional.

If provided, they will override the value derived from the symbol’s value.

For example, it might be useful to override algebraic = false for a transcendental number.

NaN: boolean | undefined;
algebraic: boolean | undefined;
complex: boolean | undefined;
composite: boolean | undefined;
even: boolean | undefined;
extendedComplex: boolean | undefined;
extendedReal: boolean | undefined;
finite: boolean | undefined;
imaginary: boolean | undefined;
infinity: boolean | undefined;
integer: boolean | undefined;
negative: boolean | undefined;
negativeOne: boolean | undefined;
nonNegative: boolean | undefined;
nonPositive: boolean | undefined;
notZero: boolean | undefined;
number: boolean | undefined;
odd: boolean | undefined;
one: boolean | undefined;
positive: boolean | undefined;
prime: boolean | undefined;
rational: boolean | undefined;
real: boolean | undefined;
zero: boolean | undefined;

(parser: Parser): Expression | null

Documentation built with grok`