Struct exmex::FlatEx

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

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.

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<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 from_str_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.

Trait Implementations

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

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: Debug, OF: Debug, LM: Debug> Debug for FlatEx<T, OF, LM> where
    T: Debug + Clone,
    OF: MakeOperators<T>,
    LM: MatchLiteral, 

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<T, OF, LM> Differentiate<T> for FlatEx<T, OF, LM> where
    T: DataType,
    OF: MakeOperators<T> + Debug,
    LM: MatchLiteral + Debug, 

fn to_deepex<'a>(&'a self, ops: &[Operator<'a, T>]) -> ExResult<DeepEx<'a, T>> where
    Self: Sized,
    T: DataType + Float,
    <T as FromStr>::Err: Debug, 

feature = "partial" - Every trait implementation needs to implement the conversion to a deep expression to be able to use the default implementation of partial.

fn from_deepex(deepex: DeepEx<'_, T>, _: &[Operator<'_, T>]) -> ExResult<Self> where
    Self: Sized,
    T: DataType + Float,
    <T as FromStr>::Err: Debug, 

feature = "partial" - Every trait implementation needs to implement the conversion from a deep expression to be able to use the default implementation of partial.

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

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

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

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

fn partial_iter<'a, I>(&self, var_idxs: I) -> ExResult<Self> where
    T: DataType + Float,
    <T as FromStr>::Err: Debug,
    I: Iterator<Item = &'a usize> + Clone, 

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

impl<T, OF, LMF> Display for FlatEx<T, OF, LMF> where
    T: DataType,
    OF: MakeOperators<T>,
    LMF: MatchLiteral, 

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<T, OF, LM> Express<T> for FlatEx<T, OF, LM> where
    T: DataType,
    OF: MakeOperators<T>,
    LM: MatchLiteral, 

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

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

type Err = ExError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

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

fn cmp(&self, other: &FlatEx<T, OF, LM>) -> 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<T: PartialEq, OF: PartialEq, LM: PartialEq> PartialEq<FlatEx<T, OF, LM>> for FlatEx<T, OF, LM> where
    T: Debug + Clone,
    OF: MakeOperators<T>,
    LM: MatchLiteral, 

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: &FlatEx<T, OF, LM>) -> bool

This method tests for !=.

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

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<'de, T: DataType, OF: MakeOperators<T>, LMF: MatchLiteral> Serialize for FlatEx<T, OF, LMF>

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

Serialize this value into the given Serde serializer.

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

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,