Enum Expr 

pub enum Expr {
    Val(Rc<F>),
    Const(Rc<Const>),
    Sum(Rc<Sum>),
    Prod(Rc<Prod>),
    Sqrt(Rc<Sqrt>),
}

Expression using Rc This type does not know if there are duplicates use like: let half = F::new(1u8,2u8); // <- for convenience let val_1 = Expr::from(1u32); let val_5 = Expr::from(5u32); let sqrt_5 = Expr::sqrt(val_5); let phi = Expr::from( vec![(half,val_1),(half,sqrt_5)] ) let phi_sq = Expr::from( vec![(F::new(3u8,2u8),val_1),(half,sqrt_5)] ) to be sure that sqrt_5 is shared among phi and phi_sq

Variants

Val(Rc<F>)

Just a number Needs to be there, since sqrt(2)*sqrt(2) = 2

Const(Rc<Const>)

Constant like pi

Sum(Rc<Sum>)

Sum of terms Note that

Prod(Rc<Prod>)

Product of factors Notice that e.g. 2pi is already a product

Sqrt(Rc<Sqrt>)

Implementations

impl Expr

pub fn nan() -> Expr

pub fn infinity() -> Expr

pub fn neg_infinity() -> Expr

pub fn val_i<T>(i: T) -> Expr

where F: From<T>,

pub fn val_frac(f: F) -> Expr

pub fn c_pi() -> Expr

pub fn c_e() -> Expr

pub fn sqrt_i(i: u32) -> Expr

pub fn sqrt_frac(f: F) -> Expr

pub fn sqrt_expr(expr: Expr) -> Expr

pub fn sum_i_pi(i: u32) -> Expr

pub fn sum_i_expr(i: u32, e: Expr) -> Expr

pub fn sum_i_plus_pi(i: u32) -> Expr

pub fn sum_phi() -> Expr

the golden ratio: (1+sqrt(5))/2 = 1/2+1/2sqrt(5)

pub fn prod_pi_i(i: u32) -> Expr

pub fn prod_pi_times_sqrt_i(i: u32) -> Expr

Trait Implementations

impl Add for Expr

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Char for Expr

Const -> Name of an Expr variant. Should return char Val -> ξ Const -> Sum -> Σ Prod -> Π Sqrt -> √ For sin, cos, tan, they are a clock based on this triangle: Cos Sin Tan

---

| / /| /| |-/ / | / | |/ /_| /_| Cos Sin Tan |/ /| _| 🕑 🕢 🕘 Sin -> 🕢 Cos -> 🕑 Tan -> 🕘

fn ch(&self) -> char

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

Representation. Should return a string that results in the same value e.g. assert_eq!(exact::from(format!(“{}”,some_exact), some_exact) For example: 1/2+1/2√(5/2) -> Σ((1/2,ξ1),(1/2,√5/2)) Note that currently constants loose precision e.g. Const{ch: ‘π’, f64: std::consts::f64::PI} -> π Except that bla

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

Formats the value using the given formatter.

impl From<(char, f64)> for Expr

from const tuple

fn from(value: (char, f64)) -> Self

Converts to this type from the input type.

impl From<GenericFraction<u32>> for Expr

fn from(value: F) -> Self

Converts to this type from the input type.

impl From<Vec<(Expr, GenericFraction<u32>)>> for Expr

From a prod-type vector: PVec Also simplifies Contained products should already be simplified

fn from(v: PVec) -> Self

Converts to this type from the input type.

impl From<Vec<(GenericFraction<u32>, Expr)>> for Expr

From a sum-type vector: Vec<(F, Expr)>

fn from(value: Vec<(F, Expr)>) -> Self

Converts to this type from the input type.

impl From<u32> for Expr

If we can convert to fraction, it’s a numeral

fn from(value: u32) -> Self

Converts to this type from the input type.

impl FromRaw<Vec<(Expr, GenericFraction<u32>)>> for Expr

fn from_raw(v: PVec) -> Self

Converts to this type from the input type.

impl FromRaw<Vec<(GenericFraction<u32>, Expr)>> for Expr

fn from_raw(terms: SVec) -> Self

Converts to this type from the input type.

impl GetExpr for Expr

Get the expression of a functional expression, such as Sqrt, Sin, Cos, Tan Currently only sqrt. √5/2 -> ξ5/2 Expr::Sqrt(Rc<Sqrt(expr)>) -> expr

fn get_expr(&self) -> Option<Expr>

impl Inv for Expr

type Output = Expr

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl Mul for Expr

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Expr

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl One for Expr

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl ParseDisplay for Expr

fn parse_display(input: String) -> Result<Expr, Error>

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 TryFrom<&str> for Expr

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for Expr

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl Zero for Expr

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl StructuralPartialEq for Expr