Struct rs_graph::mcf::simplex::NetworkSimplex

pub struct NetworkSimplex<'a, G, F> {
    pub pricing: Pricing,
    pub artificial_cost: Option<F>,
    pub infinite: F,
    // some fields omitted
}

Fields

pricing: Pricing

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<'a, G, F> NetworkSimplex<'a, G, F> where
    G: IndexDigraph<'a>,
    F: NumCast + NumAssign + Signed + PartialOrd + Copy + FromPrimitive, 

pub fn num_iterations(&self) -> usize

Trait Implementations

impl<'a, G, F> MinCostFlow<'a> for NetworkSimplex<'a, G, F> where
    G: IndexDigraph<'a>,
    F: Bounded + NumCast + NumAssign + PartialOrd + Copy + FromPrimitive + Signed, 

fn value(&self) -> Self::Flow

Return the value of the latest computed flow value.

fn flow(&self, a: <Self::Graph as GraphType<'a>>::Edge) -> Self::Flow

The flow of an Edge.

fn flow_vec(&self) -> EdgeVec<'a, &'a Self::Graph, Self::Flow>

The flow as vector.

fn solve(&mut self) -> SolutionState

Solve the maxflow problem.

The method solves the max flow problem from the source nodes src to the sink node snk with the given upper bounds on the edges.

type Graph = G

type Flow = F

fn new(g: &'a Self::Graph) -> Self

fn as_graph(&self) -> &'a Self::Graph

fn balance(&self, u: <Self::Graph as GraphType<'a>>::Node) -> Self::Flow

fn set_balance(
    &mut self,
    u: <Self::Graph as GraphType<'a>>::Node,
    balance: Self::Flow
)

fn lower(&self, e: <Self::Graph as GraphType<'a>>::Edge) -> Self::Flow

fn set_lower(&mut self, e: <Self::Graph as GraphType<'a>>::Edge, lb: Self::Flow)

fn upper(&self, e: <Self::Graph as GraphType<'a>>::Edge) -> Self::Flow

fn set_upper(&mut self, e: <Self::Graph as GraphType<'a>>::Edge, ub: Self::Flow)

fn cost(&self, e: <Self::Graph as GraphType<'a>>::Edge) -> Self::Flow

fn set_cost(
    &mut self,
    e: <Self::Graph as GraphType<'a>>::Edge,
    cost: Self::Flow
)

fn solution_state(&self) -> SolutionState

Return the current solution state.

fn set_balances<F>(&mut self, balance: F) where
    F: Fn(<Self::Graph as GraphType<'a>>::Node) -> Self::Flow, 

fn set_lowers<F>(&mut self, lower: F) where
    F: Fn(<Self::Graph as GraphType<'a>>::Edge) -> Self::Flow, 

fn set_uppers<F>(&mut self, upper: F) where
    F: Fn(<Self::Graph as GraphType<'a>>::Edge) -> Self::Flow, 

fn set_costs<F>(&mut self, cost: F) where
    F: Fn(<Self::Graph as GraphType<'a>>::Edge) -> Self::Flow,