Changeset 592:e72bacfea6b7 in lemon

Timestamp:

02/25/09 12:10:57 (16 years ago)

Author:

Alpar Juttner <alpar@…>

Branch:

default

Phase:

public

Message:

Remane GomoryHuTree? to GomoryHu? (#66)

Files:

• lemon/Makefile.am (modified) (1 diff)
• lemon/gomory_hu.h (moved) (moved from lemon/gomory_hu_tree.h) (7 diffs)
• test/gomory_hu_test.cc (modified) (3 diffs)

lemon/Makefile.am

@@ -69 +69 @@
         lemon/full_graph.h \
         lemon/glpk.h \
-        lemon/gomory_hu_tree.h \
+        lemon/gomory_hu.h \
         lemon/graph_to_eps.h \
         lemon/grid_graph.h \

lemon/gomory_hu.h

@@ -64 +64 @@
             typename CAP = typename GR::template EdgeMap<int>
             >
-  class GomoryHuTree {
+  class GomoryHu {
   public:
 
@@ -117 +117 @@
     /// \param graph The graph the algorithm will run on.
     /// \param capacity The capacity map.
-    GomoryHuTree(const Graph& graph, const Capacity& capacity) 
+    GomoryHu(const Graph& graph, const Capacity& capacity) 
       : _graph(graph), _capacity(capacity),
         _pred(0), _weight(0), _order(0) 
@@ -128 +128 @@
     ///
     /// Destructor
-    ~GomoryHuTree() {
+    ~GomoryHu() {
       destroyStructures();
     }
@@ -341 +341 @@
     
     /// This iterator class lists the nodes of a minimum cut found by
-    /// GomoryHuTree. Before using it, you must allocate a GomoryHuTree class,
-    /// and call its \ref GomoryHuTree::run() "run()" method.
+    /// GomoryHu. Before using it, you must allocate a GomoryHu class,
+    /// and call its \ref GomoryHu::run() "run()" method.
     ///
     /// This example counts the nodes in the minimum cut separating \c s from
     /// \c t.
     /// \code
-    /// GomoruHuTree<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int sum=0;
-    /// for(GomoruHuTree<Graph>::MinCutNodeIt n(gom,s,t);n!=INVALID;++n) ++sum;
+    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t);n!=INVALID;++n) ++sum;
     /// \endcode
     class MinCutNodeIt
@@ -362 +362 @@
       /// Constructor
       ///
-      MinCutNodeIt(GomoryHuTree const &gomory,
-                   ///< The GomoryHuTree class. You must call its
+      MinCutNodeIt(GomoryHu const &gomory,
+                   ///< The GomoryHu class. You must call its
                    ///  run() method
                    ///  before initializing this iterator
@@ -438 +438 @@
     
     /// This iterator class lists the edges of a minimum cut found by
-    /// GomoryHuTree. Before using it, you must allocate a GomoryHuTree class,
-    /// and call its \ref GomoryHuTree::run() "run()" method.
+    /// GomoryHu. Before using it, you must allocate a GomoryHu class,
+    /// and call its \ref GomoryHu::run() "run()" method.
     ///
     /// This example computes the value of the minimum cut separating \c s from
     /// \c t.
     /// \code
-    /// GomoruHuTree<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int value=0;
-    /// for(GomoruHuTree<Graph>::MinCutEdgeIt e(gom,s,t);e!=INVALID;++e)
+    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t);e!=INVALID;++e)
     ///   value+=capacities[e];
     /// \endcode
     /// the result will be the same as it is returned by
-    /// \ref GomoryHuTree::minCostValue() "gom.minCostValue(s,t)"
+    /// \ref GomoryHu::minCostValue() "gom.minCostValue(s,t)"
     class MinCutEdgeIt
     {
@@ -471 +471 @@
       
     public:
-      MinCutEdgeIt(GomoryHuTree const &gomory,
-                   ///< The GomoryHuTree class. You must call its
+      MinCutEdgeIt(GomoryHu const &gomory,
+                   ///< The GomoryHu class. You must call its
                    ///  run() method
                    ///  before initializing this iterator

test/gomory_hu_test.cc

@@ -4 +4 @@
 #include <lemon/smart_graph.h>
 #include <lemon/lgf_reader.h>
-#include <lemon/gomory_hu_tree.h>
+#include <lemon/gomory_hu.h>
 #include <cstdlib>
 
@@ -61 +61 @@
     edgeMap("capacity", capacity).run();
 
-  GomoryHuTree<Graph> ght(graph, capacity);
+  GomoryHu<Graph> ght(graph, capacity);
   ght.init();
   ght.run();
@@ -76 +76 @@
 
       int sum=0;
-      for(GomoryHuTree<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
+      for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
         sum+=capacity[a]; 
       check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
 
       sum=0;
-      for(GomoryHuTree<Graph>::MinCutNodeIt n(ght, u, v,true);n!=INVALID;++n)
+      for(GomoryHu<Graph>::MinCutNodeIt n(ght, u, v,true);n!=INVALID;++n)
         sum++;
-      for(GomoryHuTree<Graph>::MinCutNodeIt n(ght, u, v,false);n!=INVALID;++n)
+      for(GomoryHu<Graph>::MinCutNodeIt n(ght, u, v,false);n!=INVALID;++n)
         sum++;
       check(sum == countNodes(graph), "Problem with MinCutNodeIt");