177-patches-87df475c2753--2ecc1e07d4ff.patch on Ticket #177 – Attachment – LEMON

lemon/edmonds_karp.h

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1362071873 -3600
# Node ID 87df475c275311687b9a1dccb0c6fb993d81cd2f
# Parent  be2b4a8d4548920c639259882b72429302c514ab
Improve and fix API doc of EdmondsKarp according to Preflow (#177)

diff --git a/lemon/edmonds_karp.h b/lemon/edmonds_karp.h

-                      a
     /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef CAP CapacityMap;
     /// \brief The type of the length of the arcs.
+    /// \brief The type of the flow values.
     typedef typename CapacityMap::Value Value;
     /// \brief The map type that stores the flow values.
+    /// \brief The type of the map that stores the flow values.
     ///
     /// The map type that stores the flow values.
+    /// The type of the map that stores the flow values.
     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+#ifdef DOXYGEN
+    typedef GR::ArcMap<Value> FlowMap;
+#else
     typedef typename Digraph::template ArcMap<Value> FlowMap;
+#endif
     /// \brief Instantiates a FlowMap.
     ///
     /// This function instantiates a \ref FlowMap.
+    /// \param digraph The digraph, to which we would like to define the flow map.
+    /// \param digraph The digraph for which we would like to define
+    /// the flow map.
     static FlowMap* createFlowMap(const Digraph& digraph) {
       return new FlowMap(digraph);
+    }
 …
   /// \brief Edmonds-Karp algorithms class.
   ///
   /// This class provides an implementation of the \e Edmonds-Karp \e
+  /// algorithm producing a flow of maximum value in directed
+  /// digraphs. The Edmonds-Karp algorithm is slower than the Preflow
+  /// algorithm but it has an advantage of the step-by-step execution
+  /// algorithm producing a \ref max_flow "flow of maximum value" in a
+  /// digraph \ref clrs01algorithms, \ref amo93networkflows,
+  /// \ref edmondskarp72theoretical.
+  /// The Edmonds-Karp algorithm is slower than the Preflow
+  /// algorithm, but it has an advantage of the step-by-step execution
   /// control with feasible flow solutions. The \e source node, the \e
   /// target node, the \e capacity of the arcs and the \e starting \e
   /// flow value of the arcs should be passed to the algorithm
   /// through the constructor.
   ///
   /// The time complexity of the algorithm is \f$ O(nm^2) \f$ in
   /// worst case.  Always try the preflow algorithm instead of this if
+  /// worst case. Always try the Preflow algorithm instead of this if
   /// you just want to compute the optimal flow.
   ///
+  /// \param GR The digraph type the algorithm runs on.
+  /// \param CAP The capacity map type.
+  /// \param TR Traits class to set various data types used by
+  /// the algorithm.  The default traits class is \ref
+  /// EdmondsKarpDefaultTraits.  See \ref EdmondsKarpDefaultTraits for the
+  /// documentation of a Edmonds-Karp traits class.
+  /// \tparam GR The type of the digraph the algorithm runs on.
+  /// \tparam CAP The type of the capacity map. The default map
+  /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
+  /// \tparam TR The traits class that defines various types used by the
+  /// algorithm. By default, it is \ref EdmondsKarpDefaultTraits
+  /// "EdmondsKarpDefaultTraits<GR, CAP>".
+  /// In most cases, this parameter should not be set directly,
+  /// consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename CAP, typename TR>
 …
   class EdmondsKarp {
   public:
+    /// The \ref EdmondsKarpDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
+    /// The type of the digraph the algorithm runs on.
     typedef typename Traits::Digraph Digraph;
+    /// The type of the capacity map.
     typedef typename Traits::CapacityMap CapacityMap;
+    /// The type of the flow values.
     typedef typename Traits::Value Value;
+    /// The type of the flow map.
     typedef typename Traits::FlowMap FlowMap;
+    /// The type of the tolerance.
     typedef typename Traits::Tolerance Tolerance;
   private:
 …
     struct DefFlowMapTraits : public Traits {
       typedef T FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
         LEMON_ASSERT(false,"Uninitialized parameter.");
+        LEMON_ASSERT(false, "FlowMap is not initialized");
         return 0;
+      }
     };
 …
     template <typename T>
     struct DefFlowMap
       : public EdmondsKarp<Digraph, CapacityMap, DefFlowMapTraits<T> > {
       typedef EdmondsKarp<Digraph, CapacityMap, DefFlowMapTraits<T> >
+      typedef EdmondsKarp<Digraph, CapacityMap, DefFlowMapTraits<T> >
       Create;
     };
     /// @}
   protected:
 …
       : _graph(digraph), _capacity(&capacity), _source(source), _target(target),
         _flow(0), _local_flow(false), _pred(0), _tolerance(), _flow_value()
+    {
+      LEMON_ASSERT(_source != _target,"Flow source and target are the same nodes.");
+      LEMON_ASSERT(_source != _target,
+                   "Flow source and target are the same nodes.");
+    }
     /// \brief Destructor.
 …
     /// \brief Sets the capacity map.
     ///
     /// Sets the capacity map.
     /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     EdmondsKarp& capacityMap(const CapacityMap& map) {
       _capacity = &map;
       return *this;
 …
     /// \brief Sets the flow map.
     ///
     /// Sets the flow map.
+    /// \return \c (*this)
+    /// If you don't use this function before calling \ref run() or
+    /// \ref init(), an instance will be allocated automatically.
+    /// The destructor deallocates this automatically allocated map,
+    /// of course.
+    /// \return <tt>(*this)</tt>
     EdmondsKarp& flowMap(FlowMap& map) {
       if (_local_flow) {
         delete _flow;
 …
       return *this;
+    }
-    /// \brief Returns the flow map.
-    ///
-    /// \return The flow map.
-    const FlowMap& flowMap() const {
-      return *_flow;
+    }
     /// \brief Sets the source node.
     ///
     /// Sets the source node.
     /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     EdmondsKarp& source(const Node& node) {
       _source = node;
       return *this;
 …
     /// \brief Sets the target node.
     ///
     /// Sets the target node.
     /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     EdmondsKarp& target(const Node& node) {
       _target = node;
       return *this;
 …
     /// \brief Sets the tolerance used by algorithm.
     ///
     /// Sets the tolerance used by algorithm.
+    /// \return <tt>(*this)</tt>
     EdmondsKarp& tolerance(const Tolerance& tolerance) {
       _tolerance = tolerance;
       return *this;
+    }
     /// \brief Returns the tolerance used by algorithm.
+    /// \brief Returns a const reference to the tolerance.
     ///
+    /// Returns the tolerance used by algorithm.
+    /// Returns a const reference to the tolerance object used by
+    /// the algorithm.
     const Tolerance& tolerance() const {
       return _tolerance;
+    }
     /// \name Execution control
+    /// The simplest way to execute the
+    /// algorithm is to use the \c run() member functions.
+    /// \n
+    /// If you need more control on initial solution or
+    /// execution then you have to call one \ref init() function and then
+    /// the start() or multiple times the \c augment() member function.
+    /// The simplest way to execute the algorithm is to use \ref run().\n
+    /// If you need better control on the initial solution or the execution,
+    /// you have to call one of the \ref init() functions first, then
+    /// \ref start() or multiple times the \ref augment() function.
     ///@{
+    /// \brief Initializes the algorithm
+    ///
+    /// Sets the flow to empty flow.
+    /// \brief Initializes the algorithm.
+    ///
+    /// Initializes the internal data structures and sets the initial
+    /// flow to zero on each arc.
     void init() {
       createStructures();
       for (ArcIt it(_graph); it != INVALID; ++it) {
 …
       _flow_value = 0;
+    }
+    /// \brief Initializes the algorithm
+    ///
+    /// Initializes the flow to the \c flowMap. The \c flowMap should
+    /// contain a feasible flow, ie. in each node excluding the source
+    /// and the target the incoming flow should be equal to the
+    /// \brief Initializes the algorithm using the given flow map.
+    ///
+    /// Initializes the internal data structures and sets the initial
+    /// flow to the given \c flowMap. The \c flowMap should
+    /// contain a feasible flow, i.e. at each node excluding the source
+    /// and the target, the incoming flow should be equal to the
     /// outgoing flow.
     template <typename FlowMap>
     void flowInit(const FlowMap& flowMap) {
 …
+      }
+    }
+    /// \brief Initializes the algorithm
+    ///
+    /// Initializes the flow to the \c flowMap. The \c flowMap should
+    /// contain a feasible flow, ie. in each node excluding the source
+    /// and the target the incoming flow should be equal to the
+    /// outgoing flow.
+    /// \return %False when the given flowMap does not contain
+    /// \brief Initializes the algorithm using the given flow map.
+    ///
+    /// Initializes the internal data structures and sets the initial
+    /// flow to the given \c flowMap. The \c flowMap should
+    /// contain a feasible flow, i.e. at each node excluding the source
+    /// and the target, the incoming flow should be equal to the
+    /// outgoing flow.
+    /// \return \c false when the given \c flowMap does not contain a
     /// feasible flow.
     template <typename FlowMap>
     bool checkedFlowInit(const FlowMap& flowMap) {
 …
       return true;
+    }
     /// \brief Augment the solution on an arc shortest path.
+    /// \brief Augments the solution along a shortest path.
     ///
     /// Augment the solution on an arc shortest path. It searches an
     /// arc shortest path between the source and the target
     /// in the residual digraph by the bfs algoritm.
+    /// Augments the solution along a shortest path. This function searches a
+    /// shortest path between the source and the target
+    /// in the residual digraph by the Bfs algoritm.
     /// Then it increases the flow on this path with the minimal residual
     /// capacity on the path. If there is no such path it gives back
+    /// capacity on the path. If there is no such path, it gives back
     /// false.
     /// \return %False when the augmenting didn't success so the
+    /// \return \c false when the augmenting did not success, i.e. the
     /// current flow is a feasible and optimal solution.
     bool augment() {
       for (NodeIt n(_graph); n != INVALID; ++n) {
 …
     /// \brief Executes the algorithm
     ///
+    /// It runs augmenting phases until the optimal solution is reached.
+    /// Executes the algorithm by performing augmenting phases until the
+    /// optimal solution is reached.
+    /// \pre One of the \ref init() functions must be called before
+    /// using this function.
     void start() {
       while (augment()) {}
+    }
     /// \brief Runs the algorithm.
     ///
     /// It is just a shorthand for:
     ///
+    /// Runs the Edmonds-Karp algorithm.
+    /// \note ek.run() is just a shortcut of the following code.
     ///\code
     /// ek.init();
     /// ek.start();
 …
     /// \name Query Functions
     /// The result of the Edmonds-Karp algorithm can be obtained using these
     /// functions.\n
+    /// Before the use of these functions,
+    /// either run() or start() must be called.
+    /// Either \ref run() or \ref start() should be called before using them.
     ///@{
     /// \brief Returns the value of the maximum flow.
     ///
+    /// Returns the value of the maximum flow by returning the excess
+    /// of the target node \c t.
+    /// Returns the value of the maximum flow found by the algorithm.
+    ///
+    /// \pre Either \ref run() or \ref init() must be called before
+    /// using this function.
     Value flowValue() const {
       return _flow_value;
+    }
+    /// \brief Returns the flow on the arc.
+    /// \brief Returns the flow value on the given arc.
     ///
+    /// Sets the \c flowMap to the flow on the arcs.
+    /// Returns the flow value on the given arc.
+    ///
+    /// \pre Either \ref run() or \ref init() must be called before
+    /// using this function.
     Value flow(const Arc& arc) const {
       return (*_flow)[arc];
+    }
     /// \brief Returns true when the node is on the source side of minimum cut.
+    /// \brief Returns a const reference to the flow map.
     ///
+    /// Returns a const reference to the arc map storing the found flow.
+    ///
+    /// \pre Either \ref run() or \ref init() must be called before
+    /// using this function.
+    const FlowMap& flowMap() const {
+      return *_flow;
+    }
+    /// Returns true when the node is on the source side of minimum
+    /// cut.
+    /// \brief Returns \c true when the node is on the source side of the
+    /// minimum cut.
+    ///
+    /// Returns true when the node is on the source side of the found
+    /// minimum cut.
+    ///
+    /// \pre Either \ref run() or \ref init() must be called before
+    /// using this function.
     bool minCut(const Node& node) const {
       return ((*_pred)[node] != INVALID) or node == _source;
+    }
     /// \brief Returns a minimum value cut.
+    /// \brief Gives back a minimum value cut.
     ///
+    /// Sets \c cutMap to the characteristic vector of a minimum value cut.
+    /// Sets \c cutMap to the characteristic vector of a minimum value
+    /// cut. \c cutMap should be a \ref concepts::WriteMap "writable"
+    /// node map with \c bool (or convertible) value type.
+    ///
+    /// \note This function calls \ref minCut() for each node, so it runs in
+    /// O(n) time.
+    ///
+    /// \pre Either \ref run() or \ref init() must be called before
+    /// using this function.
     template <typename CutMap>
     void minCutMap(CutMap& cutMap) const {
       for (NodeIt n(_graph); n != INVALID; ++n) {

lemon/edmonds_karp.h

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1362071156 -3600
# Node ID 0ad9454fd0b6f0307d01e0baf23ac9642983e6a1
# Parent  87df475c275311687b9a1dccb0c6fb993d81cd2f
Rename DefFlowMap named parameter to SetFlowMap (#177)
in EdmondsKarp according to Preflow

diff --git a/lemon/edmonds_karp.h b/lemon/edmonds_karp.h

-                      a
     ///@{
     template <typename T>
     struct DefFlowMapTraits : public Traits {
+    struct SetFlowMapTraits : public Traits {
       typedef T FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
         LEMON_ASSERT(false, "FlowMap is not initialized");
 …
     /// \ref named-templ-param "Named parameter" for setting FlowMap
     /// type
     template <typename T>
+    struct DefFlowMap
+      : public EdmondsKarp<Digraph, CapacityMap, DefFlowMapTraits<T> > {
+      typedef EdmondsKarp<Digraph, CapacityMap, DefFlowMapTraits<T> >
+      Create;
+    struct SetFlowMap
+      : public EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > {
+      typedef EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > Create;
     };
     /// @}

test/edmonds_karp_test.cc

diff --git a/test/edmonds_karp_test.cc b/test/edmonds_karp_test.cc

-                      a
   bool b;
   typedef EdmondsKarp<Digraph, CapMap>
               ::DefFlowMap<FlowMap>
+              ::SetFlowMap<FlowMap>
               ::Create EKType;
   EKType ek_test(g, cap, n, n);
   const EKType& const_ek_test = ek_test;

lemon/edmonds_karp.h

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1362071628 -3600
# Node ID d1c4ed808574081acf145cb252f5ad5cca6ba772
# Parent  0ad9454fd0b6f0307d01e0baf23ac9642983e6a1
Rename flow init functions according to Preflow (#177)

diff --git a/lemon/edmonds_karp.h b/lemon/edmonds_karp.h

-                      a
     /// and the target, the incoming flow should be equal to the
     /// outgoing flow.
     template <typename FlowMap>
     void flowInit(const FlowMap& flowMap) {
+    void init(const FlowMap& flowMap) {
       createStructures();
       for (ArcIt e(_graph); e != INVALID; ++e) {
         _flow->set(e, flowMap[e]);
 …
     /// \return \c false when the given \c flowMap does not contain a
     /// feasible flow.
     template <typename FlowMap>
     bool checkedFlowInit(const FlowMap& flowMap) {
+    bool checkedInit(const FlowMap& flowMap) {
       createStructures();
       for (ArcIt e(_graph); e != INVALID; ++e) {
         _flow->set(e, flowMap[e]);

test/edmonds_karp_test.cc

diff --git a/test/edmonds_karp_test.cc b/test/edmonds_karp_test.cc

-                      a
   int flow_value=ek_test.flowValue();
   for(ArcIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
   ek_test.flowInit(flow);
+  ek_test.init(flow);
   ek_test.start();
   CutMap min_cut1(g);

lemon/edmonds_karp.h

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1362091475 -3600
# Node ID 67ffe67e28de610b4114d0669f538eed1d435f97
# Parent  d1c4ed808574081acf145cb252f5ad5cca6ba772
Merge test files of Preflow and EdmondsKarp (#177)

diff --git a/lemon/edmonds_karp.h b/lemon/edmonds_karp.h

-                      a
   public:
+    typedef EdmondsKarp Create;
     ///\name Named template parameters
     ///@{

test/CMakeLists.txt

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt

-                      a
   dijkstra_test
   dim_test
   edge_set_test
-  edmonds_karp_test
   error_test
   euler_test
   fractional_matching_test
 …
   matching_test
   max_cardinality_search_test
   max_clique_test
+  max_flow_test
   min_cost_arborescence_test
   min_cost_flow_test
   min_mean_cycle_test
   nagamochi_ibaraki_test
   path_test
   planarity_test
-  preflow_test
   radix_sort_test
   random_test
   suurballe_test

test/Makefile.am

diff --git a/test/Makefile.am b/test/Makefile.am

-                      a
         test/dijkstra_test \
         test/dim_test \
         test/edge_set_test \
-        test/edmonds_karp_test \
         test/error_test \
         test/euler_test \
         test/fractional_matching_test \
 …
         test/matching_test \
         test/max_cardinality_search_test \
         test/max_clique_test \
+        test/max_flow_test \
         test/min_cost_arborescence_test \
         test/min_cost_flow_test \
         test/min_mean_cycle_test \
         test/nagamochi_ibaraki_test \
         test/path_test \
         test/planarity_test \
-        test/preflow_test \
         test/radix_sort_test \
         test/random_test \
         test/suurballe_test \
 …
 test_dijkstra_test_SOURCES = test/dijkstra_test.cc
 test_dim_test_SOURCES = test/dim_test.cc
 test_edge_set_test_SOURCES = test/edge_set_test.cc
-test_edmonds_karp_test_SOURCES = test/edmonds_karp_test.cc
 test_error_test_SOURCES = test/error_test.cc
 test_euler_test_SOURCES = test/euler_test.cc
 test_fractional_matching_test_SOURCES = test/fractional_matching_test.cc
 …
 test_matching_test_SOURCES = test/matching_test.cc
 test_max_cardinality_search_test_SOURCES = test/max_cardinality_search_test.cc
 test_max_clique_test_SOURCES = test/max_clique_test.cc
+test_max_flow_test_SOURCES = test/max_flow_test.cc
 test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
 test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc
 test_min_mean_cycle_test_SOURCES = test/min_mean_cycle_test.cc
 test_nagamochi_ibaraki_test_SOURCES = test/nagamochi_ibaraki_test.cc
 test_path_test_SOURCES = test/path_test.cc
 test_planarity_test_SOURCES = test/planarity_test.cc
-test_preflow_test_SOURCES = test/preflow_test.cc
 test_radix_sort_test_SOURCES = test/radix_sort_test.cc
 test_suurballe_test_SOURCES = test/suurballe_test.cc
 test_random_test_SOURCES = test/random_test.cc

deleted file test/edmonds_karp_test.cc

diff --git a/test/edmonds_karp_test.cc b/test/edmonds_karp_test.cc
deleted file mode 100644

-                      +
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
- * This file is a part of LEMON, a generic C++ optimization library.
+ *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
+ *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
+ *
- */
-#include<iostream>
-#include "test_tools.h"
-#include<lemon/smart_graph.h>
-#include<lemon/edmonds_karp.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-using namespace lemon;
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "8\n"
-  "9\n"
-  "@arcs\n"
-  "    label capacity\n"
-  "0 1 0     20\n"
-  "0 2 1     0\n"
-  "1 1 2     3\n"
-  "1 2 3     8\n"
-  "1 3 4     8\n"
-  "2 5 5     5\n"
-  "3 2 6     5\n"
-  "3 5 7     5\n"
-  "3 6 8     5\n"
-  "4 3 9     3\n"
-  "5 7 10    3\n"
-  "5 6 11    10\n"
-  "5 8 12    10\n"
-  "6 8 13    8\n"
-  "8 9 14    20\n"
-  "8 1 15    5\n"
-  "9 5 16    5\n"
-  "@attributes\n"
-  "source 1\n"
-  "target 8\n";
-void checkEdmondKarpCompile() {
-  typedef int VType;
-  typedef concepts::Digraph Digraph;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::ReadMap<Arc,VType> CapMap;
-  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
-  typedef concepts::WriteMap<Node,bool> CutMap;
-  Digraph g;
-  Node n;
-  Arc e;
-  CapMap cap;
-  FlowMap flow;
-  CutMap cut;
-  VType v;
-  bool b;
-  typedef EdmondsKarp<Digraph, CapMap>
-              ::SetFlowMap<FlowMap>
-              ::Create EKType;
-  EKType ek_test(g, cap, n, n);
-  const EKType& const_ek_test = ek_test;
-  EKType::Tolerance tol = const_ek_test.tolerance();
-  ek_test.tolerance(tol);
-  ek_test
-    .capacityMap(cap)
-    .flowMap(flow)
-    .source(n)
-    .target(n);
-  ek_test.init();
-  ek_test.start();
-  v = const_ek_test.flowValue();
-  v = const_ek_test.flow(e);
-  const FlowMap& fm = const_ek_test.flowMap();
-  b = const_ek_test.minCut(n);
-  const_ek_test.minCutMap(cut);
-  ignore_unused_variable_warning(fm);
+}
-int cutValue (const SmartDigraph& g,
-              const SmartDigraph::NodeMap<bool>& cut,
-              const SmartDigraph::ArcMap<int>& cap) {
-  int c=0;
-  for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
-    if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
+  }
-  return c;
+}
-bool checkFlow(const SmartDigraph& g,
-               const SmartDigraph::ArcMap<int>& flow,
-               const SmartDigraph::ArcMap<int>& cap,
-               SmartDigraph::Node s, SmartDigraph::Node t) {
-  for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
-    if (flow[e] < 0 || flow[e] > cap[e]) return false;
+  }
-  for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
-    if (n == s || n == t) continue;
-    int sum = 0;
-    for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
-      sum += flow[e];
+    }
-    for (SmartDigraph::InArcIt e(g, n); e != INVALID; ++e) {
-      sum -= flow[e];
+    }
-    if (sum != 0) return false;
+  }
-  return true;
+}
-int main() {
-  typedef SmartDigraph Digraph;
-  typedef Digraph::Node Node;
-  typedef Digraph::NodeIt NodeIt;
-  typedef Digraph::ArcIt ArcIt;
-  typedef Digraph::ArcMap<int> CapMap;
-  typedef Digraph::ArcMap<int> FlowMap;
-  typedef Digraph::NodeMap<bool> CutMap;
-  typedef EdmondsKarp<Digraph, CapMap> EKType;
-  Digraph g;
-  Node s, t;
-  CapMap cap(g);
-  std::istringstream input(test_lgf);
-  DigraphReader<Digraph>(g,input).
-    arcMap("capacity", cap).
-    node("source",s).
-    node("target",t).
-    run();
-  EKType ek_test(g, cap, s, t);
-  ek_test.run();
-  check(checkFlow(g, ek_test.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-  CutMap min_cut(g);
-  ek_test.minCutMap(min_cut);
-  int min_cut_value=cutValue(g,min_cut,cap);
-  check(ek_test.flowValue() == min_cut_value,
-        "The max flow value is not equal to the three min cut values.");
-  FlowMap flow(g);
-  for(ArcIt e(g); e!=INVALID; ++e) flow[e] = ek_test.flowMap()[e];
-  int flow_value=ek_test.flowValue();
-  for(ArcIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
-  ek_test.init(flow);
-  ek_test.start();
-  CutMap min_cut1(g);
-  ek_test.minCutMap(min_cut1);
-  min_cut_value=cutValue(g,min_cut1,cap);
-  check(ek_test.flowValue() == min_cut_value &&
-        min_cut_value == 2*flow_value,
-        "The max flow value or the min cut value is wrong.");
-  check(checkFlow(g, ek_test.flowMap(), cap, s, t),
-        "The flow is not feasible.");
-  CutMap min_cut2(g);
-  ek_test.minCutMap(min_cut2);
-  min_cut_value=cutValue(g,min_cut2,cap);
-  check(ek_test.flowValue() == min_cut_value &&
-        min_cut_value == 2*flow_value,
-        "The max flow value or the three min cut values were not doubled.");
-  ek_test.flowMap(flow);
-  NodeIt tmp1(g,s);
-  ++tmp1;
-  if ( tmp1 != INVALID ) s=tmp1;
-  NodeIt tmp2(g,t);
-  ++tmp2;
-  if ( tmp2 != INVALID ) t=tmp2;
-  ek_test.source(s);
-  ek_test.target(t);
-  ek_test.run();
-  CutMap min_cut3(g);
-  ek_test.minCutMap(min_cut3);
-  min_cut_value=cutValue(g,min_cut3,cap);
-  check(ek_test.flowValue() == min_cut_value,
-        "The max flow value or the three min cut values are incorrect.");
-  return 0;
+}

.cc

diff --git a/test/preflow_test.cc b/test/max_flow_test.cc
rename from test/preflow_test.cc
rename to test/max_flow_test.cc

-                      old
+                      new
 #include "test_tools.h"
 #include <lemon/smart_graph.h>
 #include <lemon/preflow.h>
+#include <lemon/edmonds_karp.h>
 #include <lemon/concepts/digraph.h>
 #include <lemon/concepts/maps.h>
 #include <lemon/lgf_reader.h>
 …
   "source 1\n"
   "target 8\n";
+// Checks the general interface of a max flow algorithm
+template <typename GR, typename CAP>
+struct MaxFlowClassConcept
+{
+  template <typename MF>
+  struct Constraints {
+    typedef typename GR::Node Node;
+    typedef typename GR::Arc Arc;
+    typedef typename CAP::Value Value;
+    typedef concepts::ReadWriteMap<Arc, Value> FlowMap;
+    typedef concepts::WriteMap<Node, bool> CutMap;
+    GR g;
+    Node n;
+    Arc e;
+    CAP cap;
+    FlowMap flow;
+    CutMap cut;
+    Value v;
+    bool b;
+    void constraints() {
+      checkConcept<concepts::Digraph, GR>();
+      const Constraints& me = *this;
+      typedef typename MF
+          ::template SetFlowMap<FlowMap>
+          ::Create MaxFlowType;
+      typedef typename MF::Create MaxFlowType2;
+      MaxFlowType max_flow(me.g, me.cap, me.n, me.n);
+      const MaxFlowType& const_max_flow = max_flow;
+      max_flow
+          .capacityMap(cap)
+          .flowMap(flow)
+          .source(n)
+          .target(n);
+      typename MaxFlowType::Tolerance tol = const_max_flow.tolerance();
+      max_flow.tolerance(tol);
+      max_flow.init();
+      max_flow.init(cap);
+      max_flow.run();
+      v = const_max_flow.flowValue();
+      v = const_max_flow.flow(e);
+      const FlowMap& fm = const_max_flow.flowMap();
+      b = const_max_flow.minCut(n);
+      const_max_flow.minCutMap(cut);
+      ignore_unused_variable_warning(fm);
+    }
+  };
+};
+// Checks the specific parts of Preflow's interface
 void checkPreflowCompile()
+{
   typedef int VType;
+  typedef int Value;
   typedef concepts::Digraph Digraph;
+  typedef Digraph::Node Node;
+  typedef Digraph::Arc Arc;
+  typedef concepts::ReadMap<Arc,VType> CapMap;
+  typedef concepts::ReadWriteMap<Arc,VType> FlowMap;
+  typedef concepts::WriteMap<Node,bool> CutMap;
+  typedef concepts::ReadMap<Digraph::Arc, Value> CapMap;
   typedef Elevator<Digraph, Digraph::Node> Elev;
   typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
   Digraph g;
+  Node n;
+  Arc e;
+  Digraph::Node n;
   CapMap cap;
-  FlowMap flow;
-  CutMap cut;
-  VType v;
-  bool b;
   typedef Preflow<Digraph, CapMap>
+            ::SetFlowMap<FlowMap>
+            ::SetElevator<Elev>
+            ::SetStandardElevator<LinkedElev>
+            ::Create PreflowType;
+      ::SetElevator<Elev>
+      ::SetStandardElevator<LinkedElev>
+      ::Create PreflowType;
   PreflowType preflow_test(g, cap, n, n);
   const PreflowType& const_preflow_test = preflow_test;
   const PreflowType::Elevator& elev = const_preflow_test.elevator();
   preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
-  PreflowType::Tolerance tol = const_preflow_test.tolerance();
-  preflow_test.tolerance(tol);
+  preflow_test
+    .capacityMap(cap)
+    .flowMap(flow)
+    .source(n)
+    .target(n);
+  preflow_test.init();
+  preflow_test.init(cap);
+  bool b = preflow_test.init(cap);
   preflow_test.startFirstPhase();
   preflow_test.startSecondPhase();
-  preflow_test.run();
   preflow_test.runMinCut();
+  v = const_preflow_test.flowValue();
+  v = const_preflow_test.flow(e);
+  const FlowMap& fm = const_preflow_test.flowMap();
+  b = const_preflow_test.minCut(n);
+  const_preflow_test.minCutMap(cut);
+  ignore_unused_variable_warning(fm);
+  ignore_unused_variable_warning(b);
+}
+int cutValue (const SmartDigraph& g,
+// Checks the specific parts of EdmondsKarp's interface
+void checkEdmondsKarpCompile()
+{
+  typedef int Value;
+  typedef concepts::Digraph Digraph;
+  typedef concepts::ReadMap<Digraph::Arc, Value> CapMap;
+  typedef Elevator<Digraph, Digraph::Node> Elev;
+  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
+  Digraph g;
+  Digraph::Node n;
+  CapMap cap;
+  EdmondsKarp<Digraph, CapMap> ek_test(g, cap, n, n);
+  ek_test.init(cap);
+  bool b = ek_test.checkedInit(cap);
+  b = ek_test.augment();
+  ek_test.start();
+  ignore_unused_variable_warning(b);
+}
+template <typename T>
+T cutValue (const SmartDigraph& g,
               const SmartDigraph::NodeMap<bool>& cut,
               const SmartDigraph::ArcMap<int>& cap) {
+              const SmartDigraph::ArcMap<T>& cap) {
   int c=0;
+  T c=0;
   for(SmartDigraph::ArcIt e(g); e!=INVALID; ++e) {
     if (cut[g.source(e)] && !cut[g.target(e)]) c+=cap[e];
+  }
   return c;
+}
+template <typename T>
 bool checkFlow(const SmartDigraph& g,
                const SmartDigraph::ArcMap<int>& flow,
                const SmartDigraph::ArcMap<int>& cap,
+               const SmartDigraph::ArcMap<T>& flow,
+               const SmartDigraph::ArcMap<T>& cap,
                SmartDigraph::Node s, SmartDigraph::Node t) {
   for (SmartDigraph::ArcIt e(g); e != INVALID; ++e) {
 …
   for (SmartDigraph::NodeIt n(g); n != INVALID; ++n) {
     if (n == s || n == t) continue;
     int sum = 0;
+    T sum = 0;
     for (SmartDigraph::OutArcIt e(g, n); e != INVALID; ++e) {
       sum += flow[e];
+    }
 …
   return true;
+}
+int main() {
+template <typename MF, typename SF>
+void checkMaxFlowAlg() {
+  typedef SmartDigraph Digraph;
+  DIGRAPH_TYPEDEFS(Digraph);
+  typedef SmartDigraph Digraph;
+  typedef Digraph::Node Node;
+  typedef Digraph::NodeIt NodeIt;
+  typedef Digraph::ArcIt ArcIt;
+  typedef Digraph::ArcMap<int> CapMap;
+  typedef Digraph::ArcMap<int> FlowMap;
+  typedef Digraph::NodeMap<bool> CutMap;
+  typedef Preflow<Digraph, CapMap> PType;
+  typedef typename MF::Value Value;
+  typedef Digraph::ArcMap<Value> CapMap;
+  typedef CapMap FlowMap;
+  typedef BoolNodeMap CutMap;
   Digraph g;
   Node s, t;
   CapMap cap(g);
   std::istringstream input(test_lgf);
   DigraphReader<Digraph>(g,input).
     arcMap("capacity", cap).
     node("source",s).
     node("target",t).
     run();
+  DigraphReader<Digraph>(g,input)
+      .arcMap("capacity", cap)
+      .node("source",s)
+      .node("target",t)
+      .run();
   PType preflow_test(g, cap, s, t);
   preflow_test.run();
+  MF max_flow(g, cap, s, t);
+  max_flow.run();
   check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
+  check(checkFlow(g, max_flow.flowMap(), cap, s, t),
         "The flow is not feasible.");
   CutMap min_cut(g);
   preflow_test.minCutMap(min_cut);
   int min_cut_value=cutValue(g,min_cut,cap);
+  max_flow.minCutMap(min_cut);
+  Value min_cut_value = cutValue(g, min_cut, cap);
   check(preflow_test.flowValue() == min_cut_value,
         "The max flow value is not equal to the three min cut values.");
+  check(max_flow.flowValue() == min_cut_value,
+        "The max flow value is not equal to the min cut value.");
   FlowMap flow(g);
   for(ArcIt e(g); e!=INVALID; ++e) flow[e] = preflow_test.flowMap()[e];
+  for (ArcIt e(g); e != INVALID; ++e) flow[e] = max_flow.flowMap()[e];
   int flow_value=preflow_test.flowValue();
+  Value flow_value = max_flow.flowValue();
+  for(ArcIt e(g); e!=INVALID; ++e) cap[e]=2*cap[e];
+  preflow_test.init(flow);
+  preflow_test.startFirstPhase();
+  for (ArcIt e(g); e != INVALID; ++e) cap[e] = 2 * cap[e];
+  max_flow.init(flow);
+  SF::startFirstPhase(max_flow);       // start first phase of the algorithm
   CutMap min_cut1(g);
   preflow_test.minCutMap(min_cut1);
   min_cut_value=cutValue(g,min_cut1,cap);
+  max_flow.minCutMap(min_cut1);
+  min_cut_value = cutValue(g, min_cut1, cap);
   check(preflow_test.flowValue() == min_cut_value &&
         min_cut_value == 2*flow_value,
+  check(max_flow.flowValue() == min_cut_value &&
+        min_cut_value == 2 * flow_value,
         "The max flow value or the min cut value is wrong.");
   preflow_test.startSecondPhase();
+  SF::startSecondPhase(max_flow);       // start second phase of the algorithm
   check(checkFlow(g, preflow_test.flowMap(), cap, s, t),
+  check(checkFlow(g, max_flow.flowMap(), cap, s, t),
         "The flow is not feasible.");
   CutMap min_cut2(g);
   preflow_test.minCutMap(min_cut2);
   min_cut_value=cutValue(g,min_cut2,cap);
+  max_flow.minCutMap(min_cut2);
+  min_cut_value = cutValue(g, min_cut2, cap);
   check(preflow_test.flowValue() == min_cut_value &&
         min_cut_value == 2*flow_value,
         "The max flow value or the three min cut values were not doubled");
+  check(max_flow.flowValue() == min_cut_value &&
+        min_cut_value == 2 * flow_value,
+        "The max flow value or the min cut value was not doubled");
   preflow_test.flowMap(flow);
+  max_flow.flowMap(flow);
   NodeIt tmp1(g,s);
+  NodeIt tmp1(g, s);
   ++tmp1;
   if ( tmp1 != INVALID ) s=tmp1;
+  if (tmp1 != INVALID) s = tmp1;
   NodeIt tmp2(g,t);
+  NodeIt tmp2(g, t);
   ++tmp2;
   if ( tmp2 != INVALID ) t=tmp2;
+  if (tmp2 != INVALID) t = tmp2;
   preflow_test.source(s);
   preflow_test.target(t);
+  max_flow.source(s);
+  max_flow.target(t);
   preflow_test.run();
+  max_flow.run();
   CutMap min_cut3(g);
   preflow_test.minCutMap(min_cut3);
   min_cut_value=cutValue(g,min_cut3,cap);
+  max_flow.minCutMap(min_cut3);
+  min_cut_value=cutValue(g, min_cut3, cap);
+  check(max_flow.flowValue() == min_cut_value,
+        "The max flow value or the min cut value is wrong.");
+}
+  check(preflow_test.flowValue() == min_cut_value,
+        "The max flow value or the three min cut values are incorrect.");
+// Struct for calling start functions of a general max flow algorithm
+template <typename MF>
+struct GeneralStartFunctions {
+  static void startFirstPhase(MF& mf) {
+    mf.start();
+  }
+  static void startSecondPhase(MF& mf) {
+    ignore_unused_variable_warning(mf);
+  }
+};
+// Struct for calling start functions of Preflow
+template <typename MF>
+struct PreflowStartFunctions {
+  static void startFirstPhase(MF& mf) {
+    mf.startFirstPhase();
+  }
+  static void startSecondPhase(MF& mf) {
+    mf.startSecondPhase();
+  }
+};
+int main() {
+  typedef concepts::Digraph GR;
+  typedef concepts::ReadMap<GR::Arc, int> CM1;
+  typedef concepts::ReadMap<GR::Arc, double> CM2;
+  // Check the interface of Preflow
+  checkConcept< MaxFlowClassConcept<GR, CM1>,
+                Preflow<GR, CM1> >();
+  checkConcept< MaxFlowClassConcept<GR, CM2>,
+                Preflow<GR, CM2> >();
+  // Check the interface of EdmondsKarp
+  checkConcept< MaxFlowClassConcept<GR, CM1>,
+                EdmondsKarp<GR, CM1> >();
+  checkConcept< MaxFlowClassConcept<GR, CM2>,
+                EdmondsKarp<GR, CM2> >();
+  // Check Preflow
+  typedef Preflow<SmartDigraph, SmartDigraph::ArcMap<int> > PType1;
+  typedef Preflow<SmartDigraph, SmartDigraph::ArcMap<float> > PType2;
+  checkMaxFlowAlg<PType1, PreflowStartFunctions<PType1> >();
+  checkMaxFlowAlg<PType2, PreflowStartFunctions<PType2> >();
+  // Check EdmondsKarp
+  typedef EdmondsKarp<SmartDigraph, SmartDigraph::ArcMap<int> > EKType1;
+  typedef EdmondsKarp<SmartDigraph, SmartDigraph::ArcMap<float> > EKType2;
+  checkMaxFlowAlg<EKType1, GeneralStartFunctions<EKType1> >();
+  checkMaxFlowAlg<EKType2, GeneralStartFunctions<EKType2> >();
   return 0;
+}

lemon/edmonds_karp.h

# HG changeset patch
# User Peter Kovacs <kpeter@inf.elte.hu>
# Date 1362091539 -3600
# Node ID 2ecc1e07d4ff28b7e344dc04cd4595b9c8558afb
# Parent  67ffe67e28de610b4114d0669f538eed1d435f97
Avoid usage of alternative operator (#177)

diff --git a/lemon/edmonds_karp.h b/lemon/edmonds_karp.h

-                      a
     /// \pre Either \ref run() or \ref init() must be called before
     /// using this function.
     bool minCut(const Node& node) const {
       return ((*_pred)[node] != INVALID) or node == _source;
+      return ((*_pred)[node] != INVALID) || node == _source;
+    }
     /// \brief Gives back a minimum value cut.

Context Navigation

Ticket #177: 177-patches-87df475c2753--2ecc1e07d4ff.patch

lemon/edmonds_karp.h

lemon/edmonds_karp.h

test/edmonds_karp_test.cc

lemon/edmonds_karp.h

test/edmonds_karp_test.cc

lemon/edmonds_karp.h

test/CMakeLists.txt

test/Makefile.am

deleted file test/edmonds_karp_test.cc

.cc

lemon/edmonds_karp.h

Download in other formats: