Enum symbolics_core::expr::Expr

pub enum Expr {
    Num(f64),
    Symbol(String),
    Add(Box<Expr>, Box<Expr>),
    Mul(Box<Expr>, Box<Expr>),
    Pow(Box<Expr>, Box<Expr>),
    Log(Box<Expr>, Box<Expr>),
    Sin(Box<Expr>),
    Cos(Box<Expr>),
    Arcsin(Box<Expr>),
    Arccos(Box<Expr>),
    Arctan(Box<Expr>),
}

Variants

Num(f64)Symbol(String)Add(Box<Expr>, Box<Expr>)Mul(Box<Expr>, Box<Expr>)Pow(Box<Expr>, Box<Expr>)Log(Box<Expr>, Box<Expr>)Sin(Box<Expr>)Cos(Box<Expr>)Arcsin(Box<Expr>)Arccos(Box<Expr>)Arctan(Box<Expr>)

Methods

impl Expr

pub fn is_num(self) -> bool

Return whether the expression represents a literal number, i.e. whether it is of variant Num.

pub fn val(self) -> Option<f64>

Return the numeric value of the expression, if all symbols have been applied. If there are unapplied symbols, returns None.

impl Expr

pub fn apply1<T, S: AsRef<str>>(self, name_raw: S, value: T) -> Expr where
    T: Clone + Into<Expr>, 

Apply a single substitution, then simplify purely numeric sub-expressions. The substitution can be anything that can be converted to an expression.

Examples

      let y = 3*s!(x).squared() + 2;
      let y_2 = y.apply1("x", 2);
      assert_eq!(y_2.val().unwrap(), 14.);

      let y = 3*s!(x) + 2;
      let y_t = y.apply1("x", s!(t).squared());
      assert_eq!(format!("{:?}", y_t), "Add(Mul(Num(3.0), Pow(Symbol(\"t\"), Num(2.0))), Num(2.0))")

impl Expr

pub fn log<T>(self, base: T) -> Expr where
    T: Into<Expr>, 

Logarithm of arbitrary base.

pub fn log2(self) -> Expr

Logarithm with base 2.

pub fn log10(self) -> Expr

Logarithm with base 10.

pub fn ln(self) -> Expr

Natural logarithm, i.e. log base e, where e is Euler's number.

impl Expr

pub fn sqrt(self) -> Expr

Square root.

Provided as a convenience; expr.sqrt() is equivalent to expr ^ 0.5.

pub fn squared(self) -> Expr

Raise to the second power.

Provided as a convenience; expr.squared() is equivalent to expr ^ 2.

pub fn cubed(self) -> Expr

Raise to the third power.

Provided as a convenience; expr.cubed() is equivalent to expr ^ 3.

impl Expr

pub fn sin(self) -> Expr

pub fn cos(self) -> Expr

pub fn tan(self) -> Expr

pub fn csc(self) -> Expr

pub fn sec(self) -> Expr

pub fn cot(self) -> Expr

pub fn asin(self) -> Expr

pub fn acos(self) -> Expr

pub fn atan(self) -> Expr

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<f64> for Expr

fn from(x: f64) -> Expr

Performs the conversion.

impl From<i64> for Expr

fn from(x: i64) -> Expr

Performs the conversion.

impl<T> Add<T> for Expr where
    T: Into<Expr>, 

type Output = Expr

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Expr

Performs the + operation.

impl Add<Expr> for f64

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Expr> for i64

type Output = Expr

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Sub<T> for Expr where
    T: Into<Expr>, 

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Expr

Performs the - operation.

impl Sub<Expr> for f64

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Expr> for i64

type Output = Expr

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Mul<T> for Expr where
    T: Into<Expr>, 

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Expr

Performs the * operation.

impl Mul<Expr> for f64

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Expr> for i64

type Output = Expr

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Div<T> for Expr where
    T: Into<Expr>, 

type Output = Expr

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Expr

Performs the / operation.

impl Div<Expr> for f64

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Expr> for i64

type Output = Expr

The resulting type after applying the / operator.

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

Performs the / operation.

impl Neg for Expr

type Output = Expr

The resulting type after applying the - operator.

fn neg(self) -> Expr

Performs the unary - operation.

impl<T> AddAssign<T> for Expr where
    T: Into<Expr>, 

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T> SubAssign<T> for Expr where
    T: Into<Expr>, 

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T> MulAssign<T> for Expr where
    T: Into<Expr>, 

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> DivAssign<T> for Expr where
    T: Into<Expr>, 

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<'a> Not for &'a Expr

type Output = Expr

The resulting type after applying the ! operator.

fn not(self) -> Expr

Performs the unary ! operation.

impl<T> BitXor<T> for Expr where
    T: Into<Expr>, 

type Output = Expr

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Expr

Performs the ^ operation.

impl BitXor<Expr> for f64

type Output = Expr

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr) -> Expr

Performs the ^ operation.

impl BitXor<Expr> for i64

type Output = Expr

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Expr) -> Expr

Performs the ^ operation.

impl<T> BitXorAssign<T> for Expr where
    T: Into<Expr>, 

fn bitxor_assign(&mut self, rhs: T)

Performs the ^= operation.

impl Debug for Expr

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

Formats the value using the given formatter.