fee 0.2.4

Expression evaluator supporting numeric, logical and bitwise operators
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

use criterion::{Criterion, criterion_group, criterion_main};
use fee::{IndexedResolver, SmallResolver, prelude::*};
use std::hint::black_box;

fn parsers(c: &mut Criterion)
{
    let expr = "(2 * 21)
        + abs((2 + 3) * 4, sqrt(5))
        + 3 - 35 - ((5 * 80) + 5)
        + 10 + p0 - p0^p0 * p1
        - abs((2 + 3) * 4, sqrt(5))
        + ((p0 + 3 * p1) << 2) & 255 | ((10 ^ 2) % 7)";

    c.bench_function("internal/parse/rpn", |b| {
        let context = Context::empty();
        b.iter(|| {
            black_box(Expr::compile(expr, &context).unwrap());
        });
    });

    c.bench_function("internal/parse/irpn", |b| {
        let v_resolver = IndexedResolver::new();
        let f_resolver = IndexedResolver::new();
        let context = Context::new(v_resolver, f_resolver);
        b.iter(|| {
            black_box(Expr::compile(expr, &context).unwrap());
        });
    });

    c.bench_function("internal/parse/lrpn", |b| {
        let mut v_resolver = SmallResolver::new();
        v_resolver.insert("p0", 1.0);
        v_resolver.insert("p1", 2.0);
        let mut f_resolver = SmallResolver::new();
        f_resolver.insert("abs".to_string(), ExprFn::new(|_| 0.0));
        f_resolver.insert("sqrt".to_string(), ExprFn::new(|_| 0.0));

        let context = Context::new(v_resolver, f_resolver).lock();

        b.iter(|| {
            black_box(Expr::compile(expr, &context).unwrap());
        });
    });
}

criterion_group!(benches, parsers);
criterion_main!(benches);