Struct highs::Problem

pub struct Problem<MATRIX = ColMatrix> { /* private fields */ }

A complete optimization problem. Depending on the MATRIX type parameter, the problem will be built constraint by constraint (with ColProblem), or variable by variable (with RowProblem)

Implementations

impl Problem<ColMatrix>

To use these functions, you need to first add all your constraints, and then add variables one by one using the Row objects.

pub fn add_row<N: Into<f64> + Copy, B: RangeBounds<N>>(
    &mut self,
    bounds: B
) -> Row

Add a row (a constraint) to the problem. The concrete factors are added later, when creating columns.

pub fn add_column<N: Into<f64> + Copy, B: RangeBounds<N>, ITEM: Borrow<(Row, f64)>, I: IntoIterator<Item = ITEM>>(
    &mut self,
    col_factor: f64,
    bounds: B,
    row_factors: I
)

Add a continuous variable to the problem.

• col_factor represents the factor in front of the variable in the objective function.
• bounds represents the maximal and minimal allowed values of the variable.
• row_factors defines how much this variable weights in each constraint.

use highs::{ColProblem, Sense};
let mut pb = ColProblem::new();
let constraint = pb.add_row(..=5); // adds a constraint that cannot take a value over 5
// add a variable that has a coefficient 2 in the objective function, is >=0, and has a coefficient
// 2 in the constraint
pb.add_column(2., 0.., &[(constraint, 2.)]);

pub fn add_integer_column<N: Into<f64> + Copy, B: RangeBounds<N>, ITEM: Borrow<(Row, f64)>, I: IntoIterator<Item = ITEM>>(
    &mut self,
    col_factor: f64,
    bounds: B,
    row_factors: I
)

Same as add_column, but forces the solution to contain an integer value for this variable.

use highs::{ColProblem, Sense};
let mut pb = ColProblem::new();
let constraint = pb.add_row(..=5); // adds a constraint that cannot take a value over 5
// add an integer variable that has a coefficient 2 in the objective function, is >=0, and has a coefficient
// 2 in the constraint
pb.add_integer_column(2., 0.., &[(constraint, 2.)]);

pub fn add_column_with_integrality<N: Into<f64> + Copy, B: RangeBounds<N>, ITEM: Borrow<(Row, f64)>, I: IntoIterator<Item = ITEM>>(
    &mut self,
    col_factor: f64,
    bounds: B,
    row_factors: I,
    is_integer: bool
)

Same as add_column, but lets you define whether the new variable should be integral or continuous.

impl Problem<RowMatrix>

Functions to use when first declaring variables, then constraints.

pub fn add_column<N: Into<f64> + Copy, B: RangeBounds<N>>(
    &mut self,
    col_factor: f64,
    bounds: B
) -> Col

add a variable to the problem.

• col_factor is the coefficient in front of the variable in the objective function.
• bounds are the maximal and minimal values that the variable can take.

pub fn add_integer_column<N: Into<f64> + Copy, B: RangeBounds<N>>(
    &mut self,
    col_factor: f64,
    bounds: B
) -> Col

Same as add_column, but forces the solution to contain an integer value for this variable.

pub fn add_column_with_integrality<N: Into<f64> + Copy, B: RangeBounds<N>>(
    &mut self,
    col_factor: f64,
    bounds: B,
    is_integer: bool
) -> Col

Same as add_column, but lets you define whether the new variable should be integral or continuous.

pub fn add_row<N: Into<f64> + Copy, B: RangeBounds<N>, ITEM: Borrow<(Col, f64)>, I: IntoIterator<Item = ITEM>>(
    &mut self,
    bounds: B,
    row_factors: I
)

Add a constraint to the problem.

• bounds are the maximal and minimal allowed values for the linear expression in the constraint
• row_factors are the coefficients in the linear expression expressing the constraint

use highs::*;
let mut pb = RowProblem::new();
// Optimize 3x - 2y with x<=6 and y>=5
let x = pb.add_column(3., ..6);
let y = pb.add_column(-2., 5..);
pb.add_row(2.., &[(x, 3.), (y, 8.)]); // 2 <= x*3 + y*8

impl<MATRIX: Default> Problem<MATRIX> where
    Problem<ColMatrix>: From<Problem<MATRIX>>, 

pub fn num_cols(&self) -> usize

Number of variables in the problem

pub fn num_rows(&self) -> usize

Number of constraints in the problem

pub fn optimise(self, sense: Sense) -> Model

Create a model based on this problem. Don’t solve it yet. If the problem is a RowProblem, it will have to be converted to a ColProblem first, which takes an amount of time proportional to the size of the problem. If the problem is invalid (according to HiGHS), this function will panic.

pub fn try_optimise(self, sense: Sense) -> Result<Model, HighsStatus>

Create a model based on this problem. Don’t solve it yet. If the problem is a RowProblem, it will have to be converted to a ColProblem first, which takes an amount of time proportional to the size of the problem.

pub fn new() -> Self

Create a new problem instance

Trait Implementations

impl<MATRIX: Clone> Clone for Problem<MATRIX>

fn clone(&self) -> Problem<MATRIX>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<MATRIX: Debug> Debug for Problem<MATRIX>

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

Formats the value using the given formatter.

impl<MATRIX: Default> Default for Problem<MATRIX>

fn default() -> Problem<MATRIX>

Returns the “default value” for a type.

impl From<Problem<RowMatrix>> for Problem<ColMatrix>

fn from(pb: Problem<RowMatrix>) -> Problem<ColMatrix>

Converts to this type from the input type.

impl<MATRIX: PartialEq> PartialEq<Problem<MATRIX>> for Problem<MATRIX>

fn eq(&self, other: &Problem<MATRIX>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<MATRIX> StructuralPartialEq for Problem<MATRIX>