Struct Expr 

pub struct Expr<'a> {
    pub id: ExprId,
    pub arena: &'a ExprArenaCell,
    /* private fields */
}

Lightweight handle to a node in an ExprArenaCell.

Carries a borrow of the arena cell 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 ExprArenaCell

Implementations

impl<'a> Expr<'a>

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

pub const fn model_id(self) -> ModelId

Identity of the model/expression arena that created this handle.

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

pub fn from_var(arena: &'a ExprArenaCell, 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 set_param_value(self, value: f64)

Re-bind the parameter this handle references to value. Takes effect on the next extraction/evaluation, which read the value straight from the arena.

Panics

Panics if this handle is not a bare parameter (see Self::param_id).

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

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

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

pub fn neg(self) -> Self

Unary negation as an explicit expression node. The -expr operator keeps its affine fast path. Use this method when the public UnaryOp node is required.

pub fn abs(self) -> Self

pub fn sqrt(self) -> Self

pub fn cbrt(self) -> Self

pub fn exp(self) -> Self

pub fn exp2(self) -> Self

pub fn expm1(self) -> Self

pub fn exp_m1(self) -> Self

Alias for Expr::expm1, matching Rust’s f64::exp_m1 spelling.

pub fn log(self) -> Self

pub fn ln(self) -> Self

Alias for Expr::log, matching Rust’s f64::ln spelling.

pub fn log2(self) -> Self

pub fn log10(self) -> Self

pub fn log1p(self) -> Self

pub fn ln_1p(self) -> Self

Alias for Expr::log1p, matching Rust’s f64::ln_1p spelling.

pub fn sin(self) -> Self

pub fn cos(self) -> Self

pub fn tan(self) -> Self

pub fn asin(self) -> Self

pub fn acos(self) -> Self

pub fn atan(self) -> Self

pub fn sinh(self) -> Self

pub fn cosh(self) -> Self

pub fn tanh(self) -> Self

pub fn asinh(self) -> Self

pub fn acosh(self) -> Self

pub fn atanh(self) -> Self

pub fn atan2(self, x: Self) -> Self

Two-argument arctangent in Rust’s y.atan2(x) argument order.

pub fn min(self, other: Self) -> Self

Pairwise minimum, flattening nested minima into deterministic n-ary nodes.

pub fn max(self, other: Self) -> Self

Pairwise maximum, flattening nested maxima into deterministic n-ary nodes.

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) -> Self

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.