Function simplify #

Simplify an expression tree.

A list of rules are applied to an expression, repeating over the list until no further changes are made. It’s possible to pass a custom set of rules to the function as second argument. A rule can be specified as an object, string, or function:

const rules = [
  { l: 'n1*n3 + n2*n3', r: '(n1+n2)*n3' },
  'n1*n3 + n2*n3 -> (n1+n2)*n3',
  function (node) {
    // ... return a new node or return the node unchanged
    return node

String and object rules consist of a left and right pattern. The left is used to match against the expression and the right determines what matches are replaced with. The main difference between a pattern and a normal expression is that variables starting with the following characters are interpreted as wildcards:

The default list of rules is exposed on the function as simplify.rules and can be used as a basis to built a set of custom rules. Note that since the simplifyCore function is in the default list of rules, by default simplify will convert any function calls in the expression that have operator equivalents to their operator forms.

To specify a rule as a string, separate the left and right pattern by ‘->’ When specifying a rule as an object, the following keys are meaningful:

For more details on the theory, see:

An optional options argument can be passed as last argument of simplify. Currently available options (defaults in parentheses):

Syntax #

simplify(expr, rules)
simplify(expr, rules)
simplify(expr, rules, scope)
simplify(expr, rules, scope, options)
simplify(expr, scope)
simplify(expr, scope, options)

Parameters #

Parameter Type Description
expr Node | string The expression to be simplified
rules SimplifyRule[] Optional list with custom rules
scope Object Optional scope with variables
options SimplifyOptions Optional configuration settings

Returns #

Type Description
Node Returns the simplified form of expr

Throws #

Type | Description —- | ———–

Examples #

math.simplify('2 * 1 * x ^ (2 - 1)')      // Node "2 * x"
math.simplify('2 * 3 * x', {x: 4})        // Node "24"
const f = math.parse('2 * 1 * x ^ (2 - 1)')
math.simplify(f)                          // Node "2 * x"
math.simplify('0.4 * x', {}, {exactFractions: true})  // Node "x * 2 / 5"
math.simplify('0.4 * x', {}, {exactFractions: false}) // Node "0.4 * x"

See also #

simplifyCore, derivative, evaluate, parse, rationalize, resolve

Fork me on GitHub