Struct EvalContext

Source

pub struct EvalContext<'a> {
    pub variables: HashMap<String, Real>,
    pub constants: HashMap<String, Real>,
    pub arrays: HashMap<String, Vec<Real>>,
    pub attributes: HashMap<String, HashMap<String, Real>>,
    pub nested_arrays: HashMap<String, HashMap<usize, Vec<Real>>>,
    pub function_registry: Rc<FunctionRegistry<'a>>,
    pub parent: Option<Rc<EvalContext<'a>>>,
    pub ast_cache: Option<RefCell<HashMap<String, Rc<AstExpr>>>>,
}

Expand description

Evaluation context for expressions.

This is the main configuration object that holds variables, constants, arrays, functions, and other settings for evaluating expressions. You typically create an EvalContext, add your variables and functions, and then pass it to the interp function.

§Examples

use exp_rs::context::EvalContext;
use exp_rs::engine::interp;
use std::rc::Rc;
 
let mut ctx = EvalContext::new();
 
// Add variables
ctx.set_parameter("x", 5.0);
ctx.set_parameter("y", 10.0);
 
// Add a constant
ctx.constants.insert("PI_SQUARED".to_string(), 9.8696);
 
// Register a custom function
ctx.register_native_function("multiply", 2, |args| args[0] * args[1]);
 
// Evaluate expressions using this context
let result = interp("x + y * PI_SQUARED", Some(Rc::new(ctx.clone()))).unwrap();
let result2 = interp("multiply(x, y)", Some(Rc::new(ctx))).unwrap();

Contexts can be nested to create scopes:

use exp_rs::context::EvalContext;
use std::rc::Rc;
 
let mut parent = EvalContext::new();
parent.set_parameter("x", 1.0);
 
let mut child = EvalContext::new();
child.set_parameter("y", 2.0); 
child.parent = Some(Rc::new(parent));
 
// The child context can access both its own variables and the parent's

Fields§

§variables: HashMap<String, Real>

Variables that can be modified during evaluation

§constants: HashMap<String, Real>

Constants that cannot be modified during evaluation

§arrays: HashMap<String, Vec<Real>>

Arrays of values that can be accessed using array[index] syntax

§attributes: HashMap<String, HashMap<String, Real>>

Object attributes that can be accessed using object.attribute syntax

§nested_arrays: HashMap<String, HashMap<usize, Vec<Real>>>

Multi-dimensional arrays (not yet fully supported)

§function_registry: Rc<FunctionRegistry<'a>>

Registry of functions available in this context

§parent: Option<Rc<EvalContext<'a>>>

Optional parent context for variable/function inheritance

§ast_cache: Option<RefCell<HashMap<String, Rc<AstExpr>>>>

Optional cache for parsed ASTs to speed up repeated evaluations

Struct EvalContextCopy item path

§Examples

Fields§

Implementations§

impl<'a> EvalContext<'a>

pub fn new() -> Self

§Examples

pub fn set_parameter(&mut self, name: &str, value: Real) -> Option<Real>

§Parameters

§Returns

§Examples

pub fn register_native_function<F>( &mut self, name: &str, arity: usize, implementation: F, )where F: Fn(&[Real]) -> Real + 'static,

§Parameters

§Examples

pub fn register_expression_function( &mut self, name: &str, params: &[&str], expression: &str, ) -> Result<(), ExprError>

§Parameters

§Returns

§Examples

pub fn enable_ast_cache(&self)

§Examples

pub fn disable_ast_cache(&self)

§Examples

pub fn clear_ast_cache(&self)

pub fn register_default_math_functions(&mut self)

§Usage

§Feature: no-builtin-math

pub fn get_variable(&self, name: &str) -> Option<Real>

§Overriding Built-ins

§Disabling Built-ins

§Example

pub fn get_constant(&self, name: &str) -> Option<Real>

pub fn get_array(&self, name: &str) -> Option<&Vec<Real>>

pub fn get_attribute_map(&self, base: &str) -> Option<&HashMap<String, Real>>

pub fn get_native_function(&self, name: &str) -> Option<&NativeFunction<'_>>

pub fn get_user_function(&self, name: &str) -> Option<&UserFunction>

pub fn get_expression_function(&self, name: &str) -> Option<&ExpressionFunction>

Trait Implementations§

impl<'a> Clone for EvalContext<'a>

fn clone(&self) -> Self

fn clone_from(&mut self, source: &Self)

impl<'a> Default for EvalContext<'a>

fn default() -> EvalContext<'a>

Auto Trait Implementations§

impl<'a> !Freeze for EvalContext<'a>

impl<'a> !RefUnwindSafe for EvalContext<'a>

impl<'a> !Send for EvalContext<'a>

impl<'a> !Sync for EvalContext<'a>

impl<'a> Unpin for EvalContext<'a>

impl<'a> !UnwindSafe for EvalContext<'a>

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct EvalContext

pub fn register_native_function<F>( &mut self, name: &str, arity: usize, implementation: F, )
where F: Fn(&[Real]) -> Real + 'static,

§Feature: `no-builtin-math`

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T> ToOwned for T
where T: Clone,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,