Struct doctor_syn::expression::Expression

pub struct Expression { /* fields omitted */ }

Implementations

impl Expression

pub fn span(&self) -> Span

pub fn into_inner(self) -> Expr

pub fn is_lit(&self) -> bool

Generate a number from a literal expression.

use doctor_syn::{Expression, expr};
assert!(expr!("hello").is_lit());

pub fn subst(&self, variables: VariableList) -> Result<Expression>

Substitute the occurance of certain variables with an expression.

use doctor_syn::{expr, vars};

assert_eq!(expr!(x + 1).subst(vars!(x=1)).unwrap(), expr!(1 + 1));

pub fn eval<T: Evaluateable>(&self) -> Result<T>

Eval constant expressions into a single expression using a particular floating point type.

use doctor_syn::{expr};

assert_eq!(expr!(1 + 1).eval::<f64>().unwrap(), 2.0);

pub fn approx<T: Evaluateable>(
    &self,
    num_terms: usize,
    xmin: T,
    xmax: T,
    variable: Name,
    parity: Parity
) -> Result<Expression>

Return a polynomial approximation of a single variable expression. The polynomial is in a canonical form t[k] . mul_add( x, t[k-1]) … . mul_add( x, t[0]) This is the most accurate and highest throughput form on most processors.

use doctor_syn::{expr, name, Parity};

assert_eq!(expr!(x).approx(2, 0.0, 1.0, name!(x)).unwrap(), expr!(1f64 . mul_add (x , 0f64), Parity::Neither));

pub fn expand(&self) -> Result<Expression>

Expand an expression.

use doctor_syn::{expr, Result};
|| -> Result<()> {
   // Unary
   assert_eq!(expr!(- - x).expand()?, expr!(x));
   assert_eq!(expr!(-(x+1)).expand()?, expr!(-x-1));

   // Binary add/sub
   assert_eq!(expr!((x+1)+(x+1)).expand()?, expr!(x + 1 + x + 1));
   assert_eq!(expr!((x+1)+((x+1)+(x+1))).expand()?, expr!(x + 1 + x + 1 + x + 1));
   assert_eq!(expr!((x+1)-(x+1)).expand()?, expr!(x + 1 - x - 1));
   assert_eq!(expr!((x+1)-((x+1)-(x+1))).expand()?, expr!(x + 1 - x - 1 + x + 1));
   assert_eq!(expr!((x+1)-((x+1)-(-x+1))).expand()?, expr!(x + 1 - x - 1 - x + 1));

   // Binary mul
   assert_eq!(expr!(x*x).expand()?, expr!(x * x));
   assert_eq!(expr!(x*(x+1)).expand()?, expr!(x * x + x * 1));
   assert_eq!(expr!((x+1)*x).expand()?, expr!(x * x + 1 * x));
   assert_eq!(expr!((x+1)*(x+1)).expand()?, expr!(x * x + x * 1 + 1 * x + 1 * 1));
   assert_eq!(expr!((x+1)*(x+1)*(x+1)).expand()?, expr!(x * x * x + x * x * 1 + x * 1 * x + x * 1 * 1 + 1 * x * x + 1 * x * 1 + 1 * 1 * x + 1 * 1 * 1));
   Ok(())
}();

pub fn collect_terms(&self, variable: Name) -> Result<Expression>

Collect terms assuming commutativity.

use doctor_syn::{expr, Result};
|| -> Result<()> {
    
   Ok(())
}();

pub fn paren(&self) -> Result<Expression>

Parenthesise operators of operators.

use doctor_syn::{expr};

assert_eq!(expr!(-x).paren().unwrap(), expr!(-x));
assert_eq!(expr!(x+1).paren().unwrap(), expr!(x+1));
assert_eq!(expr!(x+1+1).paren().unwrap(), expr!((x+1)+1));
assert_eq!(expr!(x+1+1+1).paren().unwrap(), expr!(((x+1)+1)+1));
assert_eq!(expr!(2*x+y).paren().unwrap(), expr!((2*x)+y));

pub fn use_suffix(&self, float_suffix: Option<String>) -> Result<Expression>

Change the suffix of floatng point numbers.

use doctor_syn::{expr};

assert_eq!(expr!(1.0f64).use_suffix(Some("f32".to_string())).unwrap(), expr!(1.0_f32));

Trait Implementations

impl AsRef<Expr> for Expression

fn as_ref(&self) -> &Expr

Performs the conversion.

impl Clone for Expression

fn clone(&self) -> Expression

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Display for Expression

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

Formats the value using the given formatter.

impl From<Expr> for Expression

fn from(expr: Expr) -> Self

Performs the conversion.

impl FromStr for Expression

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl PartialEq<Expression> for Expression

fn eq(&self, other: &Expression) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Expression) -> bool

This method tests for !=.

impl TryFrom<&'_ Expression> for f64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: &Expression) -> Result<Self>

Performs the conversion.

impl TryFrom<&'_ Expression> for f32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: &Expression) -> Result<Self>

Performs the conversion.

impl TryFrom<Expression> for f64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expression) -> Result<Self>

Performs the conversion.

impl TryFrom<Expression> for f32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(expr: Expression) -> Result<Self>

Performs the conversion.

impl TryFrom<f32> for Expression

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: f32) -> Result<Self>

Performs the conversion.

impl TryFrom<f64> for Expression

type Error = Error

The type returned in the event of a conversion error.

fn try_from(val: f64) -> Result<Self>

Performs the conversion.

impl StructuralPartialEq for Expression