exp-rs 0.2.0

no_std expression parser, compiler, and evaluation engine for math expressions designed for embedded, with qemu examples
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

use bumpalo::Bump;
use exp_rs::{EvalContext, expression::Expression};
use std::rc::Rc;

#[test]
fn temp_test_simple_expression_function() {
    let arena = Bump::new();
    let mut builder = Expression::new(&arena);
    let ctx = EvalContext::new();

    // Register basic math operators
    #[cfg(not(feature = "libm"))]
    {
        ctx.register_native_function("+", 2, |args| args[0] + args[1]);
        ctx.register_native_function("*", 2, |args| args[0] * args[1]);
    }

    // Register expression function in the batch instead of context
    builder
        .register_expression_function("double", &["x"], "x * 2")
        .unwrap();

    let ctx_rc = Rc::new(ctx);

    // Add a parameter and expression using the function
    builder.add_parameter("value", 5.0).unwrap();
    builder.add_expression("double(value)").unwrap();

    match builder.eval(&ctx_rc) {
        Ok(_) => {
            let result = builder.get_result(0).unwrap();
            println!("double(5) = {}", result);
            assert_eq!(result, 10.0);
        }
        Err(e) => {
            panic!("Expression function evaluation failed: {:?}", e);
        }
    }
}

#[test]
fn temp_test_expression_function_with_direct_arg() {
    let arena = Bump::new();
    let mut builder = Expression::new(&arena);
    let ctx = EvalContext::new();

    // Register basic math operators
    #[cfg(not(feature = "libm"))]
    {
        ctx.register_native_function("+", 2, |args| args[0] + args[1]);
        ctx.register_native_function("*", 2, |args| args[0] * args[1]);
    }

    // Register expression function in the batch instead of context
    builder
        .register_expression_function("double", &["x"], "x * 2")
        .unwrap();

    let ctx_rc = Rc::new(ctx);

    // Test with direct argument (no batch parameters)
    builder.add_expression("double(3)").unwrap();

    match builder.eval(&ctx_rc) {
        Ok(_) => {
            let result = builder.get_result(0).unwrap();
            println!("double(3) = {}", result);
            assert_eq!(result, 6.0);
        }
        Err(e) => {
            panic!("Expression function evaluation failed: {:?}", e);
        }
    }
}