Enum Expr 

pub enum Expr {
    Const(f64),
    Var(VarId),
    Add(Box<Expr>, Box<Expr>),
    Sub(Box<Expr>, Box<Expr>),
    Mul(Box<Expr>, Box<Expr>),
    Div(Box<Expr>, Box<Expr>),
    Neg(Box<Expr>),
    Sin(Box<Expr>),
    Cos(Box<Expr>),
    Sqrt(Box<Expr>),
    Abs(Box<Expr>),
    Atan2(Box<Expr>, Box<Expr>),
    Hypot(Box<Expr>, Box<Expr>),
    Min(Box<Expr>, Box<Expr>),
    Max(Box<Expr>, Box<Expr>),
}

A scalar expression.

Variants

Const(f64)

Constant.

Var(VarId)

Variable.

Add(Box<Expr>, Box<Expr>)

a + b.

Sub(Box<Expr>, Box<Expr>)

a - b.

Mul(Box<Expr>, Box<Expr>)

a * b.

Div(Box<Expr>, Box<Expr>)

a / b.

Neg(Box<Expr>)

-a.

Sin(Box<Expr>)

sin a.

Cos(Box<Expr>)

cos a.

Sqrt(Box<Expr>)

sqrt a (domain a ≥ 0; negative inputs evaluate to NaN).

Abs(Box<Expr>)

|a|.

Atan2(Box<Expr>, Box<Expr>)

atan2(y, x).

Hypot(Box<Expr>, Box<Expr>)

hypot(x, y).

Min(Box<Expr>, Box<Expr>)

min(a, b).

Max(Box<Expr>, Box<Expr>)

max(a, b).

Implementations

impl Expr

pub const fn c(v: f64) -> Self

Constant expression.

pub const fn var(v: VarId) -> Self

Variable expression.

pub fn add(a: Self, b: Self) -> Self

Simplifying constructor for a + b.

pub fn sub(a: Self, b: Self) -> Self

Simplifying constructor for a - b.

pub fn mul(a: Self, b: Self) -> Self

Simplifying constructor for a * b.

pub fn div(a: Self, b: Self) -> Self

Simplifying constructor for a / b.

pub fn neg(a: Self) -> Self

Simplifying constructor for -a.

pub fn sin(a: Self) -> Self

sin a.

pub fn cos(a: Self) -> Self

cos a.

pub fn sqrt(a: Self) -> Self

sqrt a.

pub fn abs(a: Self) -> Self

|a|.

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

atan2(y, x).

pub fn hypot(x: Self, y: Self) -> Self

hypot(x, y).

pub fn min(a: Self, b: Self) -> Self

min(a, b).

pub fn max(a: Self, b: Self) -> Self

max(a, b).

pub fn eval(&self, x: &[f64]) -> f64

Evaluate with variable values x (missing variables evaluate to NaN).

pub fn eval_dual(&self, x: &[f64]) -> Dual

Evaluate value and exact gradient.

Non-smooth points use a deterministic one-sided derivative: |0|' = 0, sqrt'(0) = 0, hypot'(0, 0) = (1, 0), ties of min/max take the first argument.

pub fn vars(&self) -> Vec<VarId>

Variables referenced by the expression (sorted, unique).

pub fn linear_form( &self, x: &[f64], fixed: &dyn Fn(VarId) -> bool, ) -> Option<LinearForm>

Affine form Σ cᵢ·xᵢ + k if the expression is exactly linear in the variables whose fixed[i] is false (fixed variables are folded into the constant).

pub fn substitute(&self, f: &dyn Fn(VarId) -> Self) -> Self

Replace every variable by the expression returned by f (constant folding is applied by the simplifying constructors).

pub fn size(&self) -> usize

Number of nodes (used for complexity limits).

Trait Implementations

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 Display for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Expr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expr