math-expression-evaluator

The evaluator has built-in support for sequence operations.

• Sigma (Summation): Sigma(start, end, n) calculates the sum of a sequence from start to end using n as the iterator. For example, Sigma(1,100,n) evaluates to 5050.
• Pi (Product): Pi(start, end, n) calculates the product of a sequence from start to end using n as the iterator. For example, Pi(1,15,n) evaluates to 1307674368000 (which is 15!).

You can install the library using npm for Node.js environments or bower for browser-based projects.

# Node.js
npm install math-expression-evaluator

# Browser
bower install math-expression-evaluator

For more control over the evaluation lifecycle, you can use the constituent methods of the Mexp object to manually lex, convert to postfix, and evaluate the expression. This is useful if you need to inspect tokens or the postfix notation before calculating the final result.

// 1. Create mexp object
const mexp = new Mexp();

// 2. Parse expression into tokens
var lexed = mexp.lex("expression");

// 3. Convert tokens to postfix notation
var postfixed = mexp.toPostfix(lexed);

// 4. Evaluate the postfix expression
var result = mexp.postfixEval(postfixed);

You can add custom tokens to the evaluator to support new operators or functions. Tokens added via these methods are preserved for subsequent evaluations on that instance.

const mexp = new Mexp();

// Option 1: Using addToken method
mexp.addToken([token1, token2]);

// Option 2: Passing tokens directly to eval
mexp.eval("expression", [token1, token2]);

// Option 3: Passing tokens through the granular pipeline
const answer = mexp.postfixEval(
  mexp.toPostfix(
    mexp.lex("expression", [token1, token2])
  )
);

The simplest way to evaluate an expression is to instantiate a new Mexp object and call the .eval() method with your expression string.

const mexp = new Mexp();
var value = mexp.eval("2 + 2");

The createMathFunctions utility allows you to define or extend the set of mathematical operations available to the Mexp evaluator. It accepts an instance of Mexp and returns an object containing mathematical functions. These functions can be used to implement custom logic or override default behaviors.

Note that some functions (like sin, cos, tan) respect the mexp.math.isDegree setting, while others (like sigma or Pi) utilize mexp.postfixEval to evaluate sub-expressions within a range.

import Mexp from './index';
import { createMathFunctions } from './functions';

const mexp = new Mexp();
const customFunctions = createMathFunctions(mexp);

// customFunctions now contains the standard math library including:
// sin, cos, tan, log, fact, sigma, Pi, etc.

The lex method performs lexical analysis on an input string, converting it into an array of ParsedToken objects. This process validates the syntax and ensures that tokens appear in a mathematically valid order (e.g., preventing two decimals in one number or invalid operator sequences).

• Input: A string representing the mathematical expression.
• Optional Input: An array of Token[] to be added to the evaluator's vocabulary before lexing.
• Returns: An array of ParsedToken objects representing the structured expression.
• Errors: Throws an error if the expression is syntactically invalid (e.g., "complete the expression", "Unexpected Space", or "is not allowed after [token]").

// Basic usage
const tokens = mexp.lex("sin(pi) + 2");

// Usage with custom tokens
const tokensWithCustom = mexp.lex("myFunc(5)", customTokens);

You can extend the evaluator's vocabulary by adding custom tokens to the Mexp instance using the addToken method. This allows you to define new mathematical constants, functions, or operators that the lexer will recognize.

When adding tokens, ensure they follow the Token interface structure. If you add a token of type FUNCTION_WITH_N_ARGS without specifying numberOfArguments, it defaults to 2.

// Assuming 'mexp' is an instance of Mexp
const customTokens: Token[] = [
  {
    token: 'myFunc',
    type: tokenTypes.FUNCTION_WITH_ONE_ARG,
    value: (x: number) => x * 2,
    show: 'myFunc',
    precedence: 4
  }
];

mexp.addToken(customTokens);

The Mexp class is the primary entrypoint for evaluating mathematical expressions. You can use the eval method to pass a string expression, which the class internally lexes, converts to postfix notation, and evaluates.

eval(string, tokens?, Constants?) accepts:

• string: The mathematical expression to evaluate.
• tokens (optional): An array of pre-existing Token objects.
• Constants (optional): A configuration object for constants used during evaluation.

Upon instantiation, Mexp automatically initializes its math functions and tokens registry.

import Mexp from 'math-expression-evaluator';

const evaluator = new Mexp();
const result = evaluator.eval('2 + 3 * 4');
console.log(result); // 14

The toPostfix function converts an array of tokens (typically produced by the lex function) into postfix notation (Reverse Polish Notation). This is a necessary intermediate step for evaluating mathematical expressions. The function handles operator precedence and grouping symbols to ensure the resulting array is in the correct order for stack-based evaluation.

import { lex } from './lexer';
import { toPostfix } from './postfix';

const tokens = lex('3 + 4 * 2');
const postfix = toPostfix(tokens);
// postfix will contain the tokens rearranged for evaluation