Crate vector_expr

Vectorized math expression parser/evaluator.

Why?

Performance. Evaluation of math expressions involving many variables can incur significant overhead from traversing the expression tree or performing variable lookups. We amortize that cost by performing intermediate operations on vectors of input data at a time (with optional data parallelism via the rayon feature).

Example

use vector_expr::*;

fn binding_map(var_name: &str) -> BindingId {
    match var_name {
        "bar" => 0,
        "baz" => 1,
        "foo" => 2,
        _ => unreachable!(),
    }
}
let parsed = Expression::parse("2 * (foo + bar) * baz", binding_map).unwrap();
let real = parsed.unwrap_real();

let bar = [1.0, 2.0, 3.0];
let baz = [4.0, 5.0, 6.0];
let foo = [7.0, 8.0, 9.0];
let bindings: &[&[f64]] = &[&bar, &baz, &foo];
let mut registers = Registers::new(3);
let output = real.evaluate(bindings, &mut registers);
assert_eq!(&output, &[64.0, 100.0, 144.0]);

Modules

grammar_doc

Uses the pest parsing expression grammar language.

Structs

Registers

Scratch space for calculations. Can be reused across evaluations with the same data binding length.

Enums

BoolExpression

A bool-valued expression.

Expression

Top-level parseable calculation.

RealExpression

An f64-valued expression.

StringExpression

Traits

FloatExt

Functions

empty_binding_map

Pass to Expression::parse if the expression has no variables.

Type Aliases

BindingId

Index into the &[&[f64]] bindings passed to expression evaluation.

ParseError

StringId

To speed up string comparisons, we use string interning.