Struct Budget 

#[non_exhaustive]
pub struct Budget {
    pub deadline: Option<Instant>,
    pub time_limit: Option<Duration>,
    pub max_pivots: Option<usize>,
}

A limit on one call: an absolute deadline, a relative time limit and/or a cap on the number of steps (pivots, iterations). Each defaults to “none”.

The deadline is checked at every step (for the simplex: before the entering column is chosen), the step cap before the step is performed, and both are shared by the i64 → i128 → 256-bit → BigInt attempts of one solve: steps begun by an attempt that overflowed its cell type still count, and the deadline is absolute. When it runs out, LpProblem::solve returns LpStatus::BudgetExhausted.

Absolute vs relative. deadline is an instant; time_limit is measured from the moment the budgeted call starts (start resolves it; when both are set the earlier applies). within is the eager form: it fixes the deadline now.

#[non_exhaustive]: build it with the constructors and with_* builders.

use std::time::Duration;
use symplex::linprog::{Budget, LpProblem, LpStatus, qi};

// min x + y  s.t.  x + 2y ≥ 1,  3x + y ≥ 1  needs two pivots: one is not enough.
let p = LpProblem::minimize(vec![qi(1), qi(1)])
    .ge(vec![qi(1), qi(2)], qi(1))
    .ge(vec![qi(3), qi(1)], qi(1));
let sol = p.clone().with_budget(Budget::max_pivots(1)).solve().unwrap();
assert_eq!(sol.status, LpStatus::BudgetExhausted);
assert!(sol.x.is_empty() && sol.objective.is_none());
// A generous budget changes nothing.
let sol = p.with_budget(Budget::within(Duration::from_secs(60)).with_max_pivots(1000)).solve().unwrap();
assert_eq!(sol.status, LpStatus::Optimal);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

deadline: Option<Instant>

Stop once this instant has passed.

time_limit: Option<Duration>

Time allowed, measured from the start of the budgeted call. When both this and deadline are set the earlier one applies.

max_pivots: Option<usize>

Stop before performing this many steps — simplex pivots, across both phases and all cell-type attempts (and, for a prover, across every LP of the call).

Implementations

impl Budget

pub const fn unlimited() -> Self

No limit at all.

pub const fn deadline(at: Instant) -> Self

A budget with only an absolute deadline.

pub const fn max_pivots(n: usize) -> Self

A budget with only a pivot (step) cap.

pub fn within(duration: Duration) -> Self

A budget whose deadline is duration from now (eager: the clock starts here, not when the call starts). A duration too large to represent as an instant means no deadline. For a per-call allowance use time_limit.

pub const fn time_limit(duration: Duration) -> Self

A budget with only a relative time limit, resolved when the call starts.

pub fn with_deadline(self, at: Instant) -> Self

Set (or replace) the absolute deadline.

pub fn with_time_limit(self, limit: Duration) -> Self

Set (or replace) the relative time limit.

pub fn with_max_pivots(self, n: usize) -> Self

Set (or replace) the pivot cap.

pub fn with_max_steps(self, n: usize) -> Self

Set (or replace) the step cap — the same field as with_max_pivots, named for algorithms whose step is not a pivot.

pub const fn is_unlimited(&self) -> bool

Is every limit absent?

pub fn deadline_from_now(&self) -> Option<Instant>

The deadline of a call starting now: the earlier of deadline and now + time_limit (see deadline_from).

pub fn start(&self) -> Self

The budget of a call starting now: the relative time limit is folded into the absolute deadline (the earlier of the two) and cleared, so the result can be checked with deadline_passed alone.

pub fn deadline_passed(&self) -> bool

Has the absolute deadline passed? Only deadline is consulted — call start first to account for a time_limit.

pub fn exhausted(&self, spent: usize) -> Option<BudgetHit>

Which limit has run out after spent steps, if any: the deadline is reported before the step cap.

Trait Implementations

impl Clone for Budget

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 Budget

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

Formats the value using the given formatter.

impl Default for Budget

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Budget

impl PartialEq for Budget

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Budget