Struct good_lp::Expression

pub struct Expression { /* fields omitted */ }

Represents an affine expression, such as 2x + 3 or x + y + z

Implementations

impl Expression

pub fn with_capacity(capacity: usize) -> Self

Create an expression that has the value 0, but has memory allocated for capacity coefficients.

pub fn from_other_affine<E: IntoAffineExpression>(source: E) -> Self

Create a concrete expression struct from anything that has linear coefficients and a constant

Expression::from_other_affine(0.); // A constant expression

pub fn leq<RHS>(self, rhs: RHS) -> Constraint where
    Expression: Sub<RHS, Output = Expression>, 

Creates a constraint indicating that this expression is lesser than or equal to the right hand side

pub fn geq<RHS: Sub<Expression, Output = Expression>>(
    self,
    rhs: RHS
) -> Constraint

Creates a constraint indicating that this expression is greater than or equal to the right hand side

pub fn eq<RHS>(self, rhs: RHS) -> Constraint where
    Expression: Sub<RHS, Output = Expression>, 

Creates a constraint indicating that this expression is equal to the right hand side

pub fn add_mul<N: Into<f64>, E: IntoAffineExpression>(&mut self, a: N, b: E)

Performs self = self + (a * b)

pub fn eval_with<S: Solution>(&self, values: &S) -> f64

Evaluate the concrete value of the expression, given the values of the variables

Examples

Evaluate an expression using a solution

use good_lp::{variables, variable, coin_cbc, SolverModel, Solution};
let mut vars = variables!();
let a = vars.add(variable().max(1));
let b = vars.add(variable().max(4));
let objective = a + b;
let solution = vars.maximise(objective.clone()).using(coin_cbc).solve()?;
assert_eq!(objective.eval_with(&solution), 5.);

Evaluate an expression with a HashMap

A HashMap is a valid Solution

use std::collections::HashMap;
use good_lp::{variables, Variable};
let mut vars = variables!();
let a = vars.add_variable();
let b = vars.add_variable();
let expr = a + b / 2;
let var_mapping: HashMap<_, _> = vec![(a, 3), (b, 10)].into_iter().collect();
let value = expr.eval_with(&var_mapping);
assert_eq!(value, 8.);

Trait Implementations

impl<RHS: IntoAffineExpression> Add<RHS> for Expression

type Output = Expression

The resulting type after applying the + operator.

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

Performs the + operation.

impl<RHS: IntoAffineExpression> AddAssign<RHS> for Expression

fn add_assign(&mut self, rhs: RHS)

Performs the += operation.

impl Clone for Expression

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl Default for Expression

fn default() -> Self

Returns the “default value” for a type.

impl<N: Into<f64>> Div<N> for Expression

type Output = Expression

The resulting type after applying the / operator.

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

Performs the / operation.

impl FormatWithVars for Expression

fn format_with<FUN>(
    &self,
    f: &mut Formatter<'_>,
    variable_format: FUN
) -> Result where
    FUN: Fn(&mut Formatter<'_>, Variable) -> Result, 

Write the element to the formatter. See std::fmt::Display

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

Write the elements, naming the variables v0, v1, … vn

impl From<Variable> for Expression

fn from(x: Variable) -> Expression

Performs the conversion.

impl From<f64> for Expression

fn from(x: f64) -> Expression

Performs the conversion.

impl From<i32> for Expression

fn from(x: i32) -> Expression

Performs the conversion.

impl IntoAffineExpression for Expression

type Iter = <LinearExpression as IntoAffineExpression>::Iter

The iterator returned by linear_coefficients.

fn linear_coefficients(self) -> Self::Iter

An iterator over variables and their coefficients. For instance a + 2b - 3a - 7 should yield [(a, -2), (b, 2)]

fn constant(&self) -> f64

The constant factor in the expression. For instance, a + 2b - 7 will give -7

impl<'a> IntoAffineExpression for &'a Expression

This implementation copies all the variables and coefficients from the referenced Expression into the created iterator

type Iter = <&'a LinearExpression as IntoAffineExpression>::Iter

The iterator returned by linear_coefficients.

fn linear_coefficients(self) -> Self::Iter

An iterator over variables and their coefficients. For instance a + 2b - 3a - 7 should yield [(a, -2), (b, 2)]

fn constant(&self) -> f64

The constant factor in the expression. For instance, a + 2b - 7 will give -7

impl<N: Into<f64>> Mul<N> for Expression

type Output = Expression

The resulting type after applying the * operator.

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

Performs the * operation.

impl<N: Into<f64>> MulAssign<N> for Expression

fn mul_assign(&mut self, rhs: N)

Performs the *= operation.

impl Neg for Expression

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq<Expression> for Expression

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<RHS> Shl<RHS> for Expression where
    Self: Sub<RHS, Output = Expression>, 

type Output = Constraint

The resulting type after applying the << operator.

fn shl(self, rhs: RHS) -> Self::Output

Performs the << operation.

impl<RHS: Sub<Self, Output = Expression>> Shr<RHS> for Expression

type Output = Constraint

The resulting type after applying the >> operator.

fn shr(self, rhs: RHS) -> Self::Output

Performs the >> operation.

impl<RHS: IntoAffineExpression> Sub<RHS> for Expression

type Output = Expression

The resulting type after applying the - operator.

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

Performs the - operation.

impl<RHS: IntoAffineExpression> SubAssign<RHS> for Expression

fn sub_assign(&mut self, rhs: RHS)

Performs the -= operation.

impl<E: IntoAffineExpression> Sum<E> for Expression

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

Method which takes an iterator and generates Self from the elements by “summing up” the items.