Enum Expr 

pub enum Expr {
    Constant(f64),
    BigInt(BigInt),
    Rational(BigRational),
    Boolean(bool),
    Variable(String),
    Pattern(String),
    Add(Arc<Self>, Arc<Self>),
    Sub(Arc<Self>, Arc<Self>),
    Mul(Arc<Self>, Arc<Self>),
    Div(Arc<Self>, Arc<Self>),
    Power(Arc<Self>, Arc<Self>),
    Neg(Arc<Self>),
    AddList(Vec<Self>),
    MulList(Vec<Self>),
    Sin(Arc<Self>),
    Cos(Arc<Self>),
    Tan(Arc<Self>),
    Exp(Arc<Self>),
    Log(Arc<Self>),
    Abs(Arc<Self>),
    Sqrt(Arc<Self>),
    Eq(Arc<Self>, Arc<Self>),
    Lt(Arc<Self>, Arc<Self>),
    Gt(Arc<Self>, Arc<Self>),
    Le(Arc<Self>, Arc<Self>),
    Ge(Arc<Self>, Arc<Self>),
    Matrix(Vec<Vec<Self>>),
    Vector(Vec<Self>),
    Complex(Arc<Self>, Arc<Self>),
    Transpose(Arc<Self>),
    MatrixMul(Arc<Self>, Arc<Self>),
    MatrixVecMul(Arc<Self>, Arc<Self>),
    Inverse(Arc<Self>),
    Derivative(Arc<Self>, String),
    DerivativeN(Arc<Self>, String, Arc<Self>),
    Integral {
        integrand: Arc<Self>,
        var: Arc<Self>,
        lower_bound: Arc<Self>,
        upper_bound: Arc<Self>,
    },
    VolumeIntegral {
        scalar_field: Arc<Self>,
        volume: Arc<Self>,
    },
    SurfaceIntegral {
        vector_field: Arc<Self>,
        surface: Arc<Self>,
    },
    Limit(Arc<Self>, String, Arc<Self>),
    Sum {
        body: Arc<Self>,
        var: Arc<Self>,
        from: Arc<Self>,
        to: Arc<Self>,
    },
    Series(Arc<Self>, String, Arc<Self>, Arc<Self>),
    Summation(Arc<Self>, String, Arc<Self>, Arc<Self>),
    Product(Arc<Self>, String, Arc<Self>, Arc<Self>),
    ConvergenceAnalysis(Arc<Self>, String),
    AsymptoticExpansion(Arc<Self>, String, Arc<Self>, Arc<Self>),
    IndefiniteSum {
        body: Arc<Self>,
        var: String,
        step: Arc<Self>,
    },
    IndefiniteProduct {
        body: Arc<Self>,
        var: String,
        step: Arc<Self>,
    },
    Sec(Arc<Self>),
    Csc(Arc<Self>),
    Cot(Arc<Self>),
    ArcSin(Arc<Self>),
    ArcCos(Arc<Self>),
    ArcTan(Arc<Self>),
    ArcSec(Arc<Self>),
    ArcCsc(Arc<Self>),
    ArcCot(Arc<Self>),
    Sinh(Arc<Self>),
    Cosh(Arc<Self>),
    Tanh(Arc<Self>),
    Sech(Arc<Self>),
    Csch(Arc<Self>),
    Coth(Arc<Self>),
    ArcSinh(Arc<Self>),
    ArcCosh(Arc<Self>),
    ArcTanh(Arc<Self>),
    ArcSech(Arc<Self>),
    ArcCsch(Arc<Self>),
    ArcCoth(Arc<Self>),
    LogBase(Arc<Self>, Arc<Self>),
    Atan2(Arc<Self>, Arc<Self>),
    Binomial(Arc<Self>, Arc<Self>),
    Factorial(Arc<Self>),
    Permutation(Arc<Self>, Arc<Self>),
    Combination(Arc<Self>, Arc<Self>),
    FallingFactorial(Arc<Self>, Arc<Self>),
    RisingFactorial(Arc<Self>, Arc<Self>),
    Path(PathType, Arc<Self>, Arc<Self>),
    Boundary(Arc<Self>),
    Domain(String),
    Pi,
    E,
    Infinity,
    NegativeInfinity,
    Gamma(Arc<Self>),
    Beta(Arc<Self>, Arc<Self>),
    Erf(Arc<Self>),
    Erfc(Arc<Self>),
    Erfi(Arc<Self>),
    Zeta(Arc<Self>),
    BesselJ(Arc<Self>, Arc<Self>),
    BesselY(Arc<Self>, Arc<Self>),
    LegendreP(Arc<Self>, Arc<Self>),
    LaguerreL(Arc<Self>, Arc<Self>),
    HermiteH(Arc<Self>, Arc<Self>),
    Digamma(Arc<Self>),
    KroneckerDelta(Arc<Self>, Arc<Self>),
    And(Vec<Self>),
    Or(Vec<Self>),
    Not(Arc<Self>),
    Xor(Arc<Self>, Arc<Self>),
    Implies(Arc<Self>, Arc<Self>),
    Equivalent(Arc<Self>, Arc<Self>),
    Predicate {
        name: String,
        args: Vec<Self>,
    },
    ForAll(String, Arc<Self>),
    Exists(String, Arc<Self>),
    Union(Vec<Self>),
    Interval(Arc<Self>, Arc<Self>, bool, bool),
    Polynomial(Vec<Self>),
    SparsePolynomial(SparsePolynomial),
    Floor(Arc<Self>),
    IsPrime(Arc<Self>),
    Gcd(Arc<Self>, Arc<Self>),
    Mod(Arc<Self>, Arc<Self>),
    Solve(Arc<Self>, String),
    Substitute(Arc<Self>, String, Arc<Self>),
    System(Vec<Self>),
    Solutions(Vec<Self>),
    ParametricSolution {
        x: Arc<Self>,
        y: Arc<Self>,
    },
    RootOf {
        poly: Arc<Self>,
        index: u32,
    },
    InfiniteSolutions,
    NoSolution,
    Ode {
        equation: Arc<Self>,
        func: String,
        var: String,
    },
    Pde {
        equation: Arc<Self>,
        func: String,
        vars: Vec<String>,
    },
    GeneralSolution(Arc<Self>),
    ParticularSolution(Arc<Self>),
    Fredholm(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>),
    Volterra(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>),
    Apply(Arc<Self>, Arc<Self>),
    Tuple(Vec<Self>),
    Dag(Arc<DagNode>),
    Distribution(Arc<dyn Distribution>),
    Max(Arc<Self>, Arc<Self>),
    Quantity(Arc<UnitQuantity>),
    QuantityWithValue(Arc<Self>, String),
    CustomZero,
    CustomString(String),
    CustomArcOne(Arc<Self>),
    CustomArcTwo(Arc<Self>, Arc<Self>),
    CustomArcThree(Arc<Self>, Arc<Self>, Arc<Self>),
    CustomArcFour(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>),
    CustomArcFive(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>),
    CustomVecOne(Vec<Self>),
    CustomVecTwo(Vec<Self>, Vec<Self>),
    CustomVecThree(Vec<Self>, Vec<Self>, Vec<Self>),
    CustomVecFour(Vec<Self>, Vec<Self>, Vec<Self>, Vec<Self>),
    CustomVecFive(Vec<Self>, Vec<Self>, Vec<Self>, Vec<Self>, Vec<Self>),
    UnaryList(String, Arc<Self>),
    BinaryList(String, Arc<Self>, Arc<Self>),
    NaryList(String, Vec<Self>),
}

The central enum representing a mathematical expression in the symbolic system.

Expr is an Abstract Syntax Tree (AST) that can represent a wide variety of mathematical objects and operations. Manual implementations for Debug, Clone, PartialEq, Eq, and Hash are provided to handle variants containing types that do not derive these traits automatically (e.g., f64, Arc<dyn Distribution>).

Variants

Constant(f64)

A floating-point constant (64-bit).

BigInt(BigInt)

An arbitrary-precision integer.

Rational(BigRational)

An arbitrary-precision rational number.

Boolean(bool)

A boolean value (true or false).

Variable(String)

A symbolic variable, represented by a string name.

Pattern(String)

A pattern variable, used for rule-matching systems.

Add(Arc<Self>, Arc<Self>)

Addition of two expressions.

Sub(Arc<Self>, Arc<Self>)

Subtraction of two expressions.

Mul(Arc<Self>, Arc<Self>)

Multiplication of two expressions.

Div(Arc<Self>, Arc<Self>)

Division of two expressions.

Power(Arc<Self>, Arc<Self>)

Exponentiation (base raised to the power of exponent).

Neg(Arc<Self>)

Negation of an expression.

AddList(Vec<Self>)

N-ary Addition (Sum of a list of expressions).

This variant represents the sum of multiple expressions in a single operation, which is more efficient than nested binary Add operations for associative operations. It’s part of the AST to DAG migration strategy, allowing for more flexible expression representation without breaking existing code.

Examples

use rssn::symbolic::core::Expr;

// Representing a + b + c + d as a single n-ary operation
let sum = Expr::AddList(vec![
    Expr::Variable("a".to_string()),
    Expr::Variable("b".to_string()),
    Expr::Variable("c".to_string()),
    Expr::Variable("d".to_string()),
]);

MulList(Vec<Self>)

N-ary Multiplication (Product of a list of expressions).

This variant represents the product of multiple expressions in a single operation, which is more efficient than nested binary Mul operations for associative operations. It’s part of the AST to DAG migration strategy, allowing for more flexible expression representation without breaking existing code.

Examples

use rssn::symbolic::core::Expr;

// Representing a * b * c * d as a single n-ary operation
let product = Expr::MulList(vec![
    Expr::Variable("a".to_string()),
    Expr::Variable("b".to_string()),
    Expr::Variable("c".to_string()),
    Expr::Variable("d".to_string()),
]);

Sin(Arc<Self>)

The sine function.

Cos(Arc<Self>)

The cosine function.

Tan(Arc<Self>)

The tangent function.

Exp(Arc<Self>)

The natural exponential function, e^x.

Log(Arc<Self>)

The natural logarithm, ln(x).

Abs(Arc<Self>)

The absolute value function, |x|.

Sqrt(Arc<Self>)

The square root function.

Eq(Arc<Self>, Arc<Self>)

Represents an equation (left = right).

Lt(Arc<Self>, Arc<Self>)

Less than (<).

Gt(Arc<Self>, Arc<Self>)

Greater than (>).

Le(Arc<Self>, Arc<Self>)

Less than or equal to (<=).

Ge(Arc<Self>, Arc<Self>)

Greater than or equal to (>=).

Matrix(Vec<Vec<Self>>)

A matrix, represented as a vector of row vectors.

Vector(Vec<Self>)

A vector (or column matrix).

Complex(Arc<Self>, Arc<Self>)

A complex number with real and imaginary parts.

Transpose(Arc<Self>)

Matrix transpose.

MatrixMul(Arc<Self>, Arc<Self>)

Matrix-matrix multiplication.

MatrixVecMul(Arc<Self>, Arc<Self>)

Matrix-vector multiplication.

Inverse(Arc<Self>)

Matrix inverse.

Derivative(Arc<Self>, String)

The derivative of an expression with respect to a variable.

DerivativeN(Arc<Self>, String, Arc<Self>)

The N-th derivative of an expression.

Integral

A definite integral of integrand with respect to var from lower_bound to upper_bound.

Fields

integrand: Arc<Self>

The expression to be integrated.

var: Arc<Self>

The variable of integration.

lower_bound: Arc<Self>

The lower limit of integration.

upper_bound: Arc<Self>

The upper limit of integration.

VolumeIntegral

A volume integral of a scalar field over a specified volume.

Fields

scalar_field: Arc<Self>

The scalar field to be integrated over the volume.

volume: Arc<Self>

The volume domain.

SurfaceIntegral

A surface integral of a vector field over a specified surface.

Fields

vector_field: Arc<Self>

The vector field to be integrated over the surface.

surface: Arc<Self>

The surface domain.

Limit(Arc<Self>, String, Arc<Self>)

A limit of an expression as a variable approaches a point.

Sum

A summation of body with var from from to to.

Fields

body: Arc<Self>

The expression to be summed.

var: Arc<Self>

The summation variable.

from: Arc<Self>

The starting value of the summation variable.

to: Arc<Self>

The ending value of the summation variable.

Series(Arc<Self>, String, Arc<Self>, Arc<Self>)

A finite or infinite series expansion.

Summation(Arc<Self>, String, Arc<Self>, Arc<Self>)

A summation over a range (similar to Sum).

Product(Arc<Self>, String, Arc<Self>, Arc<Self>)

A product of terms over a range.

ConvergenceAnalysis(Arc<Self>, String)

Represents a convergence analysis for a series.

AsymptoticExpansion(Arc<Self>, String, Arc<Self>, Arc<Self>)

An asymptotic expansion of a function.

IndefiniteSum

An indefinite sum (anti-difference) of body with variable var and step size step.

Fields

body: Arc<Self>

The expression to be summed.

var: String

The summation variable.

step: Arc<Self>

The step size.

IndefiniteProduct

An indefinite product of body with variable var and step size step.

Fields

body: Arc<Self>

The expression to be multiplied.

var: String

The product variable.

step: Arc<Self>

The step size.

Sec(Arc<Self>)

Secant function.

Csc(Arc<Self>)

Cosecant function.

Cot(Arc<Self>)

Cotangent function.

ArcSin(Arc<Self>)

Arcsine (inverse sine).

ArcCos(Arc<Self>)

Arccosine (inverse cosine).

ArcTan(Arc<Self>)

Arctangent (inverse tangent).

ArcSec(Arc<Self>)

Arcsecant (inverse secant).

ArcCsc(Arc<Self>)

Arccosecant (inverse cosecant).

ArcCot(Arc<Self>)

Arccotangent (inverse cotangent).

Sinh(Arc<Self>)

Hyperbolic sine.

Cosh(Arc<Self>)

Hyperbolic cosine.

Tanh(Arc<Self>)

Hyperbolic tangent.

Sech(Arc<Self>)

Hyperbolic secant.

Csch(Arc<Self>)

Hyperbolic cosecant.

Coth(Arc<Self>)

Hyperbolic cotangent.

ArcSinh(Arc<Self>)

Inverse hyperbolic sine.

ArcCosh(Arc<Self>)

Inverse hyperbolic cosine.

ArcTanh(Arc<Self>)

Inverse hyperbolic tangent.

ArcSech(Arc<Self>)

Inverse hyperbolic secant.

ArcCsch(Arc<Self>)

Inverse hyperbolic cosecant.

ArcCoth(Arc<Self>)

Inverse hyperbolic cotangent.

LogBase(Arc<Self>, Arc<Self>)

Logarithm with a specified base.

Atan2(Arc<Self>, Arc<Self>)

Two-argument arctangent.

Binomial(Arc<Self>, Arc<Self>)

Binomial coefficient, “n choose k”.

Factorial(Arc<Self>)

Factorial, n!.

Permutation(Arc<Self>, Arc<Self>)

Permutations, P(n, k).

Combination(Arc<Self>, Arc<Self>)

Combinations, C(n, k).

FallingFactorial(Arc<Self>, Arc<Self>)

Falling factorial.

RisingFactorial(Arc<Self>, Arc<Self>)

Rising factorial.

Path(PathType, Arc<Self>, Arc<Self>)

A path for path integrals (e.g., line, circle).

Boundary(Arc<Self>)

Represents the boundary of a domain.

Domain(String)

Represents a named domain (e.g., for integrals).

Pi

The mathematical constant Pi (π).

E

The mathematical constant E (e, Euler’s number).

Infinity

Represents infinity.

NegativeInfinity

Represents negative infinity.

Gamma(Arc<Self>)

The Gamma function.

Beta(Arc<Self>, Arc<Self>)

The Beta function.

Erf(Arc<Self>)

The error function.

Erfc(Arc<Self>)

The complementary error function.

Erfi(Arc<Self>)

The imaginary error function.

Zeta(Arc<Self>)

The Riemann Zeta function.

BesselJ(Arc<Self>, Arc<Self>)

Bessel function of the first kind.

BesselY(Arc<Self>, Arc<Self>)

Bessel function of the second kind.

LegendreP(Arc<Self>, Arc<Self>)

Legendre polynomial.

LaguerreL(Arc<Self>, Arc<Self>)

Laguerre polynomial.

HermiteH(Arc<Self>, Arc<Self>)

Hermite polynomial.

Digamma(Arc<Self>)

The digamma function (psi function).

KroneckerDelta(Arc<Self>, Arc<Self>)

The Kronecker delta function.

And(Vec<Self>)

Logical AND of a vector of expressions.

Or(Vec<Self>)

Logical OR of a vector of expressions.

Not(Arc<Self>)

Logical NOT.

Xor(Arc<Self>, Arc<Self>)

Logical XOR (exclusive OR).

Implies(Arc<Self>, Arc<Self>)

Logical implication (A => B).

Equivalent(Arc<Self>, Arc<Self>)

Logical equivalence (A <=> B).

Predicate

A predicate with a name and arguments.

Fields

name: String

The name of the predicate.

args: Vec<Self>

The arguments to the predicate.

ForAll(String, Arc<Self>)

Universal quantifier (“for all”).

Exists(String, Arc<Self>)

Existential quantifier (“there exists”).

Union(Vec<Self>)

A union of sets or intervals.

Interval(Arc<Self>, Arc<Self>, bool, bool)

An interval with a lower and upper bound, and flags for inclusion.

Polynomial(Vec<Self>)

A dense polynomial represented by its coefficients.

SparsePolynomial(SparsePolynomial)

A sparse polynomial.

Floor(Arc<Self>)

The floor function.

IsPrime(Arc<Self>)

A predicate to check if a number is prime.

Gcd(Arc<Self>, Arc<Self>)

Greatest Common Divisor (GCD).

Mod(Arc<Self>, Arc<Self>)

Modulo operation.

Solve(Arc<Self>, String)

Represents the action of solving an equation for a variable.

Substitute(Arc<Self>, String, Arc<Self>)

Represents the substitution of a variable in an expression with another expression.

System(Vec<Self>)

Represents a system of equations to be solved.

Solutions(Vec<Self>)

Represents the set of solutions to an equation or system.

ParametricSolution

A parametric solution, e.g., for a system of ODEs.

Fields

x: Arc<Self>

The x-component of the parametric solution.

y: Arc<Self>

The y-component of the parametric solution.

RootOf

Represents the i-th root of a polynomial.

Fields

poly: Arc<Self>

The polynomial to find the root of.

index: u32

The index of the root (for polynomials with multiple roots).

InfiniteSolutions

Represents infinite solutions.

NoSolution

Represents that no solution exists.

Ode

An ordinary differential equation (ODE).

Fields

equation: Arc<Self>

The differential equation.

func: String

The unknown function name.

var: String

The independent variable name.

Pde

A partial differential equation (PDE).

Fields

equation: Arc<Self>

The partial differential equation.

func: String

The unknown function name.

vars: Vec<String>

The independent variable names.

GeneralSolution(Arc<Self>)

The general solution to a differential equation.

ParticularSolution(Arc<Self>)

A particular solution to a differential equation.

Fredholm(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>)

A Fredholm integral equation.

Volterra(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>)

A Volterra integral equation.

Apply(Arc<Self>, Arc<Self>)

Application of a function to an argument.

Tuple(Vec<Self>)

A tuple of expressions.

Dag(Arc<DagNode>)

A node in a Directed Acyclic Graph (DAG) for expression sharing.

This is now the preferred representation for all expressions. When serialized, the DAG structure is preserved.

Distribution(Arc<dyn Distribution>)

A probability distribution.

Max(Arc<Self>, Arc<Self>)

Maximum of two expressions.

Quantity(Arc<UnitQuantity>)

A unified quantity with its value and unit string.

QuantityWithValue(Arc<Self>, String)

A temporary representation of a value with a unit string, before unification.

CustomZero

👎Deprecated since 0.1.18:

Please use the ‘UnaryList’ variant instead.

Deprecated: Zero-argument custom operation.

CustomString(String)

👎Deprecated since 0.1.18:

Please use the ‘UnaryList’ variant instead.

Deprecated: String-argument custom operation.

CustomArcOne(Arc<Self>)

👎Deprecated since 0.1.18:

Please use the ‘UnaryList’ variant instead.

Deprecated: One-arc-argument custom operation.

CustomArcTwo(Arc<Self>, Arc<Self>)

👎Deprecated since 0.1.18:

Please use the ‘BinaryList’ variant instead.

Deprecated: Two-arc-argument custom operation.

CustomArcThree(Arc<Self>, Arc<Self>, Arc<Self>)

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Deprecated: Three-arc-argument custom operation.

CustomArcFour(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>)

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Deprecated: Four-arc-argument custom operation.

CustomArcFive(Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>, Arc<Self>)

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Deprecated: Five-arc-argument custom operation.

CustomVecOne(Vec<Self>)

👎Deprecated since 0.1.18:

Please use the ‘UnaryList’ variant instead.

Deprecated: One-vector-argument custom operation.

CustomVecTwo(Vec<Self>, Vec<Self>)

👎Deprecated since 0.1.18:

Please use the ‘BinaryList’ variant instead.

Deprecated: Two-vector-argument custom operation.

CustomVecThree(Vec<Self>, Vec<Self>, Vec<Self>)

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Deprecated: Three-vector-argument custom operation.

CustomVecFour(Vec<Self>, Vec<Self>, Vec<Self>, Vec<Self>)

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Deprecated: Four-vector-argument custom operation.

CustomVecFive(Vec<Self>, Vec<Self>, Vec<Self>, Vec<Self>, Vec<Self>)

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Deprecated: Five-vector-argument custom operation.

UnaryList(String, Arc<Self>)

Generic unary operation identified by a name.

This variant allows for extensible unary operations without modifying the Expr enum. Operations are registered in the DYNAMIC_OP_REGISTRY with their properties (associativity, commutativity, etc.). This is part of the plugin system and future-proofing strategy.

Examples

use std::sync::Arc;

use rssn::symbolic::core::DynamicOpProperties;
use rssn::symbolic::core::Expr;
use rssn::symbolic::core::register_dynamic_op;

// Register a custom operation
register_dynamic_op(
    "my_func",
    DynamicOpProperties {
        name: "my_func".to_string(),
        description: "My custom function".to_string(),
        is_associative: false,
        is_commutative: false,
    },
);

// Use it
let expr = Expr::UnaryList(
    "my_func".to_string(),
    Arc::new(Expr::Variable("x".to_string())),
);

BinaryList(String, Arc<Self>, Arc<Self>)

Generic binary operation identified by a name.

This variant allows for extensible binary operations without modifying the Expr enum. Operations are registered in the DYNAMIC_OP_REGISTRY with their properties.

Examples

use std::sync::Arc;

use rssn::symbolic::core::DynamicOpProperties;
use rssn::symbolic::core::Expr;
use rssn::symbolic::core::register_dynamic_op;

// Register a custom binary operation
register_dynamic_op(
    "my_binop",
    DynamicOpProperties {
        name: "my_binop".to_string(),
        description: "My custom binary operation".to_string(),
        is_associative: true,
        is_commutative: true,
    },
);

// Use it
let expr = Expr::BinaryList(
    "my_binop".to_string(),
    Arc::new(Expr::Variable("x".to_string())),
    Arc::new(Expr::Variable("y".to_string())),
);

NaryList(String, Vec<Self>)

Generic n-ary operation identified by a name.

This variant allows for extensible n-ary operations without modifying the Expr enum. Operations are registered in the DYNAMIC_OP_REGISTRY with their properties. This is particularly useful for operations that can take a variable number of arguments.

Examples

use rssn::symbolic::core::DynamicOpProperties;
use rssn::symbolic::core::Expr;
use rssn::symbolic::core::register_dynamic_op;

// Register a custom n-ary operation
register_dynamic_op(
    "my_nary",
    DynamicOpProperties {
        name: "my_nary".to_string(),
        description: "My custom n-ary operation".to_string(),
        is_associative: true,
        is_commutative: false,
    },
);

// Use it
let expr = Expr::NaryList(
    "my_nary".to_string(),
    vec![
        Expr::Variable("a".to_string()),
        Expr::Variable("b".to_string()),
        Expr::Variable("c".to_string()),
    ],
);

Implementations

impl Expr

pub fn new_sin<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Sin

pub fn new_cos<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Cos

pub fn new_tan<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Tan

pub fn new_exp<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Exp

pub fn new_log<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Log

pub fn new_neg<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Neg

pub fn new_abs<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Abs

pub fn new_sqrt<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Sqrt

pub fn new_transpose<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Transpose

pub fn new_inverse<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Inverse

pub fn new_sec<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Sec

pub fn new_csc<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Csc

pub fn new_cot<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Cot

pub fn new_arcsin<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcSin

pub fn new_arccos<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcCos

pub fn new_arctan<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcTan

pub fn new_arcsec<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcSec

pub fn new_arccsc<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcCsc

pub fn new_arccot<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcCot

pub fn new_sinh<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Sinh

pub fn new_cosh<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Cosh

pub fn new_tanh<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Tanh

pub fn new_sech<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Sech

pub fn new_csch<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Csch

pub fn new_coth<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Coth

pub fn new_arcsinh<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcSinh

pub fn new_arccosh<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcCosh

pub fn new_arctanh<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcTanh

pub fn new_arcsech<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcSech

pub fn new_arccsch<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcCsch

pub fn new_arccoth<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. ArcCoth

pub fn new_not<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Not

pub fn new_floor<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Floor

pub fn new_gamma<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Gamma

pub fn new_erf<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Erf

pub fn new_erfc<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Erfc

pub fn new_erfi<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Erfi

pub fn new_zeta<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Zeta

pub fn new_digamma<A>(a: A) -> Expr

where A: AsRef<Expr>,

Creates a new expression, managed by the DAG. Digamma

pub fn new_add<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Add

pub fn new_sub<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Sub

pub fn new_mul<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Mul

pub fn new_div<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Div

pub fn new_pow<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Power

pub fn new_complex<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Complex

pub fn new_matrix_mul<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. MatrixMul

pub fn new_matrix_vec_mul<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. MatrixVecMul

pub fn new_log_base<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. LogBase

pub fn new_atan2<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Atan2

pub fn new_xor<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Xor

pub fn new_implies<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Implies

pub fn new_equivalent<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Equivalent

pub fn new_beta<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Beta

pub fn new_bessel_j<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. BesselJ

pub fn new_bessel_y<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. BesselY

pub fn new_legendre_p<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. LegendreP

pub fn new_laguerre_l<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. LaguerreL

pub fn new_hermite_h<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. HermiteH

pub fn new_kronecker_delta<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. KroneckerDelta

pub fn new_apply<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

Creates a new expression, managed by the DAG. Apply

pub fn new_vector<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

Creates a new expression, managed by the DAG. Vector

pub fn new_and<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

Creates a new expression, managed by the DAG. And

pub fn new_or<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

Creates a new expression, managed by the DAG. Or

pub fn new_union<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

Creates a new expression, managed by the DAG. Union

pub fn new_polynomial<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

Creates a new expression, managed by the DAG. Polynomial

pub fn new_tuple<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

Creates a new expression, managed by the DAG. Tuple

pub fn new_custom_arc_one<A>(a: A) -> Expr

where A: AsRef<Expr>,

👎Deprecated since 0.1.18:

Please use the ‘UnaryList’ variant instead.

Creates a new expression, managed by the DAG. CustomArcOne

pub fn new_custom_arc_two<A, B>(a: A, b: B) -> Expr

where A: AsRef<Expr>, B: AsRef<Expr>,

👎Deprecated since 0.1.18:

Please use the ‘BinaryList’ variant instead.

Creates a new expression, managed by the DAG. CustomArcTwo

pub fn new_custom_vec_one<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new expression, managed by the DAG. CustomVecOne

pub fn new_custom_vec_two<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new expression, managed by the DAG. CustomVecTwo

pub fn new_custom_vec_three<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new expression, managed by the DAG. CustomVecThree

pub fn new_custom_vec_four<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new expression, managed by the DAG. CustomVecFour

pub fn new_custom_vec_five<I, T>(elements: I) -> Expr

where I: IntoIterator<Item = T>, T: AsRef<Expr>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new expression, managed by the DAG. CustomVecFive

pub fn new_constant(c: f64) -> Self

Creates a new Constant expression, managed by the DAG.

Panics

Panics if the value cannot be created in the DAG.

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

Creates a new Variable expression, managed by the DAG.

Panics

Panics if the variable cannot be created in the DAG.

pub fn new_bigint(i: BigInt) -> Self

Creates a new BigInt expression, managed by the DAG.

Panics

Panics if the value cannot be created in the DAG.

pub fn new_rational(r: BigRational) -> Self

Creates a new Rational expression, managed by the DAG.

Panics

Panics if the value cannot be created in the DAG.

pub fn new_pi() -> Self

Creates a new Pi expression, managed by the DAG.

Panics

Panics if the value cannot be created in the DAG.

pub fn new_e() -> Self

Creates a new E expression, managed by the DAG.

Panics

Panics if the value cannot be created in the DAG.

pub fn new_infinity() -> Self

Creates a new Infinity expression, managed by the DAG.

Panics

Panics if the value cannot be created in the DAG.

pub fn new_negative_infinity() -> Self

Creates a new NegativeInfinity expression, managed by the DAG.

Panics

Panics if the value cannot be created in the DAG.

pub fn new_matrix<I, J, T>(elements: I) -> Self

where I: IntoIterator<Item = J>, J: IntoIterator<Item = T>, T: AsRef<Self>,

Creates a new Matrix expression, managed by the DAG.

Panics

Panics if the matrix rows have inconsistent length or if elements cannot be created in the DAG.

pub fn new_predicate<I, T>(name: &str, args: I) -> Self

where I: IntoIterator<Item = T>, T: AsRef<Self>,

Creates a new Predicate expression, managed by the DAG.

Panics

Panics if the predicate or its arguments cannot be created in the DAG.

pub fn new_forall<A>(var: &str, expr: A) -> Self

where A: AsRef<Self>,

Creates a new ForAll quantifier expression, managed by the DAG.

Panics

Panics if the expression cannot be created in the DAG.

pub fn new_exists<A>(var: &str, expr: A) -> Self

where A: AsRef<Self>,

Creates a new Exists quantifier expression, managed by the DAG.

Panics

Panics if the expression cannot be created in the DAG.

pub fn new_interval<A, B>( lower: A, upper: B, incl_lower: bool, incl_upper: bool, ) -> Self

where A: AsRef<Self>, B: AsRef<Self>,

Creates a new Interval expression, managed by the DAG.

Panics

Panics if the interval boundaries cannot be created in the DAG.

pub fn new_derivative<A>(function: A, variable: String) -> Self

where A: AsRef<Self>,

Creates a new Derivative expression, managed by the DAG.

Panics

Panics if the polynomial cannot be created in the DAG.

pub fn new_derivativen<A, B>(function: A, variable: String, grades: B) -> Self

where A: AsRef<Self>, B: AsRef<Self>,

Creates a new DerivativeN expression, managed by the DAG.

Panics

Panics if the polynomial cannot be created in the DAG.

pub fn new_indefinite_sum<A, B>(body: A, variable: String, step: B) -> Self

where A: AsRef<Self>, B: AsRef<Self>,

Creates a new IndefiniteSum expression, managed by the DAG.

Panics

Panics if the expression cannot be created in the DAG.

pub fn new_indefinite_product<A, B>(body: A, variable: String, step: B) -> Self

where A: AsRef<Self>, B: AsRef<Self>,

Creates a new IndefiniteProduct expression, managed by the DAG.

Panics

Panics if the expression cannot be created in the DAG.

pub fn new_sparse_polynomial(p: SparsePolynomial) -> Self

Creates a new SparsePolynomial expression, managed by the DAG.

Panics

Panics if the polynomial cannot be created in the DAG.

pub fn new_custom_zero() -> Self

👎Deprecated since 0.1.18:

Please use the ‘UnaryList’ variant instead.

Creates a new CustomZero expression (deprecated).

Panics

Panics if the value cannot be created in the DAG.

pub fn new_custom_string(s: &str) -> Self

👎Deprecated since 0.1.18:

Please use the ‘UnaryList’ variant instead.

Creates a new CustomString expression (deprecated).

Panics

Panics if the value cannot be created in the DAG.

pub fn new_custom_arc_three<A, B, C>(a: A, b: B, c: C) -> Self

where A: AsRef<Self>, B: AsRef<Self>, C: AsRef<Self>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new CustomArcThree expression (deprecated).

Panics

Panics if the arguments cannot be created in the DAG.

pub fn new_custom_arc_four<A, B, C, D>(a: A, b: B, c: C, d: D) -> Self

where A: AsRef<Self>, B: AsRef<Self>, C: AsRef<Self>, D: AsRef<Self>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new CustomArcFour expression (deprecated).

Panics

Panics if the arguments cannot be created in the DAG.

pub fn new_custom_arc_five<A, B, C, D, E>(a: A, b: B, c: C, d: D, e: E) -> Self

where A: AsRef<Self>, B: AsRef<Self>, C: AsRef<Self>, D: AsRef<Self>, E: AsRef<Self>,

👎Deprecated since 0.1.18:

Please use the ‘NaryList’ variant instead.

Creates a new CustomArcFive expression (deprecated).

Panics

Panics if the arguments cannot be created in the DAG.

pub const fn is_dag(&self) -> bool

Checks if this expression is in DAG form.

Returns

• true if the expression is Expr::Dag, false otherwise

Examples

use rssn::symbolic::core::Expr;

let dag_expr = Expr::new_variable("x");

assert!(dag_expr.is_dag());

let ast_expr = Expr::Constant(1.0);

assert!(!ast_expr.is_dag());

pub fn to_dag(&self) -> Result<Self, String>

Converts this expression to DAG form if not already.

This is a key function for the AST→DAG migration. It ensures that any expression, whether in old AST form or new DAG form, is converted to a canonical DAG representation.

Returns

• Ok(Expr::Dag) - The expression in DAG form
• Err(String) - If conversion fails

Errors

Returns an error if conversion from AST to DAG fails.

Examples

use std::sync::Arc;

use rssn::symbolic::core::Expr;

// Old AST form
let ast = Expr::Add(
    Arc::new(Expr::Variable("x".to_string())),
    Arc::new(Expr::Constant(1.0)),
);

// Convert to DAG
let dag = ast.to_dag().unwrap();

assert!(dag.is_dag());

pub fn to_dag_form(&mut self)

Converts this expression to DAG form in-place.

This is a convenience method that converts the expression to DAG form and replaces the current value.

Examples

use rssn::symbolic::core::Expr;

let mut expr = Expr::Constant(1.0);

assert!(!expr.is_dag());

expr.to_dag_form();

assert!(expr.is_dag());

pub fn to_ast(&self) -> Result<Self, String>

Converts a DAG expression back to AST form (for serialization).

This is used internally for backward-compatible serialization. Note: This may fail for expressions that cannot be represented in AST form.

Returns

• Ok(Expr) - The expression in AST form
• Err(String) - If conversion fails

Errors

Returns an error if conversion from DAG to AST fails.

impl Expr

pub fn sin(&self) -> Self

Returns the sine of the expression.

pub fn cos(&self) -> Self

Returns the cosine of the expression.

pub fn tan(&self) -> Self

Returns the tangent of the expression.

pub fn exp(&self) -> Self

Returns the natural exponential of the expression (e^x).

pub fn ln(&self) -> Self

Returns the natural logarithm of the expression.

pub fn log<B: AsRef<Self>>(&self, base: B) -> Self

Returns the logarithm of the expression with a specified base.

pub fn abs(&self) -> Self

Returns the absolute value of the expression.

pub fn sqrt(&self) -> Self

Returns the square root of the expression.

pub fn pow<E: AsRef<Self>>(&self, exponent: E) -> Self

Returns the expression raised to the power of another expression.

pub fn asin(&self) -> Self

Returns the arcsine of the expression.

pub fn acos(&self) -> Self

Returns the arccosine of the expression.

pub fn atan(&self) -> Self

Returns the arctangent of the expression.

pub fn sinh(&self) -> Self

Returns the hyperbolic sine of the expression.

pub fn cosh(&self) -> Self

Returns the hyperbolic cosine of the expression.

pub fn tanh(&self) -> Self

Returns the hyperbolic tangent of the expression.

impl Expr

pub fn re(&self) -> Self

Returns the real part of the expression.

pub fn im(&self) -> Self

Returns the imaginary part of the expression.

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

Attempts to convert the expression to a 64-bit float.

pub fn op(&self) -> DagOp

Returns the operation type of the expression in a unified way.

This method handles both regular expressions and DAG nodes, returning the operation regardless of internal representation.

Returns

• DagOp - The operation type corresponding to this expression

Panics

Panics if the expression cannot be converted to a DagOp.

pub fn children(&self) -> Vec<Self>

Returns the children of the expression in a unified way.

This method handles both regular expressions and DAG nodes, returning the direct child expressions regardless of internal representation.

Returns

• Vec<Expr> - A vector containing the direct children of this expression

impl Expr

pub fn pre_order_walk<F>(&self, f: &mut F)

where F: FnMut(&Self),

Performs a pre-order traversal of the expression tree. It visits the current node first, then its children.

Arguments

• f - A mutable function that takes a reference to an Expr and is applied to each node during traversal

pub fn post_order_walk<F>(&self, f: &mut F)

where F: FnMut(&Self),

Performs a post-order traversal of the expression tree. It visits the children first, then the current node.

Arguments

• f - A mutable function that takes a reference to an Expr and is applied to each node during traversal

pub fn in_order_walk<F>(&self, f: &mut F)

where F: FnMut(&Self),

Performs an in-order traversal of the expression tree. For binary operators, it visits the left child, the node itself, then the right child. For other nodes, the behavior is adapted as it’s not strictly defined.

Arguments

• f - A mutable function that takes a reference to an Expr and is applied to each node during traversal

pub fn normalize(&self) -> Self

Normalizes the expression by sorting sub-expressions of commutative operators.

This helps in identifying identical expressions that differ only in terms of operand order.

impl Expr

pub fn clone_box_dist(&self) -> Result<Arc<dyn Distribution>, String>

Clones the distribution if the expression represents a probability distribution.

Errors

Returns an error if the expression is not a distribution.

pub fn clone_box_quant(&self) -> Result<Arc<UnitQuantity>, String>

Clones the unit quantity if the expression represents a quantity.

Errors

Returns an error if the expression is not a quantity.

Trait Implementations

impl Add for Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Expr> for Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Expr> for &Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Expr> for f64

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Expr> for &Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Expr> for f64

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f64> for &Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl AsRef<Expr> for Expr

fn as_ref(&self) -> &Self

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

impl Clone for 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 Expr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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: Expr) -> Self::Output

Performs the / operation.

impl Div<&Expr> for Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&Expr> for &Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&Expr> for f64

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Expr> for &Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Expr> for f64

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f64> for &Expr

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Eq for Expr

impl From<DagNode> for Expr

fn from(node: DagNode) -> Self

Converts to this type from the input type.

impl From<f64> for Expr

fn from(val: f64) -> Self

Converts to this type from the input type.

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

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Expr> for Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Expr> for &Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Expr> for f64

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Expr> for &Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Expr> for f64

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Expr> for Multivector

type Output = Multivector

The resulting type after applying the * operator.

fn mul(self, scalar: Expr) -> Self

Performs the * operation.

impl Mul<f64> for Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f64> for &Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for &Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Expr

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for 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 PartialOrd for Expr

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Expr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Expr> for Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Expr> for &Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Expr> for f64

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Expr> for &Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Expr> for f64

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f64> for Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f64> for &Expr

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl ToExpr for Expr

fn to_expr(&self) -> Expr

Converts the value into a symbolic Expr.