Enum Expr 

pub enum Expr {
    Var(String),
    Const(f64),
    Neg(Box<Expr>),
    Add(Box<Expr>, Box<Expr>),
    Sub(Box<Expr>, Box<Expr>),
    Mul(Box<Expr>, Box<Expr>),
    Div(Box<Expr>, Box<Expr>),
    Pow(Box<Expr>, Box<Expr>),
    Sin(Box<Expr>),
    Cos(Box<Expr>),
    Tan(Box<Expr>),
    Ln(Box<Expr>),
    Exp(Box<Expr>),
    Sqrt(Box<Expr>),
    Abs(Box<Expr>),
    Floor(Box<Expr>),
    Ceil(Box<Expr>),
    Atan(Box<Expr>),
    Atan2(Box<Expr>, Box<Expr>),
    Sum {
        body: Box<Expr>,
        var: String,
        from: Box<Expr>,
        to: Box<Expr>,
    },
    Product {
        body: Box<Expr>,
        var: String,
        from: Box<Expr>,
        to: Box<Expr>,
    },
    Integral {
        body: Box<Expr>,
        var: String,
    },
    Derivative {
        body: Box<Expr>,
        var: String,
    },
}

A symbolic mathematical expression.

Variants

Var(String)

Named variable: x, y, t, etc.

Const(f64)

Numeric constant.

Neg(Box<Expr>)

Negation: -a.

Add(Box<Expr>, Box<Expr>)

Addition: a + b.

Sub(Box<Expr>, Box<Expr>)

Subtraction: a - b.

Mul(Box<Expr>, Box<Expr>)

Multiplication: a * b.

Div(Box<Expr>, Box<Expr>)

Division: a / b.

Pow(Box<Expr>, Box<Expr>)

Power: a^b.

Sin(Box<Expr>)

Sine.

Cos(Box<Expr>)

Cosine.

Tan(Box<Expr>)

Tangent.

Ln(Box<Expr>)

Natural logarithm.

Exp(Box<Expr>)

Exponential: e^a.

Sqrt(Box<Expr>)

Square root.

Abs(Box<Expr>)

Absolute value.

Floor(Box<Expr>)

Floor function.

Ceil(Box<Expr>)

Ceiling function.

Atan(Box<Expr>)

Arctangent.

Atan2(Box<Expr>, Box<Expr>)

Atan2(y, x).

Sum

Summation: Σ(body, var, from, to).

Fields

body: Box<Expr>

var: String

from: Box<Expr>

to: Box<Expr>

Product

Product: Π(body, var, from, to).

Fields

body: Box<Expr>

var: String

from: Box<Expr>

to: Box<Expr>

Integral

Integral: ∫(body, var).

Fields

body: Box<Expr>

var: String

Derivative

Derivative: d/dvar(body).

Fields

body: Box<Expr>

var: String

Implementations

impl Expr

pub fn var(name: &str) -> Self

pub fn c(val: f64) -> Self

pub fn zero() -> Self

pub fn one() -> Self

pub fn pi() -> Self

pub fn e() -> Self

pub fn add(self, other: Expr) -> Expr

pub fn sub(self, other: Expr) -> Expr

pub fn mul(self, other: Expr) -> Expr

pub fn div(self, other: Expr) -> Expr

pub fn pow(self, exp: Expr) -> Expr

pub fn neg(self) -> Expr

pub fn sin(self) -> Expr

pub fn cos(self) -> Expr

pub fn tan(self) -> Expr

pub fn ln(self) -> Expr

pub fn exp(self) -> Expr

pub fn sqrt(self) -> Expr

pub fn abs(self) -> Expr

pub fn eval(&self, vars: &HashMap<String, f64>) -> f64

Evaluate the expression with variable bindings.

pub fn contains_var(&self, var: &str) -> bool

Whether this expression contains the given variable.

pub fn is_constant(&self) -> bool

Whether this is a constant (no variables).

pub fn substitute(&self, var: &str, replacement: &Expr) -> Expr

Substitute a variable with an expression.

pub fn node_count(&self) -> usize

Count the number of nodes in the expression tree.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

fn eq(&self, other: &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 StructuralPartialEq for Expr