Class MaximumFlowAlgorithmBase<V,​E>

    • Field Detail


        public static final double DEFAULT_EPSILON
        Default tolerance.
        See Also:
        Constant Field Values
      • network

        protected Graph<V,​E> network
      • directedGraph

        protected final boolean directedGraph
      • comparator

        protected java.util.Comparator<java.lang.Double> comparator
      • vertexExtensionManager

        protected ExtensionManager<V,​? extends org.jgrapht.alg.flow.MaximumFlowAlgorithmBase.VertexExtensionBase> vertexExtensionManager
      • edgeExtensionManager

        protected ExtensionManager<E,​? extends org.jgrapht.alg.flow.MaximumFlowAlgorithmBase.AnnotatedFlowEdge> edgeExtensionManager
      • source

        protected V source
      • sink

        protected V sink
      • maxFlowValue

        protected double maxFlowValue
      • maxFlow

        protected java.util.Map<E,​java.lang.Double> maxFlow
      • sourcePartition

        protected java.util.Set<V> sourcePartition
      • sinkPartition

        protected java.util.Set<V> sinkPartition
      • cutEdges

        protected java.util.Set<E> cutEdges
    • Constructor Detail

      • MaximumFlowAlgorithmBase

        public MaximumFlowAlgorithmBase​(Graph<V,​E> network,
                                        double epsilon)
        Construct a new maximum flow
        network - the network
        epsilon - the tolerance for the comparison of floating point values
    • Method Detail

      • init

        protected <VE extends org.jgrapht.alg.flow.MaximumFlowAlgorithmBase.VertexExtensionBase> void init​(V source,
                                                                                                           V sink,
                                                                                                           ExtensionFactory<VE> vertexExtensionFactory,
                                                                                                           ExtensionFactory<org.jgrapht.alg.flow.MaximumFlowAlgorithmBase.AnnotatedFlowEdge> edgeExtensionFactory)
        Prepares all data structures to start a new invocation of the Maximum Flow or Minimum Cut algorithms
        Type Parameters:
        VE - vertex extension type
        source - source
        sink - sink
        vertexExtensionFactory - vertex extension factory
        edgeExtensionFactory - edge extension factory
      • pushFlowThrough

        protected void pushFlowThrough​(org.jgrapht.alg.flow.MaximumFlowAlgorithmBase.AnnotatedFlowEdge edge,
                                       double flow)
        Increase flow in the direction denoted by edge $(u,v)$. Any existing flow in the reverse direction $(v,u)$ gets reduced first. More precisely, let $f_2$ be the existing flow in the direction $(v,u)$, and $f_1$ be the desired increase of flow in direction $(u,v)$. If $f_1 \geq f_2$, then the flow on $(v,u)$ becomes $0$, and the flow on $(u,v)$ becomes $f_1-f_2$. Else, if $f_1 \textlptr f_2$, the flow in the direction $(v, u)$ is reduced, i.e. the flow on $(v, u)$ becomes $f_2 - f_1$, whereas the flow on $(u,v)$ remains zero.
        edge - desired direction in which the flow is increased
        flow - increase of flow in the the direction indicated by the forwardEdge
      • composeFlow

        protected java.util.Map<E,​java.lang.Double> composeFlow()
        Create a map which specifies for each edge in the input map the amount of flow that flows through it
        a map which specifies for each edge in the input map the amount of flow that flows through it
      • getCurrentSource

        public V getCurrentSource()
        Returns current source vertex, or null if there was no calculateMaximumFlow calls.
        current source
      • getCurrentSink

        public V getCurrentSink()
        Returns current sink vertex, or null if there was no calculateMaximumFlow calls.
        current sink
      • getMaximumFlowValue

        public double getMaximumFlowValue()
        Returns maximum flow value, that was calculated during last calculateMaximumFlow call.
        maximum flow value
      • getFlowMap

        public java.util.Map<E,​java.lang.Double> getFlowMap()
        Returns maximum flow, that was calculated during last calculateMaximumFlow call, or null, if there was no calculateMaximumFlow calls.
        Specified by:
        getFlowMap in interface FlowAlgorithm<V,​E>
        read-only mapping from edges to doubles - flow values
      • getFlowDirection

        public V getFlowDirection​(E e)
        Returns the direction of the flow on an edge $(u,v)$. In case $(u,v)$ is a directed edge (arc), this function will always return the edge target $v$. However, if $(u,v)$ is an edge in an undirected graph, flow may go through the edge in either side. If the flow goes from $u$ to $v$, we return $v$, otherwise $u$. If the flow on an edge equals $0$, the returned value has no meaning.
        Specified by:
        getFlowDirection in interface FlowAlgorithm<V,​E>
        e - edge
        the vertex where the flow leaves the edge
      • calculateMinCut

        public double calculateMinCut​(V source,
                                      V sink)
        Description copied from interface: MinimumSTCutAlgorithm
        Computes a minimum capacity $s-t$ cut.
        Specified by:
        calculateMinCut in interface MinimumSTCutAlgorithm<V,​E>
        source - s
        sink - t
        capacity of the cut
      • getCutEdges

        public java.util.Set<E> getCutEdges()
        Description copied from interface: MinimumSTCutAlgorithm
        Returns the set of edges which run from $S$ to $T$, in the $s-t$ cut obtained after the last invocation of MinimumSTCutAlgorithm.calculateMinCut(Object, Object) In case of a directed graph, only the edges with their tail in $S$ and their head in $T$ are returned. In cased of a undirected graph, all edges with one endpoint in $S$ and one endpoint in $T$ are returned.
        Specified by:
        getCutEdges in interface MinimumSTCutAlgorithm<V,​E>
        set of edges which run from $S$ to $T$
      • calculateSourcePartition

        protected void calculateSourcePartition()
        Calculate the set of reachable vertices from $s$ in the residual graph.