Struct exmex::FlatEx

pub struct FlatEx<T, OF = FloatOpsFactory<T>, LM = NumberMatcher>
where
    T: Debug + Clone,
    OF: MakeOperators<T>,
    LM: MatchLiteral,
{ /* private fields */ }

Flattened expressions 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::parse.

use exmex::prelude::*;

// create an expression by parsing a string
let expr = FlatEx::<f32>::parse("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<T, OF, LMF> FlatEx<T, OF, LMF>

where T: DataType, OF: MakeOperators<T>, LMF: MatchLiteral,

pub fn new( nodes: SmallVec<[FlatNode<T>; 32]>, ops: SmallVec<[FlatOp<T>; 32]>, prio_indices: SmallVec<[usize; 32]>, var_names: SmallVec<[String; 16]>, text: String ) -> Self

pub fn compile(&mut self)

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

pub fn parse_wo_compile(text: &str) -> ExResult<Self>

where T: DataType, <T as FromStr>::Err: Debug,

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

pub fn var_indices_ordered(&self) -> SmallVec<[usize; 16]>

Returns the indices of the variables in the order of their occurrence during the operations

pub fn eval_vec(&self, vars: Vec<T>) -> ExResult<T>

Consumes vector for evaluation, possibly useful for large value types.

pub fn eval_iter(&self, vars: impl Iterator<Item = T>) -> ExResult<T>

Collects iterator into SmallVec.

Trait Implementations

impl<'a, T, OF, LM> Calculate<'a, T> for FlatEx<T, OF, LM>

where T: DataType, OF: MakeOperators<T> + Debug, LM: MatchLiteral + Debug, <T as FromStr>::Err: Debug,

fn operate_unary(self, repr: &'a str) -> ExResult<Self>

Applies a unary operator.

fn operate_binary(self, other: Self, repr: &'a str) -> ExResult<Self>

Applies a binary operator.

fn subs<F>(self, sub: &mut F) -> ExResult<Self>

where F: FnMut(&str) -> Option<Self>,

Substitutes a variable with another expression.

fn from_num(x: T) -> Self

Create an expression that contains exactly one number.

impl<T, OF, LM> Clone for FlatEx<T, OF, LM>

where T: Debug + Clone + Clone, OF: MakeOperators<T> + Clone, LM: MatchLiteral + Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, OF, LM> Debug for FlatEx<T, OF, LM>

where T: Debug + Clone + Debug, OF: MakeOperators<T> + Debug, LM: MatchLiteral + Debug,

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

Formats the value using the given formatter.

impl<'de, T: DataType + 'de, OF: MakeOperators<T>, LMF: MatchLiteral> Deserialize<'de> for FlatEx<T, OF, LMF>

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, LM> Differentiate<'a, T> for FlatEx<T, OF, LM>

where T: DiffDataType, OF: MakeOperators<T> + Debug, LM: MatchLiteral + Debug, <T as FromStr>::Err: Debug,

fn partial(self, var_idx: usize) -> ExResult<Self>

feature = "partial" - This method computes a new expression that is the partial derivative of self with default operators.

fn partial_relaxed( self, var_idx: usize, missing_op_mode: MissingOpMode ) -> ExResult<Self>

Like Differentiate::partial. The only difference is that in case there is no differentation defined for a binary operator this will not necessarily throw an error depending on missing_op_mode, see MissingOpMode.

fn partial_nth(self, var_idx: usize, n: usize) -> ExResult<Self>

feature = "partial" - Computes the nth partial derivative with respect to one variable

fn partial_nth_relaxed( self, var_idx: usize, n: usize, missing_op_mode: MissingOpMode ) -> ExResult<Self>

Like Differentiate::partial_nth. The only difference is that in case there is no differentation defined for a binary operator this will not necessarily throw an error depending on missing_op_mode, see MissingOpMode.

fn partial_iter<I>(self, var_idxs: I) -> ExResult<Self>

where I: Iterator<Item = usize> + Clone,

feature = "partial" - Computes a chain of partial derivatives with respect to the variables passed as iterator

fn partial_iter_relaxed<I>( self, var_idxs: I, missing_op_mode: MissingOpMode ) -> ExResult<Self>

where I: Iterator<Item = usize> + Clone,

Like Differentiate::partial_iter. The only difference is that in case there is no differentation defined for a binary this will not necessarily throw an error depending on missing_op_mode, see MissingOpMode.

impl<T, OF, LMF> Display for FlatEx<T, OF, LMF>

where T: DataType, OF: MakeOperators<T>, LMF: MatchLiteral, <T as FromStr>::Err: Debug,

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, LM> Express<'a, T> for FlatEx<T, OF, LM>

where T: DataType, OF: MakeOperators<T>, LM: MatchLiteral, <T as FromStr>::Err: Debug,

type LiteralMatcher = LM

type OperatorFactory = OF

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

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

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

Evaluates an expression with the given variable values and returns the computed result. If more variables are passed than necessary the unnecessary ones are ignored.

fn unparse(&self) -> &str

Creates an expression string that corresponds to the FlatEx instance.

fn var_names(&self) -> &[String]

Returns the variables of the expression

fn to_deepex(self) -> ExResult<DeepEx<'a, T, OF, LM>>

where Self: Sized, T: DataType, <T as FromStr>::Err: Debug,

Conversion to a deep expression necessary for computations with expressions

fn from_deepex(deepex: DeepEx<'_, T, OF, LM>) -> ExResult<Self>

where Self: Sized, T: DataType, <T as FromStr>::Err: Debug,

fn parse(text: &'a str) -> ExResult<Self>

where Self: Sized,

impl<T, OF, LM> Ord for FlatEx<T, OF, LM>

where T: Debug + Clone + Ord, OF: MakeOperators<T> + Ord, LM: MatchLiteral + Ord,

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T, OF, LM> PartialEq for FlatEx<T, OF, LM>

where T: Debug + Clone + PartialEq, OF: MakeOperators<T> + PartialEq, LM: MatchLiteral + PartialEq,

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, OF, LM> PartialOrd for FlatEx<T, OF, LM>

where T: Debug + Clone + PartialOrd, OF: MakeOperators<T> + PartialOrd, LM: MatchLiteral + PartialOrd,

fn partial_cmp(&self, other: &FlatEx<T, OF, LM>) -> 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<T: DataType, OF: MakeOperators<T>, LMF: MatchLiteral> Serialize for FlatEx<T, OF, LMF>

where <T as FromStr>::Err: Debug,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, OF, LM> Eq for FlatEx<T, OF, LM>

where T: Debug + Clone + Eq, OF: MakeOperators<T> + Eq, LM: MatchLiteral + Eq,

impl<T, OF, LM> StructuralEq for FlatEx<T, OF, LM>

where T: Debug + Clone, OF: MakeOperators<T>, LM: MatchLiteral,

impl<T, OF, LM> StructuralPartialEq for FlatEx<T, OF, LM>

where T: Debug + Clone, OF: MakeOperators<T>, LM: MatchLiteral,