Struct ExpressionEvaluator 

pub struct ExpressionEvaluator<T: EvaluationDomain> { /* private fields */ }

A compiled expression ready for numeric evaluation.

The evaluator holds a sequence of Instrs and a pre-allocated stack. Call evaluate with parameter values to compute the result.

Implementations

impl<T: EvaluationDomain + PowfExtension> ExpressionEvaluator<T>

pub fn param_count(&self) -> usize

Return the number of parameters expected by this evaluator.

pub fn result_count(&self) -> usize

Return the number of results produced by this evaluator.

pub fn stack_size(&self) -> usize

Return the stack size required to evaluate this expression.

Callers reusing a stack buffer across evaluations should pre-allocate a Vec with this capacity.

pub fn evaluate(&self, params: &[T]) -> Result<Vec<T>>

Evaluate the expression with the given parameter values.

Returns a vector of result values. The number of results equals result_indices.len().

Errors

Returns EvaluationError if the number of parameters does not match, or if an arithmetic error occurs (e.g. division by zero).

Example

let result = evaluator.evaluate(&[2.0_f64])?;
assert_eq!(result.len(), 1);

pub fn evaluate_with_stack( &self, params: &[T], stack: &mut Vec<T>, results: &mut Vec<T>, ) -> Result<()>

Evaluate the expression, reusing caller-provided buffers.

stack must have capacity for at least stack_size elements (it is resized as needed); results is filled with the result values. Reusing buffers across calls avoids per-evaluation heap allocation, which matters for streaming and batch workloads.

Errors

Returns EvaluationError if the number of parameters does not match, or if an arithmetic error occurs.

impl<T: EvaluationDomain + PowfExtension> ExpressionEvaluator<T>

pub fn compile(atom: Atom<'_>) -> Result<Self>

Compile an Atom into an executable evaluator.

pub fn compile_with(atom: Atom<'_>, map: FunctionMap<T>) -> Result<Self>

Compile an Atom with a FunctionMap for user-defined functions.

pub fn compile_multi(atoms: &[Atom<'_>]) -> Result<Self>

Compile multiple Atoms into one multi-output evaluator, sharing common subexpressions across all outputs.

pub fn compile_multi_with( atoms: &[Atom<'_>], map: FunctionMap<T>, ) -> Result<Self>

Compile multiple Atoms with a FunctionMap into one multi-output evaluator.