Struct VariableDefinition

pub struct VariableDefinition { /* private fields */ }

Defines the properties of a variable, such as its lower and upper bounds.

Implementations

impl VariableDefinition

pub fn new() -> Self

Creates an unbounded continuous linear variable

pub fn integer(self) -> Self

Define the variable as an integer. The variable will only be able to take an integer value in the solution.

Warning: not all solvers support integer variables. Refer to the documentation of the solver you are using.

let mut problem = ProblemVariables::new();
let x = problem.add(variable().integer().min(0).max(2.5));
let solution = problem.maximise(x).using(default_solver).solve().unwrap();
// x is bound to [0; 2.5], but the solution is x=2 because x needs to be an integer
assert_eq!(solution.value(x), 2.);

pub fn binary(self) -> Self

Define the variable as an integer that can only take the value 0 or 1.

Warning: not all solvers support integer variables. Refer to the documentation of the solver you are using.

let mut problem = ProblemVariables::new();
let x = problem.add(variable().binary());
let y = problem.add(variable().binary());
if cfg!(not(any(feature="clarabel"))) {
    let solution = problem.maximise(x + y).using(default_solver).solve().unwrap();
    assert_eq!(solution.value(x), 1.);
    assert_eq!(solution.value(y), 1.);
}

pub fn initial<N: Into<f64>>(self, value: N) -> Self

Set the initial value of the variable. This may help the solver to find a solution significantly faster.

Note that the given value may be disregarded by some solvers if with_initial_solution is called on the problem instance. It is advisable to rely either on with_initial_solution, or to set initial values on the variables directly, but not both.

Warning: not all solvers support initial solutions. Refer to the documentation of the solver you are using.

let mut problem = ProblemVariables::new();
let x = problem.add(variable().max(3).initial(3));
let y = problem.add(variable().max(5).initial(5));
if cfg!(not(any(feature="clarabel"))) {
    let solution = problem.maximise(x + y).using(default_solver).solve().unwrap();
    assert_eq!(solution.value(x), 3.);
    assert_eq!(solution.value(y), 5.);
}

pub fn name<S: Into<String>>(self, name: S) -> Self

Set the name of the variable. This is useful in particular when displaying the problem for debugging purposes.

let mut pb = ProblemVariables::new();
let x = pb.add(variable().name("x"));
assert_eq!("x", pb.display(&x).to_string());

pub fn bounds<N: Into<f64> + Copy, B: RangeBounds<N>>(self, bounds: B) -> Self

Set the lower and/or higher bounds of the variable

Examples

assert_eq!(
    variable().bounds(1..2),
    variable().min(1).max(2)
);

assert_eq!(
    variable().bounds(1..),
    variable().min(1)
);

assert_eq!(
    variable().bounds(..=2),
    variable().max(2)
);

pub fn min<N: Into<f64>>(self, min: N) -> Self

Set the lower bound of the variable

pub fn max<N: Into<f64>>(self, max: N) -> Self

Set the higher bound of the variable

pub fn clamp<N1: Into<f64>, N2: Into<f64>>(self, min: N1, max: N2) -> Self

Set both the lower and higher bounds of the variable

Trait Implementations

impl Clone for VariableDefinition

fn clone(&self) -> VariableDefinition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VariableDefinition

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

Formats the value using the given formatter.

impl Default for VariableDefinition

Creates an unbounded continuous linear variable

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for VariableDefinition

fn eq(&self, other: &VariableDefinition) -> 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 StructuralPartialEq for VariableDefinition