Enum SymbolicExpr 

pub enum SymbolicExpr {
    Integer(BigInt),
    Rational(BigInt, BigInt),
    Sqrt {
        radicand: BigInt,
    },
    ScaledSqrt {
        coeff: (BigInt, BigInt),
        rad: BigInt,
    },
    Pi,
    E,
    Add(Vec<SymbolicExpr>),
    Mul(Vec<SymbolicExpr>),
    Pow {
        base: Box<SymbolicExpr>,
        exp: Box<SymbolicExpr>,
    },
    Sin(Box<SymbolicExpr>),
    Cos(Box<SymbolicExpr>),
    Exp(Box<SymbolicExpr>),
    Ln(Box<SymbolicExpr>),
}

A symbolic numeric expression.

Variants

Integer(BigInt)

Rational(BigInt, BigInt)

p/q (not necessarily reduced until simplified).

Sqrt

√n with a simplified (square-free) radicand.

Fields

radicand: BigInt

ScaledSqrt

(p/q)·√n.

Fields

coeff: (BigInt, BigInt)

rad: BigInt

Pi

E

Add(Vec<SymbolicExpr>)

Mul(Vec<SymbolicExpr>)

Pow

Fields

base: Box<SymbolicExpr>

exp: Box<SymbolicExpr>

Sin(Box<SymbolicExpr>)

Cos(Box<SymbolicExpr>)

Exp(Box<SymbolicExpr>)

Ln(Box<SymbolicExpr>)

Implementations

impl SymbolicExpr

pub fn int(n: i64) -> Self

pub fn rational(p: i64, q: i64) -> Self

pub fn sqrt(n: i64) -> Self

pub fn add(terms: Vec<SymbolicExpr>) -> Self

pub fn mul(factors: Vec<SymbolicExpr>) -> Self

pub fn sin(x: SymbolicExpr) -> Self

pub fn cos(x: SymbolicExpr) -> Self

pub fn exp(x: SymbolicExpr) -> Self

pub fn ln(x: SymbolicExpr) -> Self

Trait Implementations

impl Clone for SymbolicExpr

fn clone(&self) -> SymbolicExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SymbolicExpr

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

Formats the value using the given formatter.

impl Eq for SymbolicExpr

impl Hash for SymbolicExpr

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 SymbolicExpr

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