lieval 0.1.2

A lightweight Rust crate for parsing and evaluating mathematical expressions from strings.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

# lieval


`lieval` is a lightweight Rust crate for parsing and evaluating mathematical expressions from strings.

## Features


- Parse and evaluate simple mathematical expressions.
    - Basic arithmetic operations: `+`, `-`, `*`, `/`, `%`
    - Parentheses for expression grouping
    - Common mathematical functions: `sin`, `cos`, `atan`, `cosh`, `pow`, `sqrt`, `hypot`, `exp`, `ln`, `div_euclid`, `floor` etc...
- Support for variables, operators, and functions.
- Minimal dependencies.
- Provides a simple and easy-to-use API.

## Usage


Add the `lieval` crate to your `Cargo.toml` file:

```toml
[dependencies]
lieval = "<version>"
```

Then, in your Rust code:

```rust
use lieval::*;

assert_eq!(eval_from_str("1.0 + 2 * (3 - 1)"), Ok(vec![5.0]));
assert_eq!(
    eval_from_str("1.0 - sin(3.14 / 2) * powf(1.5, 2.5)"),
    Ok(vec![1.0 - (3.14f64 / 2.0).sin() * 1.5.powf(2.5)])
);

let mut expr = Expr::new("sqrt(4)").unwrap();
assert_eq!(expr.eval(), Ok(vec![2.0]));
```

You can assign numerical values to variables and evaluate them using `Context`.

```rust
use lieval::*;

let mut context = Context::new();

assert_eq!(
    eval_from_str_with_context("1 / x", context.set_value("x", 2.0)),
    Ok(vec![0.5])
);

let mut expr = Expr::new("sqrt(2+x)").unwrap();
assert_eq!(expr.set_var("x", 2.0).eval(), Ok(vec![2.0]));

let mut expr = Expr::new("sqrt(2+x+y)").unwrap();
assert_eq!(expr.set_var("x", 2.0).set_var("y", 5.0).eval(), Ok(vec![3.0]));
```

You can use custom functions.

```rust
use lieval::*;

let mut context = Context::new();

assert_eq!(
    eval_from_str_with_context("1 + func(2,3)", context.set_func("func", 2, |x| x[0] + x[1])),
    Ok(vec![6.0])
);
assert_eq!(
    eval_from_str_with_context("1 + func(x)", context.set_func("func", 1, |x| x[0] * 2.0).set_value("x", 1.0)),
    Ok(vec![3.0])
);
```

You can evaluate multiple expressions separated by commas.

```rust
use lieval::*;

assert_eq!(
    eval_from_str("1 + 2, sin(3 + 0.14), 7 % 3"), 
    Ok(vec![3.0, (3.14f64).sin(), 7.0 % 3.0])
);
```

You can efficiently evaluate by precomputing using `partial_eval`.

```rust
use lieval::*;

let mut expr = Expr::new("a1 + a2 * sin(x)").unwrap();
expr.set_var("a1", 1.0)
    .set_var("a2", 0.5)
    .partial_eval()
    .unwrap();
let mut x = 1.0;
for _ in 0..10 {
    x = expr.set_var("x", x).eval().unwrap()[0];
    assert_eq!(expr.set_var("x", x).eval(), Ok(vec![1.0 + 0.5 * x.sin()]));
}
```

## API Documentation


Detailed API documentation can be found [here](https://docs.rs/lieval).

## License


This project is licensed under the MIT license.