nanoexpr 0.2.1

Fast no_std math expression parser and evaluator with zero heap allocation: formulas with variables and functions for microcontrollers, WebAssembly and C, in f32, f64, integers or calculator-exact decimals
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

#![cfg(feature = "libm")]

use std::thread;

use nanoexpr::{Context, ErrorKind, Evaluator, Math, Number};

const STACK: usize = if cfg!(debug_assertions) {
    256 * 1024
} else {
    64 * 1024
};

fn nested(depth: usize) -> [String; 11] {
    [
        "(".repeat(depth) + "pi" + &")".repeat(depth),
        "-".repeat(depth) + "pi",
        "+".repeat(depth) + "pi",
        "2^".repeat(depth) + "pi",
        "1+(".repeat(depth) + "pi" + &")".repeat(depth),
        "max(".repeat(depth) + "pi" + &")".repeat(depth),
        "max(1,".repeat(depth) + "pi" + &")".repeat(depth),
        "abs(-(".repeat(depth) + "pi" + &"))".repeat(depth),
        "!".repeat(depth) + "pi",
        "1?".repeat(depth) + "pi" + &":0".repeat(depth),
        "1&&(".repeat(depth) + "pi" + &")".repeat(depth),
    ]
}

fn evaluate_deepest<N: Number + std::fmt::Debug + Send + 'static>()
where
    Math: Context<N>,
{
    thread::Builder::new()
        .stack_size(STACK)
        .spawn(|| {
            let evaluator = Evaluator::<Math>::new(&Math);
            for depth in 0..=Evaluator::<Math>::DEFAULT_MAX_DEPTH + 1 {
                for input in nested(depth) {
                    let _ = evaluator.evaluate::<N>(&input);
                }
            }
            for input in nested(10_000) {
                assert_eq!(
                    evaluator.evaluate::<N>(&input).unwrap_err().kind,
                    ErrorKind::TooDeep
                );
            }
        })
        .unwrap()
        .join()
        .unwrap();
}

#[test]
fn default_depth_fits_a_small_stack_in_f64() {
    evaluate_deepest::<f64>();
}

#[cfg(feature = "decimal")]
#[test]
fn default_depth_fits_a_small_stack_in_decimal() {
    evaluate_deepest::<nanoexpr::Decimal>();
    evaluate_deepest::<nanoexpr::Decimal<18, 9999>>();
}

#[cfg(feature = "fraction")]
#[test]
fn default_depth_fits_a_small_stack_in_fraction() {
    evaluate_deepest::<nanoexpr::Fraction>();
}

#[cfg(feature = "exact")]
#[test]
fn default_depth_fits_a_small_stack_in_exact() {
    evaluate_deepest::<nanoexpr::Exact>();
}