Struct Variable 

pub struct Variable { /* private fields */ }

A variable in a problem. Use variables to create expressions, to express the objective and the Constraints of your model.

Variables are created using ProblemVariables::add. They implement std::ops basic math operations on f64 and i32 values.

Warning

Eq is implemented on this type, but v1 == v2 is true only if the two variables represent the same object, not if they have the same definition.

let mut vars = variables!();
let v1 = vars.add(variable().min(1).max(8));
let v2 = vars.add(variable().min(1).max(8));
assert_ne!(v1, v2);

let v1_copy = v1;
assert_eq!(v1, v1_copy);

Trait Implementations

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

type Output = Expression

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Variable> for f64

type Output = Expression

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Variable> for i32

type Output = Expression

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Variable

fn clone(&self) -> Variable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Variable

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

Formats the value using the given formatter.

impl Div<f64> for Variable

type Output = Expression

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i32> for Variable

type Output = Expression

The resulting type after applying the / operator.

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

Performs the / operation.

impl FormatWithVars for Variable

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

where FUN: FnMut(&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

Converts to this type from the input type.

impl Hash for Variable

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoAffineExpression for &Variable

type Iter = Once<(Variable, f64)>

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

fn into_expression(self) -> Expression

where Self: Sized,

Transform the value into a concrete Expression struct.

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

where Self: Sized,

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

impl IntoAffineExpression for Variable

type Iter = Once<(Variable, f64)>

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

fn into_expression(self) -> Expression

where Self: Sized,

Transform the value into a concrete Expression struct.

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

where Self: Sized,

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

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

type Output = Expression

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Variable> for f64

type Output = Expression

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Variable> for i32

type Output = Expression

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Variable

type Output = Expression

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for Variable

Useful for binary variables. !x is equivalent to 1-x.

#[cfg(any(feature = "coin_cbc", feature = "lpsolve"))] {
use good_lp::*;
variables! {pb: x (binary); y (binary); }
let solution = pb.maximise(!x + y)
                .using(default_solver)
                .solve().unwrap();
assert_eq!(solution.value(x), 0.);
assert_eq!(solution.value(y), 1.);

type Output = Expression

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl PartialEq for Variable

fn eq(&self, other: &Variable) -> 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<RHS> Shl<RHS> for Variable

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 Variable

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 Variable

type Output = Expression

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Variable> for f64

type Output = Expression

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Variable> for i32

type Output = Expression

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for Variable

impl Eq for Variable

impl StructuralPartialEq for Variable