Struct exmex::prelude::FlatEx

pub struct FlatEx<'a, T, OF = FloatOpsFactory<T>> where
    T: Clone + Debug,
    OF: MakeOperators<T>,  { /* fields omitted */ }

This is the core data type representing a flattened expression and the result of parsing a string. We use flattened expressions to make efficient evaluation possible. Simplified, a flat expression consists of a SmallVec of nodes and a SmallVec of operators that are applied to the nodes in an order following operator priorities.

Creation of expressions is possible with the function parse which is equivalent to FlatEx::from_str or with FlatEx::from_pattern.

use exmex::prelude::*;

// create an expression by parsing a string
let expr = FlatEx::<f32>::from_str("sin(1+y)*x")?;
assert!((expr.eval(&[1.5, 2.0])? - (1.0 + 2.0 as f32).sin() * 1.5).abs() < 1e-6);

The argument &[1.5, 2.0] in the call of eval specifies the variable values in the alphabetical order of the variable names. In this example, we want to evaluate the expression for the varibale values x=2.0 and y=1.5.

Implementations

impl<'a, T, OF> FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

pub fn compile(&mut self)

Executes calculations that can trivially be executed, e.g., two numbers that need to be multiplied anyway.

pub fn from_str_wo_compile(text: &'a str) -> ExResult<Self> where
    T: DataType,
    <T as FromStr>::Err: Debug, 

Parses into an expression without compilation. Allow slightly faster direct evaluation of strings.

Trait Implementations

impl<'a, T: Clone, OF: Clone> Clone for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

fn clone(&self) -> FlatEx<'a, T, OF>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug, OF: Debug> Debug for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de: 'a, 'a, T: DataType + 'a, OF: MakeOperators<T>> Deserialize<'de> for FlatEx<'a, T, OF> where
    <T as FromStr>::Err: Debug, 

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<'a, T, OF> Display for FlatEx<'a, T, OF> where
    T: DataType,
    OF: MakeOperators<T>, 

The expression is displayed as a string created by unparse.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, T, OF> Express<'a, T> for FlatEx<'a, T, OF> where
    T: DataType,
    OF: MakeOperators<T>, 

fn from_str(text: &'a str) -> ExResult<Self> where
    <T as FromStr>::Err: Debug,
    T: DataType, 

Parses a string into an expression that can be evaluated.

fn from_regex(text: &'a str, number_regex: &Regex) -> ExResult<Self> where
    <T as FromStr>::Err: Debug,
    T: DataType, 

Use custom number literals defined as regex to create an expression that can be evaluated.

fn from_pattern(text: &'a str, number_regex_pattern: &str) -> ExResult<Self> where
    <T as FromStr>::Err: Debug,
    T: DataType, 

Use custom number literals defined as regex patterns to create an expression that can be evaluated.

fn eval(&self, vars: &[T]) -> ExResult<T>

Evaluates an expression with the given variable values and returns the computed result.

fn partial(self, var_idx: usize) -> ExResult<Self> where
    T: DataType + Float,
    <T as FromStr>::Err: Debug, 

This method computes a new instance that is a partial derivative of self with default operators.

fn unparse(&self) -> ExResult<String>

Creates an expression string that corresponds to the FlatEx instance.

fn reduce_memory(&mut self)

This function frees some memory. After calling partial memory might be re-allocated.

fn n_vars(&self) -> usize

Returns the number of variables of the expression

impl<'a, T: Ord, OF: Ord> Ord for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

fn cmp(&self, other: &FlatEx<'a, T, OF>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a, T: PartialEq, OF: PartialEq> PartialEq<FlatEx<'a, T, OF>> for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

fn eq(&self, other: &FlatEx<'a, T, OF>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &FlatEx<'a, T, OF>) -> bool

This method tests for !=.

impl<'a, T: PartialOrd, OF: PartialOrd> PartialOrd<FlatEx<'a, T, OF>> for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

fn partial_cmp(&self, other: &FlatEx<'a, T, OF>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'de: 'a, 'a, T: DataType, OF: MakeOperators<T>> Serialize for FlatEx<'a, T, OF>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'a, T: Eq, OF: Eq> Eq for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

impl<'a, T, OF> StructuralEq for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>, 

impl<'a, T, OF> StructuralPartialEq for FlatEx<'a, T, OF> where
    T: Clone + Debug,
    OF: MakeOperators<T>,