Struct LinearExpr 

pub struct LinearExpr<T: ExprVariable> {
    pub terms: Vec<(T, f64)>,
    pub constant: f64,
}

A linear expression stored as a sorted sparse vector. Invariants:

1. terms is always sorted by Variable T.
2. terms never contains coefficients with abs() < tolerance (effectively zero).

Fields

terms: Vec<(T, f64)>

constant: f64

Implementations

impl<T: ExprVariable> LinearExpr<T>

pub fn new() -> Self

pub fn with_term(var: T, coefficient: f64) -> Self

pub fn with_terms(terms: Vec<(T, f64)>) -> Self

pub fn with_constant(constant: f64) -> Self

pub fn with_terms_and_constant(terms: Vec<(T, f64)>, constant: f64) -> Self

pub fn coefficient(&self, var: &T) -> f64

pub fn add_term(&mut self, var: T, coefficient: f64)

pub fn remove_term(&mut self, var: &T) -> Option<f64>

pub fn add_expr(&mut self, other: &Self)

pub fn sub_expr(&mut self, other: &Self)

pub fn add_scaled_expr(&mut self, other: &Self, scale: f64)

pub fn add_constant(&mut self, constant: f64)

pub fn scale(&mut self, scalar: f64)

pub fn replace_var_with_expr( &mut self, var: T, replacement_expr: &LinearExpr<T>, ) -> Option<f64>

Trait Implementations

impl<'a> Add<&'a LinearExpr<DictionaryVariableKey>> for f64

Implements f64 + &Expr

type Output = LinearExpr<DictionaryVariableKey>

The resulting type after applying the + operator.

fn add( self, expr: &'a LinearExpr<DictionaryVariableKey>, ) -> LinearExpr<DictionaryVariableKey>

Performs the + operation.

impl<'a> Add<&'a LinearExpr<StandardVariableKey>> for f64

Implements f64 + &Expr

type Output = LinearExpr<StandardVariableKey>

The resulting type after applying the + operator.

fn add( self, expr: &'a LinearExpr<StandardVariableKey>, ) -> LinearExpr<StandardVariableKey>

Performs the + operation.

impl<'a, T: ExprVariable> Add<&'a LinearExpr<T>> for LinearExpr<T>

Implements Expr + &Expr (Reuse LHS)

type Output = LinearExpr<T>

The resulting type after applying the + operator.

fn add(self, rhs: &'a LinearExpr<T>) -> Self

Performs the + operation.

impl<'a> Add<&'a LinearExpr<VariableKey>> for f64

Implements f64 + &Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the + operator.

fn add(self, expr: &'a LinearExpr<VariableKey>) -> LinearExpr<VariableKey>

Performs the + operation.

impl Add<LinearExpr<DictionaryVariableKey>> for f64

Implements f64 + Expr

type Output = LinearExpr<DictionaryVariableKey>

The resulting type after applying the + operator.

fn add( self, expr: LinearExpr<DictionaryVariableKey>, ) -> LinearExpr<DictionaryVariableKey>

Performs the + operation.

impl Add<LinearExpr<StandardVariableKey>> for f64

Implements f64 + Expr

type Output = LinearExpr<StandardVariableKey>

The resulting type after applying the + operator.

fn add( self, expr: LinearExpr<StandardVariableKey>, ) -> LinearExpr<StandardVariableKey>

Performs the + operation.

impl Add<LinearExpr<VariableKey>> for VariableKey

Implements Var + Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the + operator.

fn add(self, expr: LinearExpr<VariableKey>) -> Self::Output

Performs the + operation.

impl Add<LinearExpr<VariableKey>> for f64

Implements f64 + Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the + operator.

fn add(self, expr: LinearExpr<VariableKey>) -> LinearExpr<VariableKey>

Performs the + operation.

impl<T: ExprVariable> Add<T> for LinearExpr<T>

Implements Expr + Var

type Output = LinearExpr<T>

The resulting type after applying the + operator.

fn add(self, var: T) -> Self

Performs the + operation.

impl<'a, T: ExprVariable> Add<f64> for &'a LinearExpr<T>

Implements &Expr + f64 (creates new Owned)

type Output = LinearExpr<T>

The resulting type after applying the + operator.

fn add(self, constant: f64) -> LinearExpr<T>

Performs the + operation.

impl<T: ExprVariable> Add<f64> for LinearExpr<T>

Implements Expr + f64

type Output = LinearExpr<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: ExprVariable> Add for LinearExpr<T>

Implements Expr + Expr (Reuse LHS)

type Output = LinearExpr<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: ExprVariable> AddAssign for LinearExpr<T>

Implements Expr += Expr

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T: Clone + ExprVariable> Clone for LinearExpr<T>

fn clone(&self) -> LinearExpr<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ExprVariable> Debug for LinearExpr<T>

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

Formats the value using the given formatter.

impl Display for LinearExpr<DictionaryVariableKey>

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

Formats the value using the given formatter.

impl Display for LinearExpr<StandardVariableKey>

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

Formats the value using the given formatter.

impl Display for LinearExpr<VariableKey>

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

Formats the value using the given formatter.

impl<'a, T: ExprVariable> Div<f64> for &'a LinearExpr<T>

Implements &Expr / f64 (creates new Owned)

type Output = LinearExpr<T>

The resulting type after applying the / operator.

fn div(self, scalar: f64) -> LinearExpr<T>

Performs the / operation.

impl<T: ExprVariable> Div<f64> for LinearExpr<T>

Implements Expr / f64

type Output = LinearExpr<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<VariableKey> for LinearExpr<VariableKey>

Implements From<Var> for LinearExpr

fn from(var: VariableKey) -> Self

Converts to this type from the input type.

impl<T: ExprVariable> From<f64> for LinearExpr<T>

Implements From<f64> for LinearExpr.

fn from(constant: f64) -> Self

Converts to this type from the input type.

impl<'a> Mul<&'a LinearExpr<DictionaryVariableKey>> for f64

Implements f64 * &Expr

type Output = LinearExpr<DictionaryVariableKey>

The resulting type after applying the * operator.

fn mul( self, expr: &'a LinearExpr<DictionaryVariableKey>, ) -> LinearExpr<DictionaryVariableKey>

Performs the * operation.

impl<'a> Mul<&'a LinearExpr<StandardVariableKey>> for f64

Implements f64 * &Expr

type Output = LinearExpr<StandardVariableKey>

The resulting type after applying the * operator.

fn mul( self, expr: &'a LinearExpr<StandardVariableKey>, ) -> LinearExpr<StandardVariableKey>

Performs the * operation.

impl<'a> Mul<&'a LinearExpr<VariableKey>> for f64

Implements f64 * &Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the * operator.

fn mul(self, expr: &'a LinearExpr<VariableKey>) -> LinearExpr<VariableKey>

Performs the * operation.

impl Mul<LinearExpr<DictionaryVariableKey>> for f64

Implements f64 * Expr

type Output = LinearExpr<DictionaryVariableKey>

The resulting type after applying the * operator.

fn mul( self, expr: LinearExpr<DictionaryVariableKey>, ) -> LinearExpr<DictionaryVariableKey>

Performs the * operation.

impl Mul<LinearExpr<StandardVariableKey>> for f64

Implements f64 * Expr

type Output = LinearExpr<StandardVariableKey>

The resulting type after applying the * operator.

fn mul( self, expr: LinearExpr<StandardVariableKey>, ) -> LinearExpr<StandardVariableKey>

Performs the * operation.

impl Mul<LinearExpr<VariableKey>> for f64

Implements f64 * Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the * operator.

fn mul(self, expr: LinearExpr<VariableKey>) -> LinearExpr<VariableKey>

Performs the * operation.

impl<'a, T: ExprVariable> Mul<f64> for &'a LinearExpr<T>

Implements &Expr * f64 (creates new Owned)

type Output = LinearExpr<T>

The resulting type after applying the * operator.

fn mul(self, scalar: f64) -> LinearExpr<T>

Performs the * operation.

impl<T: ExprVariable> Mul<f64> for LinearExpr<T>

Implements Expr * f64

type Output = LinearExpr<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T: ExprVariable> Neg for &'a LinearExpr<T>

Implements -&Expr (creates new Owned)

type Output = LinearExpr<T>

The resulting type after applying the - operator.

fn neg(self) -> LinearExpr<T>

Performs the unary - operation.

impl<T: ExprVariable> Neg for LinearExpr<T>

Implements -Expr

type Output = LinearExpr<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<'a> Sub<&'a LinearExpr<DictionaryVariableKey>> for f64

Implements f64 - &Expr

type Output = LinearExpr<DictionaryVariableKey>

The resulting type after applying the - operator.

fn sub( self, expr: &'a LinearExpr<DictionaryVariableKey>, ) -> LinearExpr<DictionaryVariableKey>

Performs the - operation.

impl<'a> Sub<&'a LinearExpr<StandardVariableKey>> for f64

Implements f64 - &Expr

type Output = LinearExpr<StandardVariableKey>

The resulting type after applying the - operator.

fn sub( self, expr: &'a LinearExpr<StandardVariableKey>, ) -> LinearExpr<StandardVariableKey>

Performs the - operation.

impl<'a, T: ExprVariable> Sub<&'a LinearExpr<T>> for LinearExpr<T>

Implements Expr - &Expr (Reuse LHS)

type Output = LinearExpr<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a LinearExpr<T>) -> Self

Performs the - operation.

impl<'a> Sub<&'a LinearExpr<VariableKey>> for f64

Implements f64 - &Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the - operator.

fn sub(self, expr: &'a LinearExpr<VariableKey>) -> LinearExpr<VariableKey>

Performs the - operation.

impl Sub<LinearExpr<DictionaryVariableKey>> for f64

Implements f64 - Expr

type Output = LinearExpr<DictionaryVariableKey>

The resulting type after applying the - operator.

fn sub( self, expr: LinearExpr<DictionaryVariableKey>, ) -> LinearExpr<DictionaryVariableKey>

Performs the - operation.

impl Sub<LinearExpr<StandardVariableKey>> for f64

Implements f64 - Expr

type Output = LinearExpr<StandardVariableKey>

The resulting type after applying the - operator.

fn sub( self, expr: LinearExpr<StandardVariableKey>, ) -> LinearExpr<StandardVariableKey>

Performs the - operation.

impl Sub<LinearExpr<VariableKey>> for VariableKey

Implements Var - Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the - operator.

fn sub(self, expr: LinearExpr<VariableKey>) -> Self::Output

Performs the - operation.

impl Sub<LinearExpr<VariableKey>> for f64

Implements f64 - Expr

type Output = LinearExpr<VariableKey>

The resulting type after applying the - operator.

fn sub(self, expr: LinearExpr<VariableKey>) -> LinearExpr<VariableKey>

Performs the - operation.

impl<T: ExprVariable> Sub<T> for LinearExpr<T>

Implements Expr - Var

type Output = LinearExpr<T>

The resulting type after applying the - operator.

fn sub(self, var: T) -> Self

Performs the - operation.

impl<'a, T: ExprVariable> Sub<f64> for &'a LinearExpr<T>

Implements &Expr - f64 (creates new Owned)

type Output = LinearExpr<T>

The resulting type after applying the - operator.

fn sub(self, constant: f64) -> LinearExpr<T>

Performs the - operation.

impl<T: ExprVariable> Sub<f64> for LinearExpr<T>

Implements Expr - f64

type Output = LinearExpr<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: ExprVariable> Sub for LinearExpr<T>

Implements Expr - Expr (Reuse LHS)

type Output = LinearExpr<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: ExprVariable> SubAssign for LinearExpr<T>

Implements Expr -= Expr

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.