Compute Engine

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.

Return a numeric approximation of this expression.

The expression is first converted to canonical form.

Any necessary calculations, including on floating point numbers, 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.

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 with the modified dictionary as operand, otherwise return the modified dictionary.

Return the value of this expression.

The expression is first converted to canonical form.

A pure expression always return the same value and has no side effects. If this.isPure is true, this.value and this.evaluate() are synonyms. For an impure expression, this.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 floating point calculations. To perform approximate floating point calculations, use this.N() instead.

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

The result is in canonical form.

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

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, {}.

Transform the expression by according to the rules: the matching lhs of a rule is replaced by its rhs.

If no rules apply, return null.

See also subs for a simple substitution.

Return a simpler form of this expression.

The expression is first converted to canonical form. Then a series of rewriting rules are applied repeatedly, until no 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 floating point numbers 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.

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.

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

From Object.toJSON(), equivalent to JSON.stringify(this.json)

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

From Object.valueOf(), return a primitive value for the expression.

If the expression is a machine number, or a Decimal that can be converted to a machine number, return a number.

If the expression is a rational number, return [number, number].

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

Otherwise return a LaTeX representation of the expression.

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

Both expressions are numerically evaluated.

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.

If the expressions cannot be compared, return undefined

Structural/symbolic equality (weak equality).

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

options?:

assumptions: Expression[];

defaultDomain: string;

If an unknown symbol is encountered, assume it should be a variable in this domain. Default ExtendedRealNumber

dictionaries: Readonly<Dictionary>[];

latexDictionary: readonly LatexDictionaryEntry[];

numericMode: NumericMode;

The default mode is auto. Use machine to only use 64-bit float, use decimal to always use arbitrary precision floating point numbers or complex for complex numbers.

numericPrecision: number;

Specific how many digits of precision for the numeric calculations. Default is 100.

tolerance: number;

If the absolute value of the difference of two numbers is less than tolerance, they are considered equal. Used by chop() as well.

→ ComputeEngine

Construct a new ComputeEngine instance.

Dictionaries define functions and symbols (in options.dictionaries) and the LaTeX syntax (in options.latexDictionaries). If no dictionaries are provided, the default ones are used.

The order of the dictionaries matter: the definitions from the later ones override the definitions from earlier ones. The first dictionary should be the 'core' dictionary which include some basic definitions such as domains (Boolean, Number, etc…) that are used by later dictionaries.

Shortcut for this.fn("Add"...).

The result is canonical.

Return a list of all the assumptions that match a pattern.

 ce.assume(x, 'PositiveInteger');
 ce.ask(['Greater', 'x', '_val'])
 //  -> [{'val': 0}]

When condition is false, signal.

• condition - If true, do nothing. If false, signal.

symbol: SemiBoxedExpression

domainValue:

• | string
• | number
• | MathJsonNumber
• | MathJsonString
• | MathJsonSymbol
• | MathJsonFunction
• | MathJsonDictionary
• | [Expression, ...Expression[]]
• | BoxedExpression
• | Domain
• | ["Matrix" | "SquareMatrix" | "Vector" | "Function" | "List" | "Dictionary" | "Tuple" | "Intersection" | "Union" | "Optional" | "Some" | "Covariant" | "Contravariant" | "Invariant", ...DomainExpression[]]
• | ["Range", Expression]
• | ["Range", Expression, Expression]
• | ["Range", Expression, Expression, Expression]
• | ["Interval", Expression, Expression]
• | ["Interval", ["Open", Expression], Expression]
• | ["Interval", Expression, ["Open", Expression]]
• | ["Interval", ["Open", Expression], ["Open", Expression]]
• | ["Head", string]
• | ["Symbol", string]
• | ["Literal", Expression]

→ AssumeResult

Add an assumption.

Note that the assumption is put into canonical form before being added.

Returned a boxed expression from the input.

The result may not be canonical.

Replace a number that is close to 0 with the exact integer 0.

How close to 0 the number has to be to be considered 0 is determined by tolerance.

Add (or replace) a definition for a symbol in the current scope.

Shortcut for this.fn("Divide", [num, denom])

The result is canonical.

Return a canonical boxed domain

Shortcut for this.fn("Error"...).

The result is canonical.

Return a canonical expression.

Note that the result may not be a function, or may have a different head than the one specified.

For example ce.fn("Add", [ce.number(2), ce.number(3)])) ( \to ) 5

Remove all assumptions about one or more symbols

Return dictionaries suitable for the specified categories, or "all" for all categories ("arithmetic", "algebra", etc…).

A dictionary defines how the symbols and function names in a MathJSON expression should be interpreted, i.e. how to evaluate and manipulate them.

Return the definition for a function matching this head.

Start looking in the current context, than up the scope chain.

Return a matching symbol definition, starting with the current scope and going up the scope chain.

Shortcut for this.fn("Divide", [1, expr])

The result is canonical.

Shortcut for this.fn("Multiply"...)

The result is canonical.

Shortcut for this.fn("Negate", [expr])

The result is canonical.

value:

• | number
• | MathJsonNumber
• | Decimal
• | Complex
• | [num: number, denom: number]

metadata?: Metadata

→ BoxedExpression

Return a canonical boxed number

Shortcut for this.fn("Pair"...)

The result is canonical.

Parse a string of LaTeX and return a corresponding BoxedExpression.

The result may not be canonical.

Remove the topmost scope from the scope stack.

base: BoxedExpression

exponent:

• | number
• | BoxedExpression
• | [number, number]

metadata?: Metadata

→ BoxedExpression

Shortcut for this.fn("Power"...)

The result is canonical.

options?:

assumptions: Expression[];

dictionary: Readonly<Dictionary> | Readonly<Dictionary>[];

scope: Partial<Scope>;

Create a new scope and add it to the top of the scope stack

The options.scope property can be used to specify custom precision, etc… for this scope

Serialize a BoxedExpression or a MathJSON expression to a LaTeX string

Call this function if an unexpected condition occurs during execution of a function in the engine.

An ErrorSignal is a problem that cannot be recovered from.

A WarningSignal indicates a minor problem that does not prevent the execution to continue.

Return a canonical boxed string

Return a canonical boxed symbol

Shortcut for this.fn("Tuple"...)

The result is canonical.

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

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.

Return true if the terminator condition is met

Return a LaTeX string after the index

Return a LaTeX string before the index

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

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

• ‘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)

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.

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

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.

Return a LaTeX dimension.

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()

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.

   <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.

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

Parse a tabular environment, until \end{endName}

Return the next token and advance the index

If there are any space, advance the index until a non-space is encountered

Return the number of exprs that matched the pattern

If expr does not match the pattern, return null.

Otherwise, return a substitution describing the values that the named wildcard in the pattern should be changed to in order for the pattern to be equal to the expression. If there are no named wildcards and the expression matches the pattern, and empty object literal {} is returned.

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.

If expr matches the pattern, return true, otherwise false

Styles

Output a LaTeX string representing the expression

Add a group fence around the expression if it is an operator of precedence less than or equal to prec.

Add a group fence around the expression if it is short (not a function)