# math_parser 1.5.0 math_parser: ^1.5.0 copied to clipboard

Process math expressions, like formulas or parts of equations, convert them to machine-readable form, and calculate them.

# Math Parser for Dart #

Process math expressions, convert them to machine-readable form, and calculate them.

This package is aimed to help you to work with formulas, parts of equations and other forms of simple math expressions in your projects. This package supports custom variables too.

## Features: In Short #

For more details about these features, refer to documentation, this readme or example file. All public API elements are documented.

- Parse mathematical expressions using
`MathNodeExpression.fromString`

or equations using`MathNodeExpression.fromStringExtended`

. - Define custom variables and functions by passing
`variableNames`

and`customFunctions`

parameters. To define a custom function, you'll have to implement the`MathDefinitionFunctionFreeformImplemented`

interface for each such function. - Automatically detect possible variable and function names used in an expression, but this works reliably only with implicit multiplication off.

## Math Tree #

The library provides a family of `MathExpression`

and
`MathNode`

classes, most of them have subnodes that are being
calculated recursively.

There are such types of MathNode:

`MathFunction`

(and`MathFunctionWithTwoArguments`

subclass)`MathValue`

`MathOperator`

Types of `MathExpression`

:

`MathComparison`

All the child classes names begin with the family they belong to.

## Evaluation #

You can evaluate a MathNode and its subnodes recursively by calling
`MathNode.calc(MathVariableValues values)`

and passing custom
variable values.

Example: Calculate `x + 3`

, where `x = 5`

.

```
MathOperatorAddition(
MathVariable('x'),
const MathValue(3),
).calc(MathVariableValues.x(5));
```

You can also evaluate `MathExpression.calc`

, but this method
doesn't guarantee numeric result, so it may return null.

## Parsing String to MathNode #

The library can parse general mathematical expressions strings
and return them as a machine-readable `MathNode`

using
`MathNodeExpression.fromString`

method.

Define custom variables with `variableNames`

parameter. Don't forget to
define the variable value in `MathExpression.calc`

when calling it.

Define custom functions using `customFunctions`

argument. You can use either
`MathCustomFunctions`

class, which plainly declares the functions, or
`MathCustomFunctionsImplemented`

, which also requires to implement the
function. When you use `MathCustomFunctionsImplemented`

during parsing,
you don't need to redeclare the function in `MathExpression.calc`

.

### Parse priority: #

- Parentheses () []
- Variables: e, pi (π) and custom ones.
`x`

is being interpreted as a var by default, but you can override this behavior with the variableNames parameter. You can rewrite e and pi by defining it in variableNames and mentioning it during the calc call. First character must be a letter or _, others - letters, digits, period, or underscore. Last symbol can't be a period. Letters may be latin or Greek, both lower or capital case. You can't use built-in function names like sin, cos, etc. Variable names are case-sensitive. Custom functions have the same requirements, except they can override built-in functions. - Functions (case-sensitive):
- Custom functions
- sin, cos, tan (tg), cot (ctg)
- sqrt (√) (interpreted as power of 1/2), complex numbers not supported
- ln (base=E), lg (base=2), log[base](x)
- asin (arcsin), acos (arccos), atan (arctg), acot (arcctg)

- Unary minus (-) at the beginning of a block
- Power (x^y)
- Implicit multiplication (two MathNodes put near without operator between)
- Division (/) & Multiplication (*)
- Subtraction (-) & Addition (+)

```
MathNode fromString(
/// The expression to convert
String expression, {
/// Converts all X - Y to X + (-Y)
bool isMinusNegativeFunction = false,
/// Allows skipping the multiplication (*) operator
bool isImplicitMultiplication = true,
/// Expressions which should be marked as variables
Set<String> variableNames = const {'x'},
/// Expressions which should be marked as functions
MathCustomFunctions customFunctions = const MathCustomFunctions({}),
});
```

Example for parsing a string and evaluating it with `x = 20`

:

```
final expression = MathNodeExpression.fromString(
'(2x)^(e^3 + 4) + x',
).calc(
MathVariableValues({'x': 20}),
);
```

More complicated work with variables and functions is shown off in example.

You can also parse equations with `MathNodeExpression.fromStringExtended`

,
refer to example for this.

### Detect used variable names #

You can detect possible variable names used in a string math expression
using `MathNodeExpression.getPotentialDefinable`

.

Detecting variable names works properly only when implicit multiplication is disabled.

```
final expr = '2*a+b';
final definable = MathNodeExpression.getPotentialDefinable(
expr,
hideBuiltIns: true,
);
MathNodeExpression.fromString(
expr,
variableNames: definable.variables,
isImplicitMultiplication: false,
);
```

## Other Features #

### Numerical methods for Definite Integrals #

You can calculate a given node as a definite integral using
the `MathNodeDefiniteIntegral`

extension. All methods have
the same interface:

```
num definiteIntegralByLeftRectangles(
/// Precision
int n,
num lowerLimit,
num upperLimit,
);
```