Struct LpProblem 

pub struct LpProblem { /* private fields */ }

A linear program in builder form. See the module docs for the problem shape and the meaning of the results.

Every variable defaults to 0 ≤ xⱼ < ∞; change that with bounds or free. Constraint rows are kept in insertion order, which is also the order of LpSolution::duals and LpSolution::farkas.

Examples

use symplex::linprog::{LpProblem, LpStatus, q, qi};

// min x + y  s.t.  x + 2y ≥ 1,  3x + y ≥ 1,  x, y ≥ 0   →  (1/5, 2/5)
let sol = LpProblem::minimize(vec![qi(1), qi(1)])
    .ge(vec![qi(1), qi(2)], qi(1))
    .ge(vec![qi(3), qi(1)], qi(1))
    .solve()
    .unwrap();
assert_eq!(sol.status, LpStatus::Optimal);
assert_eq!(sol.x, vec![q(1, 5), q(2, 5)]);
assert_eq!(sol.objective, Some(q(3, 5)));

Implementations

impl LpProblem

pub fn minimize(c: Vec<Q>) -> Self

Start a minimisation of cᵀx over x ∈ ℚ^{c.len()}.

pub fn maximize(c: Vec<Q>) -> Self

Start a maximisation of cᵀx over x ∈ ℚ^{c.len()}.

pub fn eq(self, row: Vec<Q>, rhs: Q) -> Self

Add the equality constraint row·x = rhs.

pub fn le(self, row: Vec<Q>, rhs: Q) -> Self

Add the inequality constraint row·x ≤ rhs.

pub fn ge(self, row: Vec<Q>, rhs: Q) -> Self

Add the inequality constraint row·x ≥ rhs.

pub fn bounds(self, var: usize, bounds: Bounds<Q>) -> Self

Set the bounds lower ≤ x[var] ≤ upper of one variable: .bounds(j, Bounds::closed(q(1, 2), qi(3))), .bounds(j, Bounds::at_most(qi(3))), …. An absent side is unbounded; Bounds::free makes the variable free (see also free).

An out-of-range var is reported by solve.

pub fn free(self, var: usize) -> Self

Make x[var] free (−∞ < x[var] < ∞).

pub fn num_vars(&self) -> usize

Number of decision variables (the length of c).

pub fn num_constraints(&self) -> usize

Number of constraint rows added so far.

pub fn with_budget(self, budget: Budget) -> Self

Bound the solve by a Budget (deadline and/or pivot cap). When it runs out, solve returns LpStatus::BudgetExhausted. The default budget is unlimited.

pub fn budget(&self) -> &Budget

The budget the solve runs under (unlimited unless with_budget was called).

pub fn solve(&self) -> Result<LpSolution, SymplexError>

Solve the program exactly.

The returned LpSolution reports LpStatus::Optimal, LpStatus::Infeasible (with a Farkas certificate), LpStatus::Unbounded or — only under a Budget — LpStatus::BudgetExhausted; none of these is an error.

Errors

• SymplexError::InvalidArgument for malformed input: no variables, a constraint row whose length differs from c.len(), or a bound set for a variable index ≥ c.len().
• SymplexError::ComputationFailed if the pivot cap (10 000 + 50·(m + n)) is exceeded — not expected in practice, since Bland’s rule rules out cycling.

Trait Implementations

impl Clone for LpProblem

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LpProblem

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

Formats the value using the given formatter.