Struct exmex::FlatEx

pub struct FlatEx<'a, T: Copy + Debug> { /* 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.

You create an expression with the parse function or one of its variants, namely parse_with_default_ops and parse_with_number_pattern.

use exmex::{parse_with_default_ops};

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

The second 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. Variables in the string to-be-parsed are all substrings that are no numbers, no operators, and no parentheses.

Implementations

impl<'a, T: Copy + Debug> FlatEx<'a, T>

pub fn eval(&self, vars: &[T]) -> Result<T, ExParseError>

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

Arguments

• vars - Values of the variables of the expression; the n-th value corresponds to the n-th variable in alphabetical order. Thereby, only the first occurrence of the variable in the string is relevant. If an expression has been created by partial derivation, the variables always coincide with those of the antiderivatives even in cases where variables are irrelevant such as (x)'=1.

Errors

If the number of variables in the parsed expression are different from the length of the variable slice, we return an ExParseError.

pub fn partial(self, var_idx: usize) -> Result<Self, ExParseError> where
    T: Float, 

This method computes a FlatEx instance that is a partial derivative of self with default operators as shown in the following example.

use exmex::{parse_with_default_ops};

let expr = parse_with_default_ops::<f64>("sin(1+y^2)*x")?;
let dexpr_dx = expr.clone().partial(0)?;
let dexpr_dy = expr.partial(1)?;

assert!((dexpr_dx.eval(&[9e5, 2.0])? - (5.0 as f64).sin()).abs() < 1e-12);
//                   |    
//             This partial derivative dexpr_dx does depend on x. Still, it expects
//             the same number of parameters as the corresponding
//             antiderivative. Hence, you can pass any number for x.  

assert!((dexpr_dy.eval(&[2.5, 2.0])? - 10.0 * (5.0 as f64).cos()).abs() < 1e-12);

Arguments

• var_idx - variable with respect to which the partial derivative is computed

Errors

• If self has been clear_deepexed, we cannot compute the partial derivative and return an ExParseError.
• If you use none-default operators this might not work as expected. It could return an ExParseError if an operator is not found or compute a wrong result if an operator is defined in an un-expected way.

pub fn unparse(&self) -> Result<String, ExParseError>

Creates an expression string that corresponds to the FlatEx instance. This is not necessarily the input string. More precisely,

• variables are put between curly braces,
• spaces outside of curly brackets are ignored,
• parentheses can be different from the input, and
• expressions are compiled as shown in the following example.

use exmex::parse_with_default_ops;
let flatex = parse_with_default_ops::<f64>("--sin ( z) +  {another var} + 1 + 2")?;
assert_eq!(format!("{}", flatex), "-(-(sin({z})))+{another var}+3.0");

pub fn clear_deepex(&mut self)

Usually, a FlatEx instance keeps a nested, deep structure of the expression that is not necessary for evaluation. This functions removes the deep expression to reduce memory consumption. The methods partial and unparse as well as the implementation of the Display trait will stop working after calling this function.

Trait Implementations

impl<'a, T: Clone + Copy + Debug> Clone for FlatEx<'a, T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T: Debug + Copy> Debug for FlatEx<'a, T>

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

Formats the value using the given formatter.

impl<'de: 'a, 'a, T: Float + Debug + FromStr + 'a> Deserialize<'de> for FlatEx<'a, T> 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: Copy + Debug> Display for FlatEx<'a, 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: Ord + Copy + Debug> Ord for FlatEx<'a, T>

fn cmp(&self, other: &FlatEx<'a, T>) -> 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 + Copy + Debug> PartialEq<FlatEx<'a, T>> for FlatEx<'a, T>

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

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

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

This method tests for !=.

impl<'a, T: PartialOrd + Copy + Debug> PartialOrd<FlatEx<'a, T>> for FlatEx<'a, T>

fn partial_cmp(&self, other: &FlatEx<'a, T>) -> 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: Copy + Debug> Serialize for FlatEx<'a, T>

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 + Copy + Debug> Eq for FlatEx<'a, T>

impl<'a, T: Copy + Debug> StructuralEq for FlatEx<'a, T>

impl<'a, T: Copy + Debug> StructuralPartialEq for FlatEx<'a, T>