Enum Expr 

pub enum Expr {
    Sym(String),
    Const(f64),
    Neg(E),
    Add(E, E),
    Sub(E, E),
    Mul(E, E),
    Div(E, E),
    Pow(E, E),
    Sin(E),
    Cos(E),
    Tan(E),
    Asin(E),
    Acos(E),
    Atan(E),
    Atan2(E, E),
    Sinh(E),
    Cosh(E),
    Tanh(E),
    Exp(E),
    Ln(E),
    Log2(E),
    Log10(E),
    Sqrt(E),
    Abs(E),
    Heaviside(E),
    Clamp(E, E, E),
    NamedConst {
        name: String,
        value: f64,
        rust_f32: String,
        rust_f64: String,
        latex: String,
    },
    Func {
        name: String,
        params: Vec<String>,
        kind: FuncKind,
        args: Vec<E>,
    },
}

Expression AST node.

Normally constructed via symbol, constant, and the free-standing math functions (e.g. sin, cos, pow) rather than directly.

Variants

Sym(String)

Named symbolic variable.

Const(f64)

Numeric constant.

Neg(E)

Unary negation.

Add(E, E)

Addition.

Sub(E, E)

Subtraction.

Mul(E, E)

Multiplication.

Div(E, E)

Division.

Pow(E, E)

Exponentiation (base^exponent).

Sin(E)

Sine.

Cos(E)

Cosine.

Tan(E)

Tangent.

Asin(E)

Arcsine.

Acos(E)

Arccosine.

Atan(E)

Arctangent.

Atan2(E, E)

Two-argument arctangent (atan2(y, x)).

Sinh(E)

Hyperbolic sine.

Cosh(E)

Hyperbolic cosine.

Tanh(E)

Hyperbolic tangent.

Exp(E)

Exponential (e^x).

Ln(E)

Natural logarithm.

Log2(E)

Base-2 logarithm.

Log10(E)

Base-10 logarithm.

Sqrt(E)

Square root.

Abs(E)

Absolute value.

Heaviside(E)

Heaviside step function: 0 if x < 0, 1 if x >= 0. Derivative is 0.

Clamp(E, E, E)

Clamp value to [lo, hi]. Derivative passes through (= d(val)/dvar).

NamedConst

Named constant (pi, epsilon, e, or user-defined). Survives simplification (unlike Const which may be folded away).

Fields

name: String

value: f64

rust_f32: String

rust_f64: String

latex: String

Func

User-defined function application.

Fields

name: String

Function name (for display).

params: Vec<String>

Formal parameter names.

kind: FuncKind

Function behavior (differentiation, codegen, eval).

args: Vec<E>

Actual argument expressions.

Implementations

impl Expr

pub fn diff(&self, var: impl AsVarName) -> E

Symbolically differentiate this expression with respect to a variable.

Applies the chain rule, product rule, and quotient rule automatically. The result is simplified.

impl Expr

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

Evaluate the expression numerically given variable bindings.

Returns Err if any symbol in the expression is not bound in vars.

pub fn subs(&self, var: impl AsVarName, replacement: &E) -> E

Substitute all occurrences of the named variable with replacement.

var can be any [AsVarName] – a &str, a String, or an E handle wrapping a Sym node. Returns a new expression with the substitution applied throughout.

pub fn free_vars(&self) -> BTreeSet<String>

Collect all free (unbound) variable names in the expression.

Returns a sorted set of variable name strings.

pub fn diff_all(&self, vars: &[&str]) -> Vec<E>

Differentiate with respect to multiple variables, returning a vector.

Equivalent to calling Expr::diff for each variable in order.

impl Expr

pub fn to_latex(&self) -> String

Format the expression as LaTeX math notation.

Produces a string suitable for embedding in LaTeX documents, using \frac, \sqrt, \sin, etc.

pub fn to_rust(&self, float_type: &str) -> String

Generate Rust source code for this expression.

The float_type parameter (e.g. "f64") controls numeric literal suffixes. Pass an empty string to omit type suffixes.

impl Expr

pub fn simplify(&self) -> E

Apply algebraic simplification rules.

Performs constant folding, identity elimination (0+x=x, 1*x=x), like-term collection, power combination, fraction cancellation, and canonical ordering. Iterates until a fixed point is reached.

pub fn expand(&self) -> E

Expand products and integer powers over sums.

Distributes multiplication: (a + b) * c becomes a*c + b*c. Integer powers up to 8 are expanded: (a + b)^3 becomes the full multinomial expansion. The result is simplified afterwards.

pub fn collect(&self, var: impl AsVarName) -> E

Collect like terms containing var by structural match.

var can be any [AsVarName] – a &str, a String, or an E handle wrapping a Sym node. Groups additive terms that share var as a factor, summing their coefficients. For example, a*x + b*x + c becomes (a + b)*x + c.

Trait Implementations

impl AsRef<Expr> for E

fn as_ref(&self) -> &Expr

Converts this type into a shared reference of the (usually inferred) input type.

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

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

impl StructuralPartialEq for Expr