Enum SymExpr 

pub enum SymExpr {
    Primary(Primary),
    Add(Vec<SymExpr>),
    Mul(Vec<SymExpr>),
    Exp(Box<SymExpr>, Box<SymExpr>),
}

A mathematical expression with information about its terms and factors.

This type should be distinguished from the cas_parser::parser::ast::Expr type, which is produced by cas_parser. The main difference is that this type flattens out the tree structure. For example, the expression x + (y + z) would be represented internally as a single SymExpr::Add node with three children, x, y, and z.

For more information about this type, see the module-level documentation.

Variants

Primary(Primary)

A single term or factor.

Add(Vec<SymExpr>)

Multiple terms added together.

Mul(Vec<SymExpr>)

Multiple factors multiplied together.

Exp(Box<SymExpr>, Box<SymExpr>)

An expression raised to a power.

Implementations

impl SymExpr

pub fn cmp_precedence(&self, other: &Self) -> Ordering

Returns true if the given expression has lower precedence than this expression.

This is used to determine if parentheses are needed around the given expression when printing.

pub fn as_integer(&self) -> Option<&Integer>

If the expression is a Primary::Integer, returns a reference to the contained integer.

pub fn into_integer(self) -> Option<Integer>

If the expression is a Primary::Integer, returns the contained integer.

pub fn is_integer(&self) -> bool

Returns true if the expression is a Primary::Integer.

pub fn is_integer_recip(&self) -> bool

Returns true if the expression is a Primary::Integer raised to the power of -1.

pub fn as_integer_recip(&self) -> Option<&Integer>

If the expression is a Primary::Integer raised to the power of -1, returns a reference to the contained integer (the denominator of the fraction).

pub fn into_integer_recip(self) -> Option<Integer>

If the expression is a Primary::Integer raised to the power of -1, returns the contained integer (the denominator of the fraction).

pub fn is_float(&self) -> bool

Returns true if the expression is a Primary::Float.

pub fn as_symbol(&self) -> Option<&str>

If the expression is a Primary::Symbol, returns a reference to the contained symbol.

pub fn sqrt(self) -> Self

Returns the square root of this expression. No simplification is done.

pub fn post_order_iter(&self) -> ExprIter<'_>

Returns an iterator that traverses the tree of expressions in left-to-right post-order (i.e. depth-first).

Trait Implementations

impl Add for SymExpr

Adds two SymExprs together. No simplification is done, except for the case where the operands are a mix of Primary and / or SymExpr::Add, in which case both are combined in one list of terms (flattening).

type Output = SymExpr

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for SymExpr

Adds two SymExprs together. The behavior is the same as Add, except we can reuse the allocated memory of self if possible.

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for SymExpr

fn clone(&self) -> SymExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymExpr

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

Formats the value using the given formatter.

impl Display for SymExpr

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

Formats the value using the given formatter.

impl From<Expr> for SymExpr

fn from(expr: AstExpr) -> Self

Converts to this type from the input type.

impl From<SymExpr> for Expr

fn from(expr: SymExpr) -> Self

Converts to this type from the input type.

impl Hash for SymExpr

Hash is manually implemented for SymExpr to ensure consistent behavior with PartialEq.

We also manage to hash SymExpr::Add and SymExpr::Mul in O(n) time by using a commutative hashing function, unaffected by the order of the elements.

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for SymExpr

Multiplies two SymExprs together. No simplification is done, except for the case where the operands are a mix of Primary and / or SymExpr::Mul, in which case both are combined in one list of factors (flattening).

type Output = SymExpr

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for SymExpr

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for SymExpr

Multiplies this expression by -1. No simplification is done, except for the case where the expression is a numeric Primary, in which case the number is negated.

type Output = SymExpr

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for SymExpr

Checks if two expressions are strictly equal.

Two expressions are strictly equal if:

• They are the same type of expression (i.e. both SymExpr::Primary, both SymExpr::Add, etc.).
• If both are SymExpr::Primary, both expressions must have strictly equal values.
• If both are SymExpr::Add or SymExpr::Mul, both expressions must have strictly equal terms / factors, in any order.
• If both are SymExpr::Exp, both expressions must have strictly equal base and exponent.

For more information about strict equality, see the module-level documentation.

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 Eq for SymExpr