Enum ExprData 

pub enum ExprData {
    Symbol {
        name: String,
        domain: Domain,
        commutative: bool,
    },
    Integer(BigInt),
    Rational(BigRat),
    Float(BigFloat),
    Add(Vec<ExprId>),
    Mul(Vec<ExprId>),
    Pow {
        base: ExprId,
        exp: ExprId,
    },
    Func {
        name: String,
        args: Vec<ExprId>,
    },
    Piecewise {
        branches: Vec<(ExprId, ExprId)>,
        default: ExprId,
    },
    Predicate {
        kind: PredicateKind,
        args: Vec<ExprId>,
    },
    Forall {
        var: ExprId,
        body: ExprId,
    },
    Exists {
        var: ExprId,
        body: ExprId,
    },
    BigO(ExprId),
    RootSum {
        poly: ExprId,
        var: ExprId,
        body: ExprId,
    },
}

Structural content of an expression node.

All compound nodes hold ExprId children, not owned sub-trees. This keeps ExprData small and allows sharing via the intern table.

Variants

Symbol

Fields

name: String

domain: Domain

commutative: bool

When false, this generator does not commute under multiplication; see V3-2.

Integer(BigInt)

Rational(BigRat)

Float(BigFloat)

Add(Vec<ExprId>)

Mul(Vec<ExprId>)

Pow

Fields

base: ExprId

exp: ExprId

Func

Fields

name: String

args: Vec<ExprId>

Piecewise

A piecewise expression: evaluates to value_i when cond_i holds, and to default when no condition matches.

Conditions are ExprData::Predicate nodes stored in the pool. Branches are tried in order; the first matching condition wins.

Fields

branches: Vec<(ExprId, ExprId)>

default: ExprId

Predicate

A symbolic predicate (boolean condition over symbolic reals).

Fields

kind: PredicateKind

args: Vec<ExprId>

Forall

Universal quantification (∀ var . body). Used by first-order logic (V3-3).

Fields

var: ExprId

body: ExprId

Exists

Existential quantification (∃ var . body).

Fields

var: ExprId

body: ExprId

BigO(ExprId)

Landau big-O remainder: O(arg) as a symbolic order bound (V2-15 series API).

RootSum

Sum over the roots of a polynomial: Σ_{c : poly(c)=0} body[var := c].

A binder (like ExprData::Exists): var is the bound root placeholder, poly is a univariate polynomial in var, and body is the summand (an expression in var and the free variables). Used to represent the logarithmic part of a rational-function integral whose residues are algebraic numbers of degree ≥ 2 (Rothstein–Trager / Lazard–Rioboo–Trager).

Fields

poly: ExprId

var: ExprId

body: ExprId

Trait Implementations

impl Clone for ExprData

fn clone(&self) -> ExprData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprData

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

Formats the value using the given formatter.

impl Eq for ExprData

impl Hash for ExprData

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 ExprData

fn eq(&self, other: &ExprData) -> 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 ExprData