Struct exmex::DeepEx

pub struct DeepEx<'a, T, OF = FloatOpsFactory<T>, LM = NumberMatcher>
where
    T: DataType,
    OF: MakeOperators<T>,
    LM: MatchLiteral,
    <T as FromStr>::Err: Debug,
{ /* private fields */ }

A deep expression evaluates co-recursively since its nodes can contain other deep expressions. Compared to FlatEx, this is slower to evaluate but easier to calculate with.

Implementations

impl<'a, T, OF, LM> DeepEx<'a, T, OF, LM>

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

pub fn one() -> Self

where T: NeutralElts,

pub fn zero() -> Self

where T: NeutralElts,

pub fn ops(&self) -> &Vec<Operator<'a, T>>

pub fn pow( self, exponent: DeepEx<'a, T, OF, LM> ) -> ExResult<DeepEx<'a, T, OF, LM>>

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

pub fn abs(self) -> ExResult<Self>

pub fn sin(self) -> ExResult<Self>

pub fn cos(self) -> ExResult<Self>

pub fn tan(self) -> ExResult<Self>

pub fn sinh(self) -> ExResult<Self>

pub fn cosh(self) -> ExResult<Self>

pub fn tanh(self) -> ExResult<Self>

pub fn asin(self) -> ExResult<Self>

pub fn acos(self) -> ExResult<Self>

pub fn atan(self) -> ExResult<Self>

pub fn signum(self) -> ExResult<Self>

pub fn log(self) -> ExResult<Self>

pub fn log2(self) -> ExResult<Self>

pub fn log10(self) -> ExResult<Self>

pub fn ln(self) -> ExResult<Self>

pub fn round(self) -> ExResult<Self>

pub fn floor(self) -> ExResult<Self>

pub fn ceil(self) -> ExResult<Self>

pub fn exp(self) -> ExResult<Self>

pub fn sqrt(self) -> ExResult<Self>

pub fn cbrt(self) -> ExResult<Self>

pub fn fract(self) -> ExResult<Self>

pub fn trunc(self) -> ExResult<Self>

pub fn pi() -> Self

where T: From<f64>,

pub fn e() -> Self

where T: From<f64>,

pub fn tau() -> Self

where T: From<f64>,

Trait Implementations

impl<'a, T, OF, LM> Add for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<'a, T, OF, LM> BitAnd for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<'a, T, OF, LM> BitOr for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<'a, T, OF, LM> BitXor for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

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

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

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<'a, T, OF, LM> Clone for DeepEx<'a, T, OF, LM>

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, T, OF, LM> Debug for DeepEx<'a, T, OF, LM>

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

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

Formats the value using the given formatter.

impl<'a, T, OF, LM> Default for DeepEx<'a, T, OF, LM>

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

fn default() -> Self

Returns the “default value” for a type.

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

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

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

Formats the value using the given formatter.

impl<'a, T, OF, LM> Div for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<'a, T, OF, LM> Express<'a, T> for DeepEx<'a, T, OF, LM>

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

type LiteralMatcher = LM

type OperatorFactory = OF

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 eval(&self, vars: &[T]) -> ExResult<T>

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

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

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

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 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 parse(text: &'a str) -> ExResult<Self>

where Self: Sized,

impl<'a, T, OF, LM> Mul for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<'a, T, OF, LM> Neg for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'a, T, OF, LM> Ord for DeepEx<'a, T, OF, LM>

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

fn cmp(&self, other: &DeepEx<'a, 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<'a, T, OF, LM> PartialEq for DeepEx<'a, T, OF, LM>

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

fn eq(&self, other: &DeepEx<'a, 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<'a, T, OF, LM> PartialOrd for DeepEx<'a, T, OF, LM>

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

fn partial_cmp(&self, other: &DeepEx<'a, 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<'a, T, OF, LM> Rem for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<'a, T, OF, LM> Sub for DeepEx<'a, T, OF, LM>

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

type Output = Result<DeepEx<'a, T, OF, LM>, ExError>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<'a, T, OF, LM> Eq for DeepEx<'a, T, OF, LM>

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

impl<'a, T, OF, LM> StructuralEq for DeepEx<'a, T, OF, LM>

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

impl<'a, T, OF, LM> StructuralPartialEq for DeepEx<'a, T, OF, LM>

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