# HG changeset patch
# User alpar
# Date 1079950890 0
# Node ID ae5f9ca94be76661f420328c9e6803409939e73b
# Parent  1d5f4cd0342cb96d943579b61dcc3e6e1bf34e21
DocFix

diff -r 1d5f4cd0342c -r ae5f9ca94be7 src/work/alpar/dijkstra/dijkstra.h
--- a/src/work/alpar/dijkstra/dijkstra.h	Sun Mar 21 18:43:15 2004 +0000
+++ b/src/work/alpar/dijkstra/dijkstra.h	Mon Mar 22 10:21:30 2004 +0000
@@ -34,9 +34,9 @@
   
   //Alpar: Changed the order of the parameters
   
-  ///Dijkstra algorithm class.
+  ///%Dijkstra algorithm class.
 
-  ///This class provides an efficient implementation of Dijkstra algorithm.
+  ///This class provides an efficient implementation of %Dijkstra algorithm.
   ///The edge lengths are passed to the algorithm using a
   ///\ref ReadMapSkeleton "readable map",
   ///so it is easy to change it to any kind of length.
@@ -50,7 +50,7 @@
   ///lengths of the edges. It is read once for each edge, so the map
   ///may involve in relatively time consuming process to compute the edge
   ///length if it is necessary.
-  ///\param Heap The heap type used by the Dijkstra
+  ///\param Heap The heap type used by the %Dijkstra
   ///algorithm. The default
   ///is using \ref BinHeap "binary heap".
   template <typename Graph,
@@ -97,19 +97,21 @@
 
     ///Returns the distance of a node from the source.
     ///\pre \ref run() must be called before using this function.
-    ///\warning If node \c v in unreachable from \c s the return value
+    ///\warning If node \c v in unreachable from the source the return value
     ///of this funcion is undefined.
     ValueType dist(Node v) const { return distance[v]; }
     ///Returns the edges of the shortest path tree.
 
     ///For a node \c v it returns the last edge of the shortest path
-    ///from \c s to \c v or INVALID if \c v is unreachable from \c s.
+    ///from the source to \c v or INVALID if \c v is unreachable
+    ///from the source.
     ///\pre \ref run() must be called before using this function.
     Edge pred(Node v) const { return predecessor[v]; }
     ///Returns the nodes of the shortest paths.
 
     ///For a node \c v it returns the last but one node of the shortest path
-    ///from \c s to \c v or INVALID if \c v is unreachable from \c s.
+    ///from the source to \c v or INVALID if \c v is unreachable
+    ///from the source.
     ///\pre \ref run() must be called before using this function.
     Node predNode(Node v) const { return pred_node[v]; }
     
@@ -133,10 +135,10 @@
 
     //    bool reached(Node v) { return reach[v]; }
 
-    ///Chech if a node is reachable from \c s.
+    ///Chechs if a node is reachable from the source.
 
-    ///Returns \c true if \c v is reachable from \c s.
-    ///\warning \c s is reported to be unreached!
+    ///Returns \c true if \c v is reachable from the source.
+    ///\warning the source node is reported to be unreached!
     ///\todo Is this what we want?
     ///\pre \ref run() must be called before using this function.
     ///
@@ -149,13 +151,14 @@
   //  IMPLEMENTATIONS
   // **********************************************************************
 
-  ///Runs Dijkstra algorithm from node \c s.
+  ///Runs %Dijkstra algorithm from node the source.
 
-  ///This method runs the Dijkstra algorithm from node \c s in order to
+  ///This method runs the %Dijkstra algorithm from a source node \c s
+  ///in order to
   ///compute the
   ///shortest path to each node. The algorithm computes
   ///- The shortest path tree.
-  ///- The distance of each node.
+  ///- The distance of each node from the source.
   template <typename Graph, typename LengthMap, typename Heap >
   void Dijkstra<Graph,LengthMap,Heap>::run(Node s) {