Trait Expr

pub trait Expr:
    Arg
    + Sync
    + Send {
    // Required methods
    fn for_each_arg(&self, f: &mut dyn FnMut(&dyn Arg));
    fn clone_box(&self) -> Box<dyn Expr>;
    fn str(&self) -> String;
    fn get_ref<'a>(&'a self) -> &'a dyn Expr;

    // Provided methods
    fn as_expr(&self) -> Option<Box<dyn Expr>> { ... }
    fn args(&self) -> Vec<Box<dyn Arg>> { ... }
    fn args_map_exprs(
        &self,
        _f: &dyn Fn(&dyn Expr) -> Box<dyn Arg>,
    ) -> Vec<Box<dyn Arg>> { ... }
    fn from_args(&self, args: Vec<Box<dyn Arg>>) -> Box<dyn Expr> { ... }
    fn as_arg(&self) -> Box<dyn Arg> { ... }
    fn as_function(&self) -> Option<&Func> { ... }
    fn equals(&self, other: &dyn Expr) -> bool { ... }
    fn as_symbol(&self) -> Option<Symbol> { ... }
    fn as_eq(&self) -> Option<Equation> { ... }
    fn as_mul(&self) -> Option<&Mul> { ... }
    fn as_pow(&self) -> Option<&Pow> { ... }
    fn as_f64(&self) -> Option<f64> { ... }
    fn to_cpp(&self) -> String { ... }
    fn simplify(&self) -> Box<dyn Expr> { ... }
    fn simplify_with_dimension(&self, dim: usize) -> Box<dyn Expr> { ... }
    fn as_int(&self) -> Option<Integer> { ... }
    fn pow(&self, exponent: &Box<dyn Expr>) -> Box<dyn Expr> { ... }
    fn ipow(&self, exponent: isize) -> Box<dyn Expr> { ... }
    fn sqrt(&self) -> Box<dyn Expr> { ... }
    fn get_exponent(&self) -> (Box<dyn Expr>, Box<dyn Expr>) { ... }
    fn diff(&self, var: &str, order: usize) -> Box<dyn Expr> { ... }
    fn name(&self) -> String { ... }
    fn subs(&self, substitutions: &[[Box<dyn Expr>; 2]]) -> Box<dyn Expr> { ... }
    fn has(&self, expr: &dyn Expr) -> bool { ... }
    fn has_box(&self, expr: Box<dyn Expr>) -> bool { ... }
    fn expand(&self) -> Box<dyn Expr> { ... }
    fn factor(&self, factors: &[&dyn Expr]) -> Box<dyn Expr> { ... }
    fn is_one(&self) -> bool { ... }
    fn is_neg_one(&self) -> bool { ... }
    fn is_number(&self) -> bool { ... }
    fn is_negative_number(&self) -> bool { ... }
    fn is_zero(&self) -> bool { ... }
    fn known_expr(&self) -> KnownExpr<'_> { ... }
    fn terms<'a>(&'a self) -> Box<dyn Iterator<Item = &'a dyn Expr> + 'a> { ... }
    fn get_coeff(&self) -> (Rational, Box<dyn Expr>) { ... }
    fn compare(&self, other: &dyn Expr) -> Option<Ordering> { ... }
    fn evaluate(&self, vars: Option<HashMap<Symbol, BoxExpr>>) -> BoxExpr { ... }
}

Required Methods

fn for_each_arg(&self, f: &mut dyn FnMut(&dyn Arg))

fn clone_box(&self) -> Box<dyn Expr>

fn str(&self) -> String

fn get_ref<'a>(&'a self) -> &'a dyn Expr

Provided Methods

fn as_expr(&self) -> Option<Box<dyn Expr>>

fn args(&self) -> Vec<Box<dyn Arg>>

fn args_map_exprs( &self, _f: &dyn Fn(&dyn Expr) -> Box<dyn Arg>, ) -> Vec<Box<dyn Arg>>

fn from_args(&self, args: Vec<Box<dyn Arg>>) -> Box<dyn Expr>

fn as_arg(&self) -> Box<dyn Arg>

fn as_function(&self) -> Option<&Func>

fn equals(&self, other: &dyn Expr) -> bool

fn as_symbol(&self) -> Option<Symbol>

fn as_eq(&self) -> Option<Equation>

fn as_mul(&self) -> Option<&Mul>

fn as_pow(&self) -> Option<&Pow>

fn as_f64(&self) -> Option<f64>

fn to_cpp(&self) -> String

fn simplify(&self) -> Box<dyn Expr>

fn simplify_with_dimension(&self, dim: usize) -> Box<dyn Expr>

fn as_int(&self) -> Option<Integer>

fn pow(&self, exponent: &Box<dyn Expr>) -> Box<dyn Expr>

fn ipow(&self, exponent: isize) -> Box<dyn Expr>

fn sqrt(&self) -> Box<dyn Expr>

fn get_exponent(&self) -> (Box<dyn Expr>, Box<dyn Expr>)

fn diff(&self, var: &str, order: usize) -> Box<dyn Expr>

fn name(&self) -> String

fn subs(&self, substitutions: &[[Box<dyn Expr>; 2]]) -> Box<dyn Expr>

fn has(&self, expr: &dyn Expr) -> bool

fn has_box(&self, expr: Box<dyn Expr>) -> bool

fn expand(&self) -> Box<dyn Expr>

Expands an expression. For example: (x + y) * z -> xz + yz

fn factor(&self, factors: &[&dyn Expr]) -> Box<dyn Expr>

Factorizes an expression For example: factor(ax + cx + zy, [x]) -> (a + c)x + zy

fn is_one(&self) -> bool

fn is_neg_one(&self) -> bool

fn is_number(&self) -> bool

fn is_negative_number(&self) -> bool

fn is_zero(&self) -> bool

fn known_expr(&self) -> KnownExpr<'_>

fn terms<'a>(&'a self) -> Box<dyn Iterator<Item = &'a dyn Expr> + 'a>

fn get_coeff(&self) -> (Rational, Box<dyn Expr>)

fn compare(&self, other: &dyn Expr) -> Option<Ordering>

fn evaluate(&self, vars: Option<HashMap<Symbol, BoxExpr>>) -> BoxExpr

Trait Implementations

impl Add<&(dyn Expr + 'static)> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Box<dyn Expr>> for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

fn add(self, rhs: Box<dyn Expr>) -> Self::Output

Performs the + operation.

impl Add<isize> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for &Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

fn add(self, rhs: &Box<dyn Expr>) -> Self::Output

Performs the + operation.

impl Add for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the + operator.

fn add(self, rhs: Box<dyn Expr>) -> Self::Output

Performs the + operation.

impl AddAssign for Box<dyn Expr>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Arg for Box<dyn Expr>

fn srepr(&self) -> String

fn clone_arg(&self) -> Box<dyn Arg>

fn as_expr(&self) -> Option<Box<dyn Expr>>

fn map_expr(&self, f: &dyn Fn(&dyn Expr) -> Box<dyn Expr>) -> Box<dyn Arg>

impl AsAny for Box<dyn Expr>

fn as_any(&self) -> &dyn Any

impl Clone for Box<dyn Expr>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for &dyn Expr

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

Formats the value using the given formatter.

impl Debug for Box<dyn Expr>

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

Formats the value using the given formatter.

impl Display for &dyn Expr

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

Formats the value using the given formatter.

impl Display for Box<dyn Expr>

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

Formats the value using the given formatter.

impl Div<&Box<dyn Expr>> for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the / operator.

fn div(self, rhs: &Box<dyn Expr>) -> Self::Output

Performs the / operation.

impl Div<&Box<dyn Expr>> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the / operator.

fn div(self, rhs: &Box<dyn Expr>) -> Self::Output

Performs the / operation.

impl<E: Expr> Div<&E> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&(dyn Expr + 'static)> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the / operator.

fn div(self, rhs: Box<dyn Expr>) -> Self::Output

Performs the / operation.

impl DivAssign<&(dyn Expr + 'static)> for Box<dyn Expr>

fn div_assign(&mut self, rhs: &dyn Expr)

Performs the /= operation.

impl DivAssign<&(dyn Expr + 'static)> for Equation

fn div_assign(&mut self, rhs: &dyn Expr)

Performs the /= operation.

impl<'a> From<&'a Add> for &'a dyn Expr

fn from(value: &'a Add) -> Self

Converts to this type from the input type.

impl From<Box<dyn Arg>> for Box<dyn Expr>

fn from(value: Box<dyn Arg>) -> Self

Converts to this type from the input type.

impl FromStr for Box<dyn Expr>

type Err = ParseExprError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl Hash for dyn Expr

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

impl JsonSchema for dyn Expr

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(_generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Mul<&Box<dyn Expr>> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

fn mul(self, rhs: &Box<dyn Expr>) -> Self::Output

Performs the * operation.

impl<E: Expr> Mul<&E> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&(dyn Expr + 'static)> for &Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&(dyn Expr + 'static)> for Add

type Output = Mul

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&(dyn Expr + 'static)> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Box<dyn Expr>> for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

fn mul(self, rhs: Box<dyn Expr>) -> Self::Output

Performs the * operation.

impl<N: NumCast> Mul<N> for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<isize> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for &Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

fn mul(self, rhs: &Box<dyn Expr>) -> Self::Output

Performs the * operation.

impl Mul for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the * operator.

fn mul(self, rhs: Box<dyn Expr>) -> Self::Output

Performs the * operation.

impl MulAssign<&Box<dyn Expr>> for Box<dyn Expr>

fn mul_assign(&mut self, rhs: &Box<dyn Expr>)

Performs the *= operation.

impl MulAssign<&(dyn Expr + 'static)> for Box<dyn Expr>

fn mul_assign(&mut self, rhs: &dyn Expr)

Performs the *= operation.

impl MulAssign for Box<dyn Expr>

fn mul_assign(&mut self, rhs: Box<dyn Expr>)

Performs the *= operation.

impl Neg for &Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq<&Box<dyn Expr>> for &dyn Expr

fn eq(&self, other: &&Box<dyn Expr>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<&(dyn Expr + 'static)> for Box<dyn Expr>

fn eq(&self, other: &&dyn Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq<Box<dyn Expr>> for &dyn Expr

fn eq(&self, other: &Box<dyn Expr>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for &dyn Expr

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialEq for Box<dyn Expr>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Sub<&Box<dyn Expr>> for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn sub(self, rhs: &Box<dyn Expr>) -> Self::Output

Performs the - operation.

impl Sub<Box<dyn Expr>> for &Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn sub(self, rhs: Box<dyn Expr>) -> Self::Output

Performs the - operation.

impl Sub for &Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn sub(self, rhs: &Box<dyn Expr>) -> Self::Output

Performs the - operation.

impl Sub for &dyn Expr

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Box<dyn Expr>

type Output = Box<dyn Expr>

The resulting type after applying the - operator.

fn sub(self, rhs: Box<dyn Expr>) -> Self::Output

Performs the - operation.

impl SubAssign<&(dyn Expr + 'static)> for Box<dyn Expr>

fn sub_assign(&mut self, rhs: &dyn Expr)

Performs the -= operation.

impl SubAssign<&(dyn Expr + 'static)> for Equation

fn sub_assign(&mut self, rhs: &dyn Expr)

Performs the -= operation.

impl Eq for &dyn Expr

impl Eq for Box<dyn Expr>

impl ExprOperations for &dyn Expr

Implementors

impl Expr for Add

impl Expr for Diff

impl Expr for Equation

impl Expr for Func

impl Expr for Integer

impl Expr for Integral

impl Expr for Mul

impl Expr for Pow

impl Expr for Rational

impl Expr for Symbol