Struct good_lp::Expression

pub struct Expression<F> { /* fields omitted */ }

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

Implementations

impl<F> Expression<F>

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

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

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

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<F> where
    Expression<F>: Sub<RHS, Output = Expression<F>>, 

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

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

Performs self = self + (a * b)

pub fn eval_with<S: Solution<F>>(&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<'a, F> Add<&'a Expression<F>> for Expression<F>

type Output = Expression<F>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Expression<F>) -> Self::Output

Performs the + operation.

impl<F, RHS: Into<Expression<F>>> Add<RHS> for Expression<F>

type Output = Expression<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, F> AddAssign<&'a Expression<F>> for Expression<F>

fn add_assign(&mut self, rhs: &'a Expression<F>)

Performs the += operation.

impl<F, RHS: Into<Expression<F>>> AddAssign<RHS> for Expression<F>

fn add_assign(&mut self, rhs: RHS)

Performs the += operation.

impl<F> Clone for Expression<F>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Expression<T>

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

Formats the value using the given formatter.

impl<F> Default for Expression<F>

fn default() -> Self

Returns the "default value" for a type.

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

type Output = Expression<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F> FormatWithVars<F> for Expression<F>

fn format_with<FUN>(
    &self,
    f: &mut Formatter<'_>,
    variable_format: FUN
) -> Result where
    FUN: Fn(&mut Formatter<'_>, Variable<F>) -> 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<'a, F> From<&'a Variable<F>> for Expression<F>

fn from(var: &'a Variable<F>) -> Self

Performs the conversion.

impl<F, N: Into<f64>> From<N> for Expression<F>

fn from(constant: N) -> Self

Performs the conversion.

impl<F> From<Variable<F>> for Expression<F>

fn from(var: Variable<F>) -> Self

Performs the conversion.

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

type Output = Expression<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn mul_assign(&mut self, rhs: N)

Performs the *= operation.

impl<T> Neg for Expression<T>

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F> PartialEq<Expression<F>> for Expression<F>

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<F, RHS> Shl<RHS> for Expression<F> where
    Self: Sub<RHS, Output = Expression<F>>, 

type Output = Constraint<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Constraint<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'a, F> Sub<&'a Expression<F>> for Expression<F>

type Output = Expression<F>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Expression<F>) -> Self::Output

Performs the - operation.

impl<F, RHS: Into<Expression<F>>> Sub<RHS> for Expression<F>

type Output = Expression<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, F> SubAssign<&'a Expression<F>> for Expression<F>

fn sub_assign(&mut self, rhs: &'a Expression<F>)

Performs the -= operation.

impl<F, RHS: Into<Expression<F>>> SubAssign<RHS> for Expression<F>

fn sub_assign(&mut self, rhs: RHS)

Performs the -= operation.

impl<'a, F, A> Sum<A> for Expression<F> where
    Expression<F>: From<A>, 

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

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