# math_expressions 2.2.0 math_expressions: ^2.2.0 copied to clipboard

A library for parsing and evaluating mathematical expressions, supporting real numbers, vectors, and basic interval arithmetic.

# math_expressions #

A library for parsing and evaluating mathematical expressions.

- Performs evaluations in real, vector, and interval contexts.
- Supports expression simplification and differentiation.

math_expressions is inspired by mathExpr for Java and distributed under the MIT license.

## Features #

- Evaluation of expressions in various modes: Real, Vector and Interval.
- Parsing, simplification and differentiation of mathematical expressions.
- Supporting most basic math functions out of the box.
- Extensible through custom function definitions in code.
- Well documented and tested.

This package contains a very simple command-line interpreter for real numbers:

```
pub run math_expressions:interpreter
```

### What's not working yet? #

- Some evaluations in vector and interval space (especially functions).
- N-dimensional vectors. Curently no more than four dimensions are supported.
- The parser only works for real numbers.
- Complex numbers.

Suggestions and pull requests are always welcome!

## Usage #

Below are two basic examples of how to use this library. There also is some additional example code available.

### 1. Expression creation and evaluation #

This example shows how to evaluate

for

#### Build the expression

You can either create an mathematical expression programmatically or parse a string.

- Create the expression programmatically:

```
Variable x = Variable('x'), y = Variable('y');
Power xSquare = Power(x, 2);
Cos yCos = Cos(y);
Number three = Number(3.0);
Expression exp = (xSquare + yCos) / three;
```

- Create the expression via the parser:

```
Parser p = Parser();
Expression exp = p.parse("(x^2 + cos(y)) / 3");
```

#### Evaluate the expression

- Bind variables and evaluate the expression as real number:

```
// Bind variables:
ContextModel cm = ContextModel();
cm.bindVariable(x, Number(2.0));
cm.bindVariable(y, Number(Math.PI));
// Evaluate expression:
double eval = exp.evaluate(EvaluationType.REAL, cm);
print(eval) // = 1.0
```

### 2. Expression simplification and differentiation #

This example shows how to simplify and differentiate

- Expressions can be simplified and differentiated with respect to a given variable:

```
Expression exp = p.parse("x*1 - (-5)");
print(exp); // = ((x * 1.0) - -(5.0))
print(exp.simplify()); // = (x + 5.0)
Expression expDerived = exp.derive('x');
print(expDerived); // = (((x * 0.0) + (1.0 * 1.0)) - -(0.0))
print(expDerived.simplify()); // = 1.0
```

## Alternatives #

Here are some other Dart libraries that implement similar functionality to math_expression: parsing and evaluating mathematical expressions.

- expressions: an elegant and small library to parse and evaluate simple expressions.
- function_tree: a library for parsing, evaluating and plotting single- and multi-variables numerical functions.

To the author's knowledge math_expressions is currently the only library supporting interval arithmetics.