# HG changeset patch
# User athos
# Date 1109870408 0
# Node ID 8f623d1833a760d89c31ff03714c223faa7016cc
# Parent  a1abe9452199f592e2384632e4027491595ca08c
Some more documentation (sorry, I forgot to check the doxygen.log and now I am under windows)

diff -r a1abe9452199 -r 8f623d1833a7 doc/maps.dox
--- a/doc/maps.dox	Thu Mar 03 17:18:27 2005 +0000
+++ b/doc/maps.dox	Thu Mar 03 17:20:08 2005 +0000
@@ -12,7 +12,8 @@
   typedef double Value;
 \endcode
 
-A map can \e readable (\ref lemon::concept::ReadMap "ReadMap", for short),
+A map can be 
+\e readable (\ref lemon::concept::ReadMap "ReadMap", for short),
 \e writable (\ref lemon::concept::WriteMap "WriteMap") or both
 (\ref lemon::concept::ReadWriteMap "ReadWriteMap").
 There also exists a special type of
@@ -144,4 +145,4 @@
 To be written...
 
 */
-}
\ No newline at end of file
+}
diff -r a1abe9452199 -r 8f623d1833a7 doc/quicktour.dox
--- a/doc/quicktour.dox	Thu Mar 03 17:18:27 2005 +0000
+++ b/doc/quicktour.dox	Thu Mar 03 17:20:08 2005 +0000
@@ -10,11 +10,15 @@
 frequently when <b>designing and testing certain networks</b>, for example
 in telecommunication, computer networks, and other areas that I cannot
 think of now. A very natural way of modelling these networks is by means
-of a <b> graph</b> (we will always mean a directed graph by that). 
+of a <b> graph</b> (we will always mean a directed graph by that and say
+<b> undirected graph </b> otherwise). 
 So if you want to write a program that works with 
-graphs then you might find it useful to use our library LEMON.
+graphs then you might find it useful to use our library LEMON. LEMON 
+defines various graph concepts depending on what you want to do with the 
+graph: a very good description can be found in the page
+about \ref graphs "graphs".
 
-
+You will also want to assign data to the edges or nodes of the graph, for example a length or capacity function defined on the edges. You can do this in LEMON using so called \ref maps "maps". You can define a map on the nodes or on the edges of the graph and the value of the map (the range of the function) can be practically almost any type. Read more about maps \ref maps-page "here".
 
 Some examples are the following (you will find links next to the code fragments that help to download full demo programs):
 
@@ -44,33 +48,88 @@
 If you want to read more on the LEMON graph structures and concepts, read the page about \ref graphs "graphs". 
 
 -# The following code shows how to read a graph from a stream (e.g. a file). LEMON supports the DIMACS file format: it can read a graph instance from a file 
-in that format (find the documentation of the format on the web). 
+in that format (find the documentation of the DIMECS file format on the web). 
 \code
 Graph g;
 std::ifstream f("graph.dim");
 readDimacs(f, g);
 \endcode
-One can also store network (graph+capacity on the edges) instances and other things in DIMACS format: to see the details read the documentation of the \ref dimacs.h "Dimacs file format reader".
+One can also store network (graph+capacity on the edges) instances and other things in DIMACS format and use these in LEMON: to see the details read the documentation of the \ref dimacs.h "Dimacs file format reader".
 
 
 - If you want to solve some transportation problems in a network then 
 you will want to find shortest paths between nodes of a graph. This is 
 usually solved using Dijkstra's algorithm. A utility
 that solves this is  the \ref lemon::Dijkstra "LEMON Dijkstra class".
-A simple program using the \ref lemon::Dijkstra "LEMON Dijkstra class" is
-as follows (we do not include the part that instantiates the graph and the length function):
+The following code is a simple program using the \ref lemon::Dijkstra "LEMON
+Dijkstra class" and it also shows how to define a map on the edges (the length
+function):
 
 \code
-  typedef Graph::EdgeMap<int> LengthMap;
-  Graph G;
-  Node s, t;
-  LengthMap cap(G);
-	...
-  Dijkstra<Graph, LengthMap> 
-	dijkstra_test(G, cap);
-  dijkstra_test.run(s);
+
+    typedef ListGraph Graph;
+    typedef Graph::Node Node;
+    typedef Graph::Edge Edge;
+    typedef Graph::EdgeMap<int> LengthMap;
+
+    Graph g;
+
+    //An example from Ahuja's book
+
+    Node s=g.addNode();
+    Node v2=g.addNode();
+    Node v3=g.addNode();
+    Node v4=g.addNode();
+    Node v5=g.addNode();
+    Node t=g.addNode();
+
+    Edge s_v2=g.addEdge(s, v2);
+    Edge s_v3=g.addEdge(s, v3);
+    Edge v2_v4=g.addEdge(v2, v4);
+    Edge v2_v5=g.addEdge(v2, v5);
+    Edge v3_v5=g.addEdge(v3, v5);
+    Edge v4_t=g.addEdge(v4, t);
+    Edge v5_t=g.addEdge(v5, t);
+  
+    LengthMap len(g);
+
+    len.set(s_v2, 10);
+    len.set(s_v3, 10);
+    len.set(v2_v4, 5);
+    len.set(v2_v5, 8);
+    len.set(v3_v5, 5);
+    len.set(v4_t, 8);
+    len.set(v5_t, 8);
+
+    std::cout << "The id of s is " << g.id(s)<< ", the id of t is " << g.id(t)<<"."<<std::endl;
+
+    std::cout << "Dijkstra algorithm test..." << std::endl;
+
+    Dijkstra<Graph, LengthMap> dijkstra_test(g,len);
+    
+    dijkstra_test.run(s);
+
+    
+    std::cout << "The distance of node t from node s: " << dijkstra_test.dist(t)<<std::endl;
+
+    std::cout << "The shortest path from s to t goes through the following nodes (the first one is t, the last one is s): "<<std::endl;
+
+    for (Node v=t;v != s; v=dijkstra_test.predNode(v)){
+	std::cout << g.id(v) << "<-";
+    }
+    std::cout << g.id(s) << std::endl;	
 \endcode
 
+See the whole program in \file dijkstra_demo.cc.
+
+The first part of the code is self-explanatory: we build the graph and set the
+length values of the edges. Then we instantiate a member of the Dijkstra class
+and run the Dijkstra algorithm from node \c s. After this we read some of the
+results. 
+You can do much more with the Dijkstra class, for example you can run it step
+by step and gain full control of the execution. For a detailed description, see the documentation of the \ref lemon::Dijkstra "LEMON Dijkstra class".
+
+
 - If you want to design a network and want to minimize the total length
 of wires then you might be looking for a <b>minimum spanning tree</b> in
 an undirected graph. This can be found using the Kruskal algorithm: the 
@@ -82,19 +141,4 @@
 \endcode
 
 
-
-Some more detailed introduction can be obtained by following the links 
-below:
-
-\ref graphs "Graph structures"
-play a central role in LEMON, so if you are new to the library,
-you probably should start \ref graphs "here".
-(You can also find that page along with others under
-<a class="el" href="pages.html"> Related Pages </a>.)
-
-If you are 
-interested in data structures and algorithms in more details, then
-you should browse the reference manual part of the documentation.
-Section <a class="el" href="modules.html"> Modules </a>
- is a good starting point for this.
 */