Enum Expr 

pub enum Expr {
    Tree {
        op: String,
        args: Vec<Expr>,
    },
    Const {
        val: f64,
    },
    Var {
        name: String,
    },
}

The elements of the top-level expression trees

Expr is used to create variables and expressions to pass to Symjit to compile.

The Python/Sympy interface generates a JSON string, encoding the model, and pass it to the Rust code to deserialize. The Rust interface (Compiler) directly uses various functions to compose the trees.

Examples

let x = Expr::var("x");     # create a new variable
let c = Expr::from(2.5);    # create a new constant (f64)
let expr = &x * &(x.sin() + &c)
...

Note that the overloaded operators expect &Expr; therefore, the need for taking reference (adding & in from the intermediate expressions).

Variants

Tree

Fields

op: String

args: Vec<Expr>

Const

Fields

val: f64

Var

Fields

name: String

Implementations

impl Expr

pub fn var(name: &str) -> Expr

Creates a new variable named name.

pub fn unary(op: &str, arg: &Expr) -> Expr

Create a unary operation: op(arg).

To create a user-defined unary function, you need to register the function with Compiler using def_unary.

pub fn binary(op: &str, l: &Expr, r: &Expr) -> Expr

Creates a binary operations op(l, r).

To create a user-defined binary function, you need to register the function with Compiler using def_binary.

pub fn ternary(op: &str, l: &Expr, c: &Expr, r: &Expr) -> Expr

Creates a ternary operation: op(l, c, r).

pub fn nary(op: &str, args: &[&Expr]) -> Expr

Creates an n-ary operation: op(args...).

pub fn equation(lhs: &Expr, rhs: &Expr) -> Equation

Creates an equation lhs ~ rhs.

pub fn to_variable(&self) -> Result<Variable>

Converts a variable Expr to a Variable type needed by the next stage.

pub fn add(&self, other: &Expr) -> Expr

pub fn sub(&self, other: &Self) -> Expr

pub fn mul(&self, other: &Self) -> Expr

pub fn div(&self, other: &Self) -> Expr

pub fn rem(&self, other: &Self) -> Expr

pub fn bitand(&self, other: &Self) -> Expr

pub fn bitor(&self, other: &Self) -> Expr

pub fn bitxor(&self, other: &Self) -> Expr

pub fn eq(&self, other: &Expr) -> Expr

Comparison ==

pub fn ne(&self, other: &Expr) -> Expr

Comparison !=

pub fn lt(&self, other: &Expr) -> Expr

Comparison <

pub fn le(&self, other: &Expr) -> Expr

Comparison <=

pub fn gt(&self, other: &Expr) -> Expr

Comparison >

pub fn ge(&self, other: &Expr) -> Expr

Comparison >=

pub fn min(&self, other: &Expr) -> Expr

pub fn max(&self, other: &Expr) -> Expr

pub fn pow(&self, other: &Expr) -> Expr

pub fn ifelse(&self, true_val: &Expr, false_val: &Expr) -> Expr

Ternary select operations: if self { true_val} else {false_valve} Note that this is not a short-circuited operation.

pub fn sum(&self, var: &Expr, start: &Expr, end: &Expr) -> Expr

Sums self for var in start..=end.

Examples

let x = Expr::var("x");
let i = Expr::var("i");
let p = i.sum(&i, &Expr::from(1), &x);
let mut comp = Compiler::new();
let mut func = comp.compile(&[x], &[p])?;
println!("{}", func.call([5]))  // prints [15.0]

Note that the range is start to end inclusive to remain consistent with SymPy usage.

Warning

var should be a unique variable over the whole model.

pub fn prod(&self, var: &Expr, start: &Expr, end: &Expr) -> Expr

Calculates the product of self for var in start..=end.

Examples

let x = Expr::var("x");
let i = Expr::var("i");
let p = i.prod(&i, &Expr::from(1), &x); // this is the factorial function
let mut comp = Compiler::new();
let mut func = comp.compile(&[x], &[p])?;
println!("{}", func.call([5]))  // prints [120.0]

Note that the range is start to end inclusive to remain consistent with SymPy usage.

var should be a unique variable over the whole model.

pub fn not(&self) -> Expr

pub fn neg(&self) -> Expr

pub fn square(&self) -> Expr

self^2

pub fn cube(&self) -> Expr

self^3

pub fn recip(&self) -> Expr

1 / self

pub fn round(&self) -> Expr

pub fn trunc(&self) -> Expr

pub fn floor(&self) -> Expr

pub fn ceil(&self) -> Expr

pub fn fract(&self) -> Expr

The fractional part of a number: self - floor(self)

pub fn heaviside(&self) -> Expr

Heaviside functions. It returns 1 if self is >=0; otherwise returns 0.

It can be used for conditional operations.

pub fn sqrt(&self) -> Expr

pub fn abs(&self) -> 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 sinh(&self) -> Expr

pub fn cosh(&self) -> Expr

pub fn tanh(&self) -> Expr

pub fn csch(&self) -> Expr

pub fn sech(&self) -> Expr

pub fn coth(&self) -> Expr

pub fn asin(&self) -> Expr

pub fn acos(&self) -> Expr

pub fn atan(&self) -> Expr

pub fn asinh(&self) -> Expr

pub fn acosh(&self) -> Expr

pub fn atanh(&self) -> Expr

pub fn sinc(&self) -> Expr

pub fn cbrt(&self) -> Expr

pub fn exp(&self) -> Expr

pub fn ln(&self) -> Expr

pub fn log10(&self) -> Expr

pub fn exp_m1(&self) -> Expr

pub fn ln_1p(&self) -> Expr

pub fn log2(&self) -> Expr

pub fn exp2(&self) -> Expr

pub fn erf(&self) -> Expr

pub fn erfc(&self) -> Expr

pub fn gamma(&self) -> Expr

pub fn lgam(&self) -> Expr

Log gamma

pub fn si(&self) -> Expr

pub fn ci(&self) -> Expr

pub fn shi(&self) -> Expr

pub fn chi(&self) -> Expr

impl Expr

pub fn diff_var(&self) -> Option<String>

Extracts the differentiated variable from the lhs of a diff eq

pub fn normal_var(&self) -> Option<String>

Extracts the regular variable from the lhs of an observable eq

Trait Implementations

impl Add for &Expr

type Output = Expr

The resulting type after applying the + operator.

fn add(self, other: Self) -> Expr

Performs the + operation.

impl BitAnd for &Expr

type Output = Expr

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Expr

Performs the & operation.

impl BitOr for &Expr

type Output = Expr

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Expr

Performs the | operation.

impl BitXor for &Expr

type Output = Expr

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Expr

Performs the ^ operation.

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<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div for &Expr

type Output = Expr

The resulting type after applying the / operator.

fn div(self, other: Self) -> Expr

Performs the / operation.

impl From<f32> for Expr

fn from(val: f32) -> Expr

Converts to this type from the input type.

impl From<f64> for Expr

fn from(val: f64) -> Expr

Converts to this type from the input type.

impl From<i32> for Expr

fn from(val: i32) -> Expr

Converts to this type from the input type.

impl Mul for &Expr

type Output = Expr

The resulting type after applying the * operator.

fn mul(self, other: Self) -> 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 Not for &Expr

type Output = Expr

The resulting type after applying the ! operator.

fn not(self) -> Expr

Performs the unary ! operation.

impl Rem for &Expr

type Output = Expr

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Expr

Performs the % operation.

impl Sub for &Expr

type Output = Expr

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Expr

Performs the - operation.