Struct Expr 

pub struct Expr<'a> {
    pub id: ExprId,
    pub arena: &'a RefCell<ExprArena>,
}

Lightweight handle to a node in an ExprArena.

Carries a borrow of the arena (wrapped in RefCell so operator overloads can push new nodes during arithmetic). Expr is Copy, so users freely reuse a variable handle in many constraints.

Fields

id: ExprId

arena: &'a RefCell<ExprArena>

Implementations

impl<'a> Expr<'a>

pub fn new(id: ExprId, arena: &'a RefCell<ExprArena>) -> Self

pub fn constant(arena: &'a RefCell<ExprArena>, v: f64) -> Self

pub fn from_var(arena: &'a RefCell<ExprArena>, v: VarId) -> Self

pub fn var_id(self) -> Option<VarId>

If this handle is a bare variable, return its VarId. None for compound expressions (sums, products, constants, …).

pub fn param_id(self) -> Option<ParamId>

If this handle is a bare parameter, return its ParamId. None for compound expressions.

pub fn pow(self, exponent: Self) -> Self

pub fn powi(self, n: i32) -> Self

pub fn powf(self, n: f64) -> Self

pub fn sin(self) -> Self

pub fn cos(self) -> Self

pub fn exp(self) -> Self

pub fn log(self) -> Self

pub fn abs(self) -> Self

Trait Implementations

impl<'a> Add for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add<Expr<'a>> for f64

type Output = Expr<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<'a>) -> Expr<'a>

Performs the + operation.

impl<'a> Add<Expr<'a>> for i32

type Output = Expr<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Expr<'a>) -> Expr<'a>

Performs the + operation.

impl<'a> Add<f64> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add<i32> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Clone for Expr<'a>

fn clone(&self) -> Expr<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for Expr<'a>

impl Debug for Expr<'_>

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

Formats the value using the given formatter.

impl<'a> Div for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div<Expr<'a>> for f64

type Output = Expr<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<'a>) -> Expr<'a>

Performs the / operation.

impl<'a> Div<Expr<'a>> for i32

type Output = Expr<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Expr<'a>) -> Expr<'a>

Performs the / operation.

impl<'a> Div<f64> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self

Performs the / operation.

impl<'a> Div<i32> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self

Performs the / operation.

impl<'a> Mul for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<Expr<'a>> for f64

type Output = Expr<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<'a>) -> Expr<'a>

Performs the * operation.

impl<'a> Mul<Expr<'a>> for i32

type Output = Expr<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Expr<'a>) -> Expr<'a>

Performs the * operation.

impl<'a> Mul<f64> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<i32> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Neg for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<'a> Sub for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<Expr<'a>> for f64

type Output = Expr<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<'a>) -> Expr<'a>

Performs the - operation.

impl<'a> Sub<Expr<'a>> for i32

type Output = Expr<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Expr<'a>) -> Expr<'a>

Performs the - operation.

impl<'a> Sub<f64> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self

Performs the - operation.

impl<'a> Sub<i32> for Expr<'a>

type Output = Expr<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self

Performs the - operation.

impl<'a> Sum for Expr<'a>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, 'b> Sum<&'b Expr<'a>> for Expr<'a>

fn sum<I: Iterator<Item = &'b Expr<'a>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.