Struct NetworkSimplex 

pub struct NetworkSimplex<G, F> {
    pub pricing: Pricing,
    pub zero: F,
    pub artificial_cost: Option<F>,
    pub infinite: F,
    /* private fields */
}

A primal network simplex algorithm.

Fields

pricing: Pricing

zero: F

The (flow) value to be considered zero. Defaults to F::zero().

artificial_cost: Option<F>

The artificial cost value.

Should be larger than the value of any augmenting cycle. If None (the default) the artificial cost is set to (max(max(cost), 0) + 1) * n, which should be large enough.

infinite: F

The infinite flow value.

Capacities greater than or equal to this are considered unbounded and flows are considered infinite. The default is F::max_value(). For floating-point types F::infinity() can be used as well.

Implementations

impl<G, F> NetworkSimplex<G, F>

where G: IndexDigraph, F: Bounded + NumCast + NumAssign + PartialOrd + Copy + FromPrimitive + Signed,

pub fn new(g: G) -> Self

pub fn as_graph(&self) -> &G

pub fn balance(&self, u: <G as GraphType>::Node<'_>) -> F

pub fn set_balance(&mut self, u: <G as GraphType>::Node<'_>, balance: F)

pub fn set_balances<'a, Bs>(&'a mut self, balance: Bs)

where Bs: Fn(<G as GraphType>::Node<'a>) -> F,

pub fn lower(&self, e: <G as GraphType>::Edge<'_>) -> F

pub fn set_lower(&mut self, e: <G as GraphType>::Edge<'_>, lb: F)

pub fn set_lowers<'a, Ls>(&'a mut self, lower: Ls)

where Ls: Fn(<G as GraphType>::Edge<'a>) -> F,

pub fn upper(&self, e: <G as GraphType>::Edge<'_>) -> F

pub fn set_upper(&mut self, e: <G as GraphType>::Edge<'_>, ub: F)

pub fn set_uppers<'a, Us>(&'a mut self, upper: Us)

where Us: Fn(<G as GraphType>::Edge<'a>) -> F,

pub fn cost(&self, e: <G as GraphType>::Edge<'_>) -> F

pub fn set_cost(&mut self, e: <G as GraphType>::Edge<'_>, cost: F)

pub fn set_costs<'a, Cs>(&'a mut self, cost: Cs)

where Cs: Fn(<G as GraphType>::Edge<'a>) -> F,

pub fn value(&self) -> F

Return the value of the latest computed flow value.

pub fn flow(&self, a: <G as GraphType>::Edge<'_>) -> F

The flow of an Edge.

pub fn solve(&mut self) -> SolutionState

Solve the min-cost-flow problem.

pub fn solution_state(&self) -> SolutionState

Return the solution state of the latest computation.

pub fn num_iterations(&self) -> usize