[Lemon-commits] [lemon_svn] deba: r3048 - hugo/trunk/lemon

[Lemon SVN]

Author: deba
Date: Tue Oct 31 15:30:54 2006
New Revision: 3048

Added:
   hugo/trunk/lemon/nagamochi_ibaraki.h
      - copied, changed from r3026, /hugo/trunk/lemon/min_cut.h
Removed:
   hugo/trunk/lemon/min_cut.h
Modified:
   hugo/trunk/lemon/Makefile.am

Log:
Renaming MinCut



Modified: hugo/trunk/lemon/Makefile.am
==============================================================================
--- hugo/trunk/lemon/Makefile.am	(original)
+++ hugo/trunk/lemon/Makefile.am	Tue Oct 31 15:30:54 2006
@@ -76,9 +76,9 @@
 	lemon/matrix_maps.h \
 	lemon/max_matching.h \
 	lemon/min_cost_arborescence.h \
-	lemon/min_cut.h \
 	lemon/mip_glpk.h \
 	lemon/mip_cplex.h \
+	lemon/nagamochi_ibaraki.h \
 	lemon/path.h \
 	lemon/polynomial.h \
 	lemon/preflow.h \

Copied: hugo/trunk/lemon/nagamochi_ibaraki.h (from r3026, /hugo/trunk/lemon/min_cut.h)
==============================================================================
--- /hugo/trunk/lemon/min_cut.h	(original)
+++ hugo/trunk/lemon/nagamochi_ibaraki.h	Tue Oct 31 15:30:54 2006
@@ -688,13 +688,13 @@
     ///@}
   };
 
-  /// \brief Default traits class of MinCut class.
+  /// \brief Default traits class of NagamochiIbaraki class.
   ///
-  /// Default traits class of MinCut class.
+  /// Default traits class of NagamochiIbaraki class.
   /// \param Graph Graph type.
   /// \param CapacityMap Type of length map.
   template <typename _Graph, typename _CapacityMap>
-  struct MinCutDefaultTraits {
+  struct NagamochiIbarakiDefaultTraits {
     /// \brief The type of the capacity of the edges.
     typedef typename _CapacityMap::Value Value;
 
@@ -756,14 +756,14 @@
       return new HeapCrossRef(graph);
     }
     
-    /// \brief The heap type used by MinCut algorithm.
+    /// \brief The heap type used by NagamochiIbaraki algorithm.
     ///
-    /// The heap type used by MinCut algorithm. It should
+    /// The heap type used by NagamochiIbaraki algorithm. It should
     /// maximalize the priorities and the heap's key type is
     /// the aux graph's node.
     ///
     /// \sa BinHeap
-    /// \sa MinCut
+    /// \sa NagamochiIbaraki
     typedef typename _min_cut_bits
     ::HeapSelector<CapacityMap>
     ::template Selector<Value, HeapCrossRef>
@@ -849,9 +849,10 @@
 #else
   template <typename _Graph = ListUGraph, 
 	    typename _CapacityMap = typename _Graph::template UEdgeMap<int>, 
-	    typename _Traits = MinCutDefaultTraits<_Graph, _CapacityMap> >
+	    typename _Traits 
+            = NagamochiIbarakiDefaultTraits<_Graph, _CapacityMap> >
 #endif
-  class MinCut {
+  class NagamochiIbaraki {
   public:
     /// \brief \ref Exception for uninitialized parameters.
     ///
@@ -860,7 +861,7 @@
     class UninitializedParameter : public lemon::UninitializedParameter {
     public:
       virtual const char* what() const throw() {
-	return "lemon::MinCut::UninitializedParameter";
+	return "lemon::NagamochiIbaraki::UninitializedParameter";
       }
     };
 
@@ -906,8 +907,10 @@
     /// \ref named-templ-param "Named parameter" for setting 
     /// the capacity type to constMap<UEdge, int, 1>()
     struct DefNeutralCapacity
-      : public MinCut<Graph, CapacityMap, DefNeutralCapacityTraits> { 
-      typedef MinCut<Graph, CapacityMap, DefNeutralCapacityTraits> Create;
+      : public NagamochiIbaraki<Graph, CapacityMap, 
+                                DefNeutralCapacityTraits> { 
+      typedef NagamochiIbaraki<Graph, CapacityMap, 
+                               DefNeutralCapacityTraits> Create;
     };
 
 
@@ -929,8 +932,10 @@
     /// reference type
     template <class H, class CR = typename Graph::template NodeMap<int> >
     struct DefHeap
-      : public MinCut<Graph, CapacityMap, DefHeapTraits<H, CR> > { 
-      typedef MinCut< Graph, CapacityMap, DefHeapTraits<H, CR> > Create;
+      : public NagamochiIbaraki<Graph, CapacityMap, 
+                                DefHeapTraits<H, CR> > { 
+      typedef NagamochiIbaraki< Graph, CapacityMap, 
+                                DefHeapTraits<H, CR> > Create;
     };
 
     template <class H, class CR>
@@ -954,8 +959,10 @@
     /// parameter and the heap's constructor waits for the cross reference.
     template <class H, class CR = typename Graph::template NodeMap<int> >
     struct DefStandardHeap
-      : public MinCut<Graph, CapacityMap, DefStandardHeapTraits<H, CR> > { 
-      typedef MinCut<Graph, CapacityMap, DefStandardHeapTraits<H, CR> > 
+      : public NagamochiIbaraki<Graph, CapacityMap, 
+                                DefStandardHeapTraits<H, CR> > { 
+      typedef NagamochiIbaraki<Graph, CapacityMap, 
+                               DefStandardHeapTraits<H, CR> > 
       Create;
     };
 
@@ -1054,14 +1061,14 @@
 
   public :
 
-    typedef MinCut Create;
+    typedef NagamochiIbaraki Create;
 
 
     /// \brief Constructor.
     ///
     ///\param graph the graph the algorithm will run on.
     ///\param capacity the capacity map used by the algorithm.
-    MinCut(const Graph& graph, const CapacityMap& capacity) 
+    NagamochiIbaraki(const Graph& graph, const CapacityMap& capacity) 
       : _graph(&graph), 
         _capacity(&capacity), local_capacity(false),
         _aux_graph(0), local_aux_graph(false),
@@ -1078,7 +1085,7 @@
     /// construct the capacity map.
     ///
     ///\param graph the graph the algorithm will run on.
-    MinCut(const Graph& graph) 
+    NagamochiIbaraki(const Graph& graph) 
       : _graph(&graph), 
         _capacity(0), local_capacity(false),
         _aux_graph(0), local_aux_graph(false),
@@ -1090,7 +1097,7 @@
     /// \brief Destructor.
     ///
     /// Destructor.
-    ~MinCut() {
+    ~NagamochiIbaraki() {
       if (local_heap) delete _heap;
       if (local_heap_cross_ref) delete _heap_cross_ref;
       if (_first) delete _first;
@@ -1108,7 +1115,7 @@
     /// it will allocate one. The destuctor deallocates this
     /// automatically allocated heap and cross reference, of course.
     /// \return <tt> (*this) </tt>
-    MinCut &heap(Heap& heap, HeapCrossRef &crossRef)
+    NagamochiIbaraki &heap(Heap& heap, HeapCrossRef &crossRef)
     {
       if (local_heap_cross_ref) {
 	delete _heap_cross_ref;
@@ -1130,7 +1137,7 @@
     /// it will allocate one. The destuctor deallocates this
     /// automatically allocated graph, of course.
     /// \return <tt> (*this) </tt>
-    MinCut &auxGraph(AuxGraph& aux_graph)
+    NagamochiIbaraki &auxGraph(AuxGraph& aux_graph)
     {
       if(local_aux_graph) {
 	delete _aux_graph;
@@ -1147,7 +1154,7 @@
     /// it will allocate one. The destuctor deallocates this
     /// automatically allocated graph, of course.
     /// \return <tt> (*this) </tt>
-    MinCut &auxCapacityMap(AuxCapacityMap& aux_capacity_map)
+    NagamochiIbaraki &auxCapacityMap(AuxCapacityMap& aux_capacity_map)
     {
       if(local_aux_capacity) {
 	delete _aux_capacity;
@@ -1269,7 +1276,7 @@
     }
 
 
-    /// \brief Runs %MinCut algorithm.
+    /// \brief Runs %NagamochiIbaraki algorithm.
     ///
     /// This method runs the %Min cut algorithm
     ///
@@ -1285,11 +1292,12 @@
 
     ///@}
 
-    /// \name Query Functions
-    /// The result of the %MinCut algorithm can be obtained using these
-    /// functions.\n
-    /// Before the use of these functions,
-    /// either run() or start() must be called.
+    /// \name Query Functions 
+    ///
+    /// The result of the %NagamochiIbaraki
+    /// algorithm can be obtained using these functions.\n 
+    /// Before the use of these functions, either run() or start()
+    /// must be called.
     
     ///@{