Changeset 1547:dd57a540ff5f in lemon-0.x

Timestamp:

07/12/05 18:16:19 (19 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2043

Message:

Improve doc

Location:

lemon

Files:

• graph_utils.h (modified) (1 diff)
• kruskal.h (modified) (16 diffs)
• maps.h (modified) (10 diffs)

lemon/graph_utils.h

@@ -194 +194 @@
   /// \brief Copy a map.
   ///
-  /// Thsi function copies the \c source map to the \c target map. It uses the
+  /// This function copies the \c source map to the \c target map. It uses the
   /// given iterator to iterate on the data structure and it uses the \c ref
   /// mapping to convert the source's keys to the target's keys.

lemon/kruskal.h

@@ -46 +46 @@
 
   /// This function runs Kruskal's algorithm to find a minimum cost tree.
-  /// \param G The graph the algorithm runs on. The algorithm considers the
+  /// \param g The graph the algorithm runs on. The algorithm considers the
   /// graph to be undirected, the direction of the edges are not used.
   ///
@@ -77 +77 @@
   template <class GR, class IN, class OUT>
   typename IN::value_type::second_type
-  kruskal(GR const& G, IN const& in, 
+  kruskal(GR const& g, IN const& in, 
                  OUT& out)
   {
@@ -84 +84 @@
     typedef typename GR::Node Node;
 
-    NodeIntMap comp(G, -1);
+    NodeIntMap comp(g, -1);
     UnionFind<Node,NodeIntMap> uf(comp); 
       
@@ -90 +90 @@
     for (typename IN::const_iterator p = in.begin(); 
          p!=in.end(); ++p ) {
-      if ( uf.join(G.target((*p).first),
-                   G.source((*p).first)) ) {
+      if ( uf.join(g.target((*p).first),
+                   g.source((*p).first)) ) {
         out.set((*p).first, true);
         tot_cost += (*p).second;
@@ -110 +110 @@
   ///
   /// A typical examle is the following call:
-  /// <tt>kruskal(G, some_input, makeSequenceOutput(iterator))</tt>.
+  /// <tt>kruskal(g, some_input, makeSequenceOutput(iterator))</tt>.
   /// Here, the third argument is a temporary object (which wraps around an
   /// iterator with a writable bool map interface), and thus by rules of C++
@@ -131 +131 @@
   inline
   typename IN::value_type::second_type
-  kruskal(GR const& G, IN const& edges, OUT const& out_map)
+  kruskal(GR const& g, IN const& edges, OUT const& out_map)
   {
     NonConstMapWr<OUT> map_wr(out_map);
-    return kruskal(G, edges, map_wr);
+    return kruskal(g, edges, map_wr);
   }  
 
@@ -176 +176 @@
     template<class _GR>
     typename enable_if<typename _GR::UndirTag,void>::type
-    fillWithEdges(const _GR& G, const Map& m,dummy<0> = 0) 
+    fillWithEdges(const _GR& g, const Map& m,dummy<0> = 0) 
     {
-      for(typename GR::UndirEdgeIt e(G);e!=INVALID;++e) 
+      for(typename GR::UndirEdgeIt e(g);e!=INVALID;++e) 
         push_back(value_type(typename GR::Edge(e,true), m[e]));
     }
@@ -184 +184 @@
     template<class _GR>
     typename disable_if<typename _GR::UndirTag,void>::type
-    fillWithEdges(const _GR& G, const Map& m,dummy<1> = 1) 
+    fillWithEdges(const _GR& g, const Map& m,dummy<1> = 1) 
     {
-      for(typename GR::EdgeIt e(G);e!=INVALID;++e) 
+      for(typename GR::EdgeIt e(g);e!=INVALID;++e) 
         push_back(value_type(e, m[e]));
     }
@@ -197 +197 @@
     }
 
-    KruskalMapInput(GR const& G, Map const& m) {
-      fillWithEdges(G,m); 
+    KruskalMapInput(GR const& g, Map const& m) {
+      fillWithEdges(g,m); 
       sort();
     }
@@ -212 +212 @@
   /// want to use the function kruskalEdgeMap() instead.
   ///
-  ///\param G The type of the graph the algorithm runs on.
+  ///\param g The type of the graph the algorithm runs on.
   ///\param m An edge map containing the cost of the edges.
   ///\par
@@ -224 +224 @@
   template<class GR, class Map>
   inline
-  KruskalMapInput<GR,Map> makeKruskalMapInput(const GR &G,const Map &m)
+  KruskalMapInput<GR,Map> makeKruskalMapInput(const GR &g,const Map &m)
   {
-    return KruskalMapInput<GR,Map>(G,m);
+    return KruskalMapInput<GR,Map>(g,m);
   }
   
@@ -292 +292 @@
   /// Input is from an edge map, output is a plain bool map.
   ///
-  ///\param G The type of the graph the algorithm runs on.
+  ///\param g The type of the graph the algorithm runs on.
   ///\param in An edge map containing the cost of the edges.
   ///\par
@@ -311 +311 @@
   inline
   typename IN::Value
-  kruskalEdgeMap(GR const& G,
+  kruskalEdgeMap(GR const& g,
                  IN const& in,
                  RET &out) {
-    return kruskal(G,
-                   KruskalMapInput<GR,IN>(G,in),
+    return kruskal(g,
+                   KruskalMapInput<GR,IN>(g,in),
                    out);
   }
@@ -325 +325 @@
   /// Input is from an edge map, output is an STL Sequence.
   ///
-  ///\param G The type of the graph the algorithm runs on.
+  ///\param g The type of the graph the algorithm runs on.
   ///\param in An edge map containing the cost of the edges.
   ///\par
@@ -336 +336 @@
   /// <tt>GR::Edge</tt> as its <tt>value_type</tt>.
   /// The algorithm copies the elements of the found tree into this sequence.
-  /// For example, if we know that the spanning tree of the graph \c G has
+  /// For example, if we know that the spanning tree of the graph \c g has
   /// say 53 edges then
   /// we can put its edges into a STL vector \c tree with a code like this.
   /// \code
   /// std::vector<Edge> tree(53);
-  /// kruskalEdgeMap_IteratorOut(G,cost,tree.begin());
+  /// kruskalEdgeMap_IteratorOut(g,cost,tree.begin());
   /// \endcode
   /// Or if we don't know in advance the size of the tree, we can write this.
   /// \code
   /// std::vector<Edge> tree;
-  /// kruskalEdgeMap_IteratorOut(G,cost,std::back_inserter(tree));
+  /// kruskalEdgeMap_IteratorOut(g,cost,std::back_inserter(tree));
   /// \endcode
   ///
@@ -356 +356 @@
   inline
   typename IN::Value
-  kruskalEdgeMap_IteratorOut(const GR& G,
+  kruskalEdgeMap_IteratorOut(const GR& g,
                              const IN& in,
                              RET out)
   {
     KruskalSequenceOutput<RET> _out(out);
-    return kruskal(G, KruskalMapInput<GR,IN>(G, in), _out);
+    return kruskal(g, KruskalMapInput<GR,IN>(g, in), _out);
   }
 

lemon/maps.h

@@ -222 +222 @@
   };
 
-  ///Convert the \c Value of a maps to another type.
+  ///Convert the \c Value of a map to another type.
 
   ///This \ref concept::ReadMap "read only map"
   ///converts the \c Value of a maps to type \c T.
-  ///Its \c Value is inherited from \c M.
-  ///
-  ///\bug wrong documentation
+  ///Its \c Key is inherited from \c M.
   template<class M, class T> 
   class ConvertMap {
@@ -305 +303 @@
   }
 
-  ///Shift a maps with a constant.
+  ///Shift a map with a constant.
 
   ///This \ref concept::ReadMap "read only map" returns the sum of the
@@ -315 +313 @@
   ///  ShiftMap<X> sh(x,v);
   ///\endcode
-  ///it is equivalent with
+  ///is equivalent with
   ///\code
   ///  ConstMap<X::Key, X::Value> c_tmp(v);
@@ -356 +354 @@
 
   ///This \ref concept::ReadMap "read only map" returns the difference
-  ///of the values returned by the two
+  ///of the values of the two
   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
@@ -392 +390 @@
 
   ///This \ref concept::ReadMap "read only map" returns the product of the
-  ///values returned by the two
+  ///values of the two
   ///given
   ///maps. Its \c Key and \c Value will be inherited from \c M1.
@@ -425 +423 @@
   }
  
-  ///Scale a maps with a constant.
+  ///Scales a maps with a constant.
 
   ///This \ref concept::ReadMap "read only map" returns the value of the
-  ///given map multipied with a constant value.
+  ///given map multiplied with a constant value.
   ///Its \c Key and \c Value is inherited from \c M.
   ///
@@ -435 +433 @@
   ///  ScaleMap<X> sc(x,v);
   ///\endcode
-  ///it is equivalent with
+  ///is equivalent with
   ///\code
   ///  ConstMap<X::Key, X::Value> c_tmp(v);
@@ -476 +474 @@
 
   ///This \ref concept::ReadMap "read only map" returns the quotient of the
-  ///values returned by the two
+  ///values of the two
   ///given maps. Its \c Key and \c Value will be inherited from \c M1.
   ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
@@ -553 +551 @@
   }
   
-  ///Combine of two maps using an STL (binary) functor.
-
-  ///Combine of two maps using an STL (binary) functor.
-  ///
-  ///
-  ///This \ref concept::ReadMap "read only map" takes to maps and a
+  ///Combines of two maps using an STL (binary) functor.
+
+  ///Combines of two maps using an STL (binary) functor.
+  ///
+  ///
+  ///This \ref concept::ReadMap "read only map" takes two maps and a
   ///binary functor and returns the composition of
-  ///two
+  ///the two
   ///given maps unsing the functor. 
   ///That is to say, if \c m1 and \c m2 is of type \c M1 and \c M2
@@ -790 +788 @@
 
 
-  ///Apply all map setting operations to two maps
+  ///Applies all map setting operations to two maps
 
   ///This map has two \ref concept::WriteMap "writable map"