Enum Expr 

pub enum Expr {
    Const(f64),
    Var(String),
    Add(Box<Expr>, Box<Expr>),
    Mul(Box<Expr>, Box<Expr>),
    Pow(Box<Expr>, Box<Expr>),
    Neg(Box<Expr>),
    Fn(MathFn, Box<Expr>),
}

A symbolic expression AST.

Sub is represented as Add(a, Neg(b)) and Div as Mul(a, Pow(b, Const(-1))).

Examples

let expr = var("x") + constant(1.0);
let mut vars = HashMap::new();
vars.insert("x".to_string(), 2.0);
assert!((expr.eval(&vars).unwrap() - 3.0).abs() < 1e-10);

Variants

Const(f64)

Numeric constant.

Var(String)

Named variable.

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

Addition: lhs + rhs.

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

Multiplication: lhs * rhs.

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

Exponentiation: base ^ exp.

Neg(Box<Expr>)

Negation: -expr.

Fn(MathFn, Box<Expr>)

Function application: f(arg).

Implementations

impl Expr

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

Evaluate the expression given concrete variable bindings.

Examples

let expr = constant(2.0) * var("x") + constant(1.0);
let vars = HashMap::from([("x".to_string(), 3.0)]);
assert!((expr.eval(&vars).unwrap() - 7.0).abs() < 1e-10);

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

Replace every occurrence of var with replacement.

Examples

let expr = var("x") + constant(1.0);
let replaced = expr.substitute("x", &constant(5.0));
assert!((replaced.eval(&HashMap::new()).unwrap() - 6.0).abs() < 1e-10);

pub fn free_variables(&self) -> HashSet<String>

Collect all free variable names in the expression.

Examples

let expr = var("x") + var("y") * constant(2.0);
let vars = expr.free_variables();
assert!(vars.contains("x"));
assert!(vars.contains("y"));
assert_eq!(vars.len(), 2);

pub fn is_zero(&self) -> bool

Returns true if the expression is Const(0.0).

Examples

assert!(constant(0.0).is_zero());
assert!(!constant(1.0).is_zero());

pub fn is_one(&self) -> bool

Returns true if the expression is Const(1.0).

Examples

assert!(constant(1.0).is_one());
assert!(!constant(2.0).is_one());

pub fn is_const(&self) -> bool

Returns true if the expression is a constant.

Examples

assert!(constant(3.14).is_const());
assert!(!var("x").is_const());

pub fn as_const(&self) -> Option<f64>

If the expression is a constant, return its value.

Examples

assert_eq!(constant(42.0).as_const(), Some(42.0));
assert_eq!(var("x").as_const(), None);

Trait Implementations

impl Add for Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

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 Div for Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Mul for Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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 Sub for Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl StructuralPartialEq for Expr