Index: doc/coding_style.dox
===================================================================
--- doc/coding_style.dox	(revision 41)
+++ doc/coding_style.dox	(revision 41)
@@ -0,0 +1,126 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+/*!
+
+\page coding_style LEMON Coding Style 
+
+\section naming_conv Naming Conventions
+
+In order to make development easier we have made some conventions
+according to coding style. These include names of types, classes,
+functions, variables, constants and exceptions. If these conventions
+are met in one's code then it is easier to read and maintain
+it. Please comply with these conventions if you want to contribute
+developing LEMON library.
+
+\note When the coding style requires the capitalization of an abbreviation,
+only the first letter should be upper case.
+
+\code
+XmlReader
+\endcode
+
+
+\warning In some cases we diverge from these rules.
+This is primary done because STL uses different naming convention and
+in certain cases
+it is beneficial to provide STL compatible interface.
+
+\subsection cs-files File Names
+
+The header file names should look like the following.
+
+\code
+header_file.h
+\endcode
+
+Note that all standard LEMON headers are located in the \c lemon subdirectory,
+so you should include them from C++ source like this:
+
+\code
+#include <lemon/header_file.h>
+\endcode
+
+The source code files use the same style and they have '.cc' extension.
+
+\code
+source_code.cc
+\endcode
+
+\subsection cs-class Classes and other types
+
+The name of a class or any type should look like the following.
+
+\code
+AllWordsCapitalizedWithoutUnderscores 
+\endcode
+
+\subsection cs-func Methods and other functions
+
+The name of a function should look like the following.
+
+\code
+firstWordLowerCaseRestCapitalizedWithoutUnderscores 
+\endcode
+
+\subsection cs-funcs Constants, Macros
+
+The names of constants and macros should look like the following.
+
+\code
+ALL_UPPER_CASE_WITH_UNDERSCORES 
+\endcode
+
+\subsection cs-loc-var Class and instance member variables, auto variables 
+
+The names of class and instance member variables and auto variables (=variables used locally in methods) should look like the following.
+
+\code
+all_lower_case_with_underscores 
+\endcode
+
+\subsection pri-loc-var Private member variables
+
+Private member variables should start with underscore
+
+\code
+_start_with_underscores
+\endcode
+
+\subsection cs-excep Exceptions
+
+When writing exceptions please comply the following naming conventions.
+
+\code
+ClassNameEndsWithException
+\endcode
+
+or
+
+\code
+ClassNameEndsWithError
+\endcode
+
+\section header-template Template Header File
+
+Each LEMON header file should look like this:
+
+\include template.h
+
+*/
Index: doc/dirs.dox
===================================================================
--- doc/dirs.dox	(revision 40)
+++ doc/dirs.dox	(revision 40)
@@ -0,0 +1,79 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+/**
+\dir demo
+\brief A collection of demo application.
+
+This directory contains several simple demo application, mainly
+for educational purposes.
+*/
+
+/**
+\dir doc
+\brief Auxiliary (and the whole generated) documentation.
+
+Auxiliary (and the whole generated) documentation.
+*/
+
+/**
+\dir test
+\brief Test programs.
+
+This directory contains several test programs that check the consistency
+of the code.
+*/
+
+/**
+\dir tools
+\brief Some useful executables
+
+This directory contains the sources of some useful complete executables.
+
+*/
+
+
+
+/**
+\dir lemon
+\brief Base include directory of LEMON
+
+This is the base directory of lemon includes, so each include file must be
+prefixed with this, e.g.
+\code
+#include<lemon/list_graph.h>
+#include<lemon/dijkstra.h>
+\endcode
+*/
+
+/**
+\dir concepts
+\brief Concept descriptors and checking classes
+
+This directory contains the concept descriptors and concept checkers. As a user
+you typically don't have to deal with these files.
+*/
+
+/**
+\dir bits
+\brief Implementation helper files
+
+This directory contains some helper classes to implement graphs, maps and
+some other classes. As a user you typically don't have to deal with these 
+files.
+*/
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 41)
+++ doc/groups.dox	(revision 41)
@@ -0,0 +1,585 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+/**
+@defgroup datas Data Structures
+This group describes the several graph structures implemented in LEMON.
+*/
+
+/**
+@defgroup graphs Graph Structures
+@ingroup datas
+\brief Graph structures implemented in LEMON.
+
+The implementation of combinatorial algorithms heavily relies on 
+efficient graph implementations. LEMON offers data structures which are 
+planned to be easily used in an experimental phase of implementation studies, 
+and thereafter the program code can be made efficient by small modifications. 
+
+The most efficient implementation of diverse applications require the
+usage of different physical graph implementations. These differences
+appear in the size of graph we require to handle, memory or time usage
+limitations or in the set of operations through which the graph can be
+accessed.  LEMON provides several physical graph structures to meet
+the diverging requirements of the possible users.  In order to save on
+running time or on memory usage, some structures may fail to provide
+some graph features like edge or node deletion.
+
+Alteration of standard containers need a very limited number of 
+operations, these together satisfy the everyday requirements. 
+In the case of graph structures, different operations are needed which do 
+not alter the physical graph, but gives another view. If some nodes or 
+edges have to be hidden or the reverse oriented graph have to be used, then 
+this is the case. It also may happen that in a flow implementation 
+the residual graph can be accessed by another algorithm, or a node-set 
+is to be shrunk for another algorithm. 
+LEMON also provides a variety of graphs for these requirements called 
+\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only 
+in conjunction with other graph representation. 
+
+You are free to use the graph structure that fit your requirements
+the best, most graph algorithms and auxiliary data structures can be used
+with any graph structures. 
+*/
+
+/**
+@defgroup semi_adaptors Semi-Adaptors Classes for Graphs
+@ingroup graphs
+\brief Graph types between real graphs and graph adaptors.
+
+Graph types between real graphs and graph adaptors. These classes wrap
+graphs to give new functionality as the adaptors do it. On the other
+hand they are not light-weight structures as the adaptors.
+*/
+
+/**
+@defgroup maps Maps 
+@ingroup datas
+\brief Some special purpose map to make life easier.
+
+LEMON provides several special maps that e.g. combine
+new maps from existing ones.
+*/
+
+/**
+@defgroup graph_maps Graph Maps 
+@ingroup maps
+\brief Special Graph-Related Maps.
+
+These maps are specifically designed to assign values to the nodes and edges of
+graphs.
+*/
+
+
+/**
+\defgroup map_adaptors Map Adaptors
+\ingroup maps
+\brief Tools to create new maps from existing ones
+
+Map adaptors are used to create "implicit" maps from other maps.
+
+Most of them are \ref lemon::concepts::ReadMap "ReadMap"s. They can
+make arithmetic operations between one or two maps (negation, scaling,
+addition, multiplication etc.) or e.g. convert a map to another one
+of different Value type.
+
+The typical usage of this classes is the passing implicit maps to
+algorithms.  If a function type algorithm is called then the function
+type map adaptors can be used comfortable. For example let's see the
+usage of map adaptors with the \c graphToEps() function:
+\code
+  Color nodeColor(int deg) {
+    if (deg >= 2) {
+      return Color(0.5, 0.0, 0.5);
+    } else if (deg == 1) {
+      return Color(1.0, 0.5, 1.0);
+    } else {
+      return Color(0.0, 0.0, 0.0);
+    }
+  }
+  
+  Graph::NodeMap<int> degree_map(graph);
+  
+  graphToEps(graph, "graph.eps")
+    .coords(coords).scaleToA4().undirected()
+    .nodeColors(composeMap(functorMap(nodeColor), degree_map)) 
+    .run();
+\endcode 
+The \c functorMap() function makes an \c int to \c Color map from the
+\e nodeColor() function. The \c composeMap() compose the \e degree_map
+and the previous created map. The composed map is proper function to
+get color of each node.
+
+The usage with class type algorithms is little bit harder. In this
+case the function type map adaptors can not be used, because the
+function map adaptors give back temporarly objects.
+\code
+  Graph graph;
+  
+  typedef Graph::EdgeMap<double> DoubleEdgeMap;
+  DoubleEdgeMap length(graph);
+  DoubleEdgeMap speed(graph);
+  
+  typedef DivMap<DoubleEdgeMap, DoubleEdgeMap> TimeMap;
+  
+  TimeMap time(length, speed);
+  
+  Dijkstra<Graph, TimeMap> dijkstra(graph, time);
+  dijkstra.run(source, target);
+\endcode
+
+We have a length map and a maximum speed map on a graph. The minimum
+time to pass the edge can be calculated as the division of the two
+maps which can be done implicitly with the \c DivMap template
+class. We use the implicit minimum time map as the length map of the
+\c Dijkstra algorithm.
+*/
+
+/**
+@defgroup matrices Matrices 
+@ingroup datas
+\brief Two dimensional data storages.
+
+Two dimensional data storages.
+*/
+
+/**
+@defgroup paths Path Structures
+@ingroup datas
+\brief Path structures implemented in LEMON.
+
+LEMON provides flexible data structures
+to work with paths.
+
+All of them have similar interfaces, and it can be copied easily with
+assignment operator and copy constructor. This make it easy and
+efficient to have e.g. the Dijkstra algorithm to store its result in
+any kind of path structure.
+
+\sa lemon::concepts::Path
+
+*/
+
+/**
+@defgroup auxdat Auxiliary Data Structures
+@ingroup datas
+\brief Some data structures implemented in LEMON.
+
+This group describes the data structures implemented in LEMON in
+order to make it easier to implement combinatorial algorithms.
+*/
+
+
+/**
+@defgroup algs Algorithms
+\brief This group describes the several algorithms
+implemented in LEMON.
+
+This group describes the several algorithms
+implemented in LEMON.
+*/
+
+/**
+@defgroup search Graph Search
+@ingroup algs
+\brief This group contains the common graph
+search algorithms.
+
+This group contains the common graph
+search algorithms like Bfs and Dfs.
+*/
+
+/**
+@defgroup shortest_path Shortest Path algorithms
+@ingroup algs
+\brief This group describes the algorithms
+for finding shortest paths.
+
+This group describes the algorithms for finding shortest paths in
+graphs.
+
+*/
+
+/** 
+@defgroup max_flow Maximum Flow algorithms 
+@ingroup algs 
+\brief This group describes the algorithms for finding maximum flows.
+
+This group describes the algorithms for finding maximum flows and
+feasible circulations.
+
+The maximum flow problem is to find a flow between a single-source and
+single-target that is maximum. Formally, there is \f$G=(V,A)\f$
+directed graph, an \f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity
+function and given \f$s, t \in V\f$ source and target node. The
+maximum flow is the solution of the next optimization problem:
+
+\f[ 0 \le f_a \le c_a \f]
+\f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv} \quad u \in V \setminus \{s,t\}\f]
+\f[ \max \sum_{v\in\delta^{+}(s)}f_{uv} - \sum_{v\in\delta^{-}(s)}f_{vu}\f]
+
+The lemon contains several algorithms for solve maximum flow problems:
+- \ref lemon::EdmondsKarp "Edmonds-Karp" 
+- \ref lemon::Preflow "Goldberg's Preflow algorithm"
+- \ref lemon::DinitzSleatorTarjan "Dinitz's blocking flow algorithm with dynamic tree"
+- \ref lemon::GoldbergTarjan "Preflow algorithm with dynamic trees"
+
+In most cases the \ref lemon::Preflow "preflow" algorithm provides the
+fastest method to compute the maximum flow. All impelementations
+provides functions for query the minimum cut, which is the dual linear
+programming probelm of the maximum flow.
+
+*/
+
+/**
+@defgroup min_cost_flow Minimum Cost Flow algorithms
+@ingroup algs
+
+\brief This group describes the algorithms
+for finding minimum cost flows and circulations.
+
+This group describes the algorithms for finding minimum cost flows and
+circulations.  
+*/
+
+/**
+@defgroup min_cut Minimum Cut algorithms 
+@ingroup algs 
+
+\brief This group describes the algorithms for finding minimum cut in
+graphs.
+
+This group describes the algorithms for finding minimum cut in graphs.
+
+The minimum cut problem is to find a non-empty and non-complete
+\f$X\f$ subset of the vertices with minimum overall capacity on
+outgoing arcs. Formally, there is \f$G=(V,A)\f$ directed graph, an
+\f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum
+cut is the solution of the next optimization problem:
+
+\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}\sum_{uv\in A, u\in X, v\not\in X}c_{uv}\f]
+
+The lemon contains several algorithms related to minimum cut problems:
+
+- \ref lemon::HaoOrlin "Hao-Orlin algorithm" for calculate minimum cut
+  in directed graphs  
+- \ref lemon::NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for
+  calculate minimum cut in undirected graphs
+- \ref lemon::GomoryHuTree "Gomory-Hu tree computation" for calculate all
+  pairs minimum cut in undirected graphs
+
+If you want to find minimum cut just between two distinict nodes,
+please see the \ref max_flow "Maximum Flow page".
+
+*/
+
+/**
+@defgroup graph_prop Connectivity and other graph properties
+@ingroup algs
+\brief This group describes the algorithms
+for discover the graph properties
+
+This group describes the algorithms for discover the graph properties
+like connectivity, bipartiteness, euler property, simplicity, etc...
+
+\image html edge_biconnected_components.png
+\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
+*/
+
+/**
+@defgroup planar Planarity embedding and drawing
+@ingroup algs
+\brief This group contains algorithms for planarity embedding and drawing
+
+This group contains algorithms for planarity checking, embedding and drawing.
+
+\image html planar.png
+\image latex planar.eps "Plane graph" width=\textwidth
+*/
+
+/**
+@defgroup matching Matching algorithms 
+@ingroup algs
+\brief This group describes the algorithms
+for find matchings in graphs and bipartite graphs.
+
+This group provides some algorithm objects and function to calculate
+matchings in graphs and bipartite graphs. The general matching problem is
+finding a subset of the edges which does not shares common endpoints.
+ 
+There are several different algorithms for calculate matchings in
+graphs.  The matching problems in bipartite graphs are generally
+easier than in general graphs. The goal of the matching optimization
+can be the finding maximum cardinality, maximum weight or minimum cost
+matching. The search can be constrained to find perfect or
+maximum cardinality matching.
+
+Lemon contains the next algorithms:
+- \ref lemon::MaxBipartiteMatching "MaxBipartiteMatching" Hopcroft-Karp 
+  augmenting path algorithm for calculate maximum cardinality matching in 
+  bipartite graphs
+- \ref lemon::PrBipartiteMatching "PrBipartiteMatching" Push-Relabel 
+  algorithm for calculate maximum cardinality matching in bipartite graphs 
+- \ref lemon::MaxWeightedBipartiteMatching "MaxWeightedBipartiteMatching" 
+  Successive shortest path algorithm for calculate maximum weighted matching 
+  and maximum weighted bipartite matching in bipartite graph
+- \ref lemon::MinCostMaxBipartiteMatching "MinCostMaxBipartiteMatching" 
+  Successive shortest path algorithm for calculate minimum cost maximum 
+  matching in bipartite graph
+- \ref lemon::MaxMatching "MaxMatching" Edmond's blossom shrinking algorithm
+  for calculate maximum cardinality matching in general graph
+- \ref lemon::MaxWeightedMatching "MaxWeightedMatching" Edmond's blossom
+  shrinking algorithm for calculate maximum weighted matching in general
+  graph
+- \ref lemon::MaxWeightedPerfectMatching "MaxWeightedPerfectMatching"
+  Edmond's blossom shrinking algorithm for calculate maximum weighted
+  perfect matching in general graph
+
+\image html bipartite_matching.png
+\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
+
+*/
+
+/**
+@defgroup spantree Minimum Spanning Tree algorithms
+@ingroup algs
+\brief This group contains the algorithms for finding a minimum cost spanning
+tree in a graph
+
+This group contains the algorithms for finding a minimum cost spanning
+tree in a graph
+*/
+
+
+/**
+@defgroup auxalg Auxiliary algorithms
+@ingroup algs
+\brief Some algorithms implemented in LEMON.
+
+This group describes the algorithms in LEMON in order to make 
+it easier to implement complex algorithms.
+*/
+
+/**
+@defgroup approx Approximation algorithms
+\brief Approximation algorithms
+
+Approximation and heuristic algorithms
+*/
+
+/**
+@defgroup gen_opt_group General Optimization Tools
+\brief This group describes some general optimization frameworks
+implemented in LEMON.
+
+This group describes some general optimization frameworks
+implemented in LEMON.
+
+*/
+
+/**
+@defgroup lp_group Lp and Mip solvers
+@ingroup gen_opt_group
+\brief Lp and Mip solver interfaces for LEMON.
+
+This group describes Lp and Mip solver interfaces for LEMON. The
+various LP solvers could be used in the same manner with this
+interface.
+
+*/
+
+/** 
+@defgroup lp_utils Tools for Lp and Mip solvers 
+@ingroup lp_group
+\brief This group adds some helper tools to the Lp and Mip solvers
+implemented in LEMON.
+
+This group adds some helper tools to general optimization framework
+implemented in LEMON.
+*/
+
+/**
+@defgroup metah Metaheuristics
+@ingroup gen_opt_group
+\brief Metaheuristics for LEMON library.
+
+This group contains some metaheuristic optimization tools.
+*/
+
+/**
+@defgroup utils Tools and Utilities 
+\brief Tools and Utilities for Programming in LEMON
+
+Tools and Utilities for Programming in LEMON
+*/
+
+/**
+@defgroup gutils Basic Graph Utilities
+@ingroup utils
+\brief This group describes some simple basic graph utilities.
+
+This group describes some simple basic graph utilities.
+*/
+
+/**
+@defgroup misc Miscellaneous Tools
+@ingroup utils
+Here you can find several useful tools for development,
+debugging and testing.
+*/
+
+
+/**
+@defgroup timecount Time measuring and Counting
+@ingroup misc
+Here you can find simple tools for measuring the performance
+of algorithms.
+*/
+
+/**
+@defgroup graphbits Tools for Graph Implementation
+@ingroup utils
+\brief Tools to Make It Easier to Make Graphs.
+
+This group describes the tools that makes it easier to make graphs and
+the maps that dynamically update with the graph changes.
+*/
+
+/**
+@defgroup exceptions Exceptions
+@ingroup utils
+This group contains the exceptions thrown by LEMON library
+*/
+
+/**
+@defgroup io_group Input-Output
+\brief Several Graph Input-Output methods
+
+Here you can find tools for importing and exporting graphs 
+and graph related data. Now it supports the LEMON format, the
+\c DIMACS format and the encapsulated postscript format.
+*/
+
+/**
+@defgroup lemon_io Lemon Input-Output
+@ingroup io_group
+\brief Reading and writing LEMON format
+
+Methods for reading and writing LEMON format. More about this
+format you can find on the \ref graph-io-page "Graph Input-Output"
+tutorial pages.
+*/
+
+/**
+@defgroup section_io Section readers and writers
+@ingroup lemon_io
+\brief Section readers and writers for lemon Input-Output.
+
+Here you can find which section readers and writers can attach to
+the LemonReader and LemonWriter.
+*/
+
+/**
+@defgroup item_io Item Readers and Writers
+@ingroup lemon_io
+\brief Item readers and writers for lemon Input-Output.
+
+The Input-Output classes can handle more data type by example
+as map or attribute value. Each of these should be written and
+read some way. The module make possible to do this.  
+*/
+
+/**
+@defgroup eps_io Postscript exporting
+@ingroup io_group
+\brief General \c EPS drawer and graph exporter
+
+This group contains general \c EPS drawing methods and special
+graph exporting tools. 
+*/
+
+
+/**
+@defgroup concept Concepts
+\brief Skeleton classes and concept checking classes
+
+This group describes the data/algorithm skeletons and concept checking
+classes implemented in LEMON.
+
+The purpose of the classes in this group is fourfold.
+ 
+- These classes contain the documentations of the concepts. In order
+  to avoid document multiplications, an implementation of a concept
+  simply refers to the corresponding concept class.
+
+- These classes declare every functions, <tt>typedef</tt>s etc. an
+  implementation of the concepts should provide, however completely
+  without implementations and real data structures behind the
+  interface. On the other hand they should provide nothing else. All
+  the algorithms working on a data structure meeting a certain concept
+  should compile with these classes. (Though it will not run properly,
+  of course.) In this way it is easily to check if an algorithm
+  doesn't use any extra feature of a certain implementation.
+
+- The concept descriptor classes also provide a <em>checker class</em>
+  that makes it possible check whether a certain implementation of a
+  concept indeed provides all the required features.
+
+- Finally, They can serve as a skeleton of a new implementation of a concept.
+
+*/
+
+
+/**
+@defgroup graph_concepts Graph Structure Concepts
+@ingroup concept
+\brief Skeleton and concept checking classes for graph structures
+
+This group contains the skeletons and concept checking classes of LEMON's
+graph structures and helper classes used to implement these.
+*/
+
+/* --- Unused group
+@defgroup experimental Experimental Structures and Algorithms
+This group contains some Experimental structures and algorithms.
+The stuff here is subject to change.
+*/
+
+/**
+\anchor demoprograms
+
+@defgroup demos Demo programs
+
+Some demo programs are listed here. Their full source codes can be found in
+the \c demo subdirectory of the source tree.
+
+It order to compile them, use <tt>--enable-demo</tt> configure option when
+build the library.
+
+*/
+
+/**
+@defgroup tools Standalone utility applications
+
+Some utility applications are listed here. 
+
+The standard compilation procedure (<tt>./configure;make</tt>) will compile
+them, as well. 
+
+*/
+
Index: doc/license.dox
===================================================================
--- doc/license.dox	(revision 40)
+++ doc/license.dox	(revision 40)
@@ -0,0 +1,25 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+/**
+
+\page license License Terms
+
+\verbinclude LICENSE
+
+*/
Index: doc/mainpage.dox
===================================================================
--- doc/mainpage.dox	(revision 40)
+++ doc/mainpage.dox	(revision 40)
@@ -0,0 +1,60 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+/**
+\mainpage LEMON Documentation
+
+\section intro Introduction
+
+\subsection whatis What is LEMON
+
+LEMON stands for
+<b>L</b>ibrary of <b>E</b>fficient <b>M</b>odels
+and <b>O</b>ptimization in <b>N</b>etworks.
+It is a C++ template
+library aimed at combinatorial optimization tasks which
+often involve in working
+with graphs.
+
+<b>
+LEMON is an <a class="el" href="http://opensource.org/">open&nbsp;source</a>
+project.
+You are free to use it in your commercial or
+non-commercial applications under very permissive
+\ref license "license terms".
+</b>
+
+\subsection howtoread How to read the documentation
+
+If you want to get a quick start and see the most important features then 
+take a look at our \ref quicktour
+"Quick Tour to LEMON" which will guide you along.
+
+If you already feel like using our library, see the page that tells you 
+\ref getstart "How to start using LEMON".
+
+If you 
+want to see how LEMON works, see 
+some \ref demoprograms "demo programs"!
+
+If you know what you are looking for then try to find it under the
+<a class="el" href="modules.html">Modules</a>
+section.
+
+
+*/
Index: doc/namespaces.dox
===================================================================
--- doc/namespaces.dox	(revision 40)
+++ doc/namespaces.dox	(revision 40)
@@ -0,0 +1,30 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+/// The namespace of LEMON
+
+/// The namespace of LEMON
+///
+namespace lemon {
+
+  /// The namespace of LEMON concepts and concept checking classes
+
+  /// The namespace of LEMON concepts and concept checking classes
+  ///
+  namespace concepts {}
+}
Index: doc/template.h
===================================================================
--- doc/template.h	(revision 40)
+++ doc/template.h	(revision 40)
@@ -0,0 +1,22 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_TEMPLATE_H
+#define LEMON_TEMPLATE_H
+
+#endif // LEMON_TEMPLATE_H
Index: lemon/base.cc
===================================================================
--- lemon/base.cc	(revision 7)
+++ lemon/base.cc	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -18,5 +18,5 @@
 
 ///\file
-///\brief Some basic non inline function and static global data.
+///\brief Some basic non-inline functions and static global data.
 
 #include<lemon/tolerance.h>
Index: lemon/bits/invalid.h
===================================================================
--- lemon/bits/invalid.h	(revision 13)
+++ lemon/bits/invalid.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,4 +27,5 @@
   /// \brief Dummy type to make it easier to create invalid iterators.
   ///
+  /// Dummy type to make it easier to create invalid iterators.
   /// See \ref INVALID for the usage.
   struct Invalid {
Index: lemon/bits/utility.h
===================================================================
--- lemon/bits/utility.h	(revision 7)
+++ lemon/bits/utility.h	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concept_check.h
===================================================================
--- lemon/concept_check.h	(revision 27)
+++ lemon/concept_check.h	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 48)
+++ lemon/concepts/maps.h	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -49,5 +49,4 @@
       /// Returns the value associated with a key.
 
-      /// Returns the value associated with a key.
       /// \bug Value shouldn't need to be default constructible.
       ///
@@ -115,5 +114,5 @@
     };
 
-    /// Read/writable map concept
+    /// Read/Writable map concept
     
     /// Read/writable map concept.
@@ -148,5 +147,4 @@
     /// Dereferable map concept.
     ///
-    /// \todo Rethink this concept.
     template<typename K, typename T, typename R, typename CR>
     class ReferenceMap : public ReadWriteMap<K,T>
@@ -168,11 +166,12 @@
     public:
 
-      ///Returns a reference to the value associated with a key.
+      ///Returns a reference to the value associated to a key.
       Reference operator[](const Key &) { return tmp; }
-      ///Returns a const reference to the value associated with a key.
+      ///Returns a const reference to the value associated to a key.
       ConstReference operator[](const Key &) const { return tmp; }
       /// Sets the value associated with a key.
       void set(const Key &k,const Value &t) { operator[](k)=t; }
 
+      /// \todo Rethink this concept. 
       template<typename _ReferenceMap>
       struct ReferenceMapConcept {
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 15)
+++ lemon/dim2.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,6 +28,5 @@
 ///
 /// The class \ref lemon::dim2::Point "dim2::Point" implements
-///a two dimensional vector with the usual
-/// operations.
+/// a two dimensional vector with the usual operations.
 ///
 /// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"
@@ -50,7 +49,5 @@
 
   /// A simple two dimensional vector (plainvector) implementation
-  ///with the usual vector
-  /// operators.
-  ///
+  /// with the usual vector operations.
   template<typename T>
     class Point {
@@ -71,5 +68,5 @@
       Point(T a, T b) : x(a), y(b) { }
 
-      ///The dimension of the vector.
+      ///Returns the dimension of the vector (i.e. returns 2).
 
       ///The dimension of the vector.
@@ -97,5 +94,5 @@
       }
   
-      ///Increment the left hand side by u
+      ///Increment the left hand side by \c u
       Point<T>& operator +=(const Point<T>& u) {
         x += u.x;
@@ -104,5 +101,5 @@
       }
   
-      ///Decrement the left hand side by u
+      ///Decrement the left hand side by \c u
       Point<T>& operator -=(const Point<T>& u) {
         x -= u.x;
@@ -316,4 +313,5 @@
       ///if at least one point was added to the box or the coordinates of
       ///the box were set).
+      ///
       ///The coordinates of an empty bounding box are not defined. 
       bool empty() const {
@@ -326,7 +324,7 @@
       }
 
-      ///Give back the bottom left corner
-
-      ///Give back the bottom left corner.
+      ///Give back the bottom left corner of the box
+
+      ///Give back the bottom left corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomLeft() const {
@@ -334,7 +332,7 @@
       }
 
-      ///Set the bottom left corner
-
-      ///Set the bottom left corner.
+      ///Set the bottom left corner of the box
+
+      ///Set the bottom left corner of the box.
       ///It should only be used for non-empty box.
       void bottomLeft(Point<T> p) {
@@ -342,7 +340,7 @@
       }
 
-      ///Give back the top right corner
-
-      ///Give back the top right corner.
+      ///Give back the top right corner of the box
+
+      ///Give back the top right corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> topRight() const {
@@ -350,7 +348,7 @@
       }
 
-      ///Set the top right corner
-
-      ///Set the top right corner.
+      ///Set the top right corner of the box
+
+      ///Set the top right corner of the box.
       ///It should only be used for non-empty box.
       void topRight(Point<T> p) {
@@ -358,7 +356,7 @@
       }
 
-      ///Give back the bottom right corner
-
-      ///Give back the bottom right corner.
+      ///Give back the bottom right corner of the box
+
+      ///Give back the bottom right corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> bottomRight() const {
@@ -366,7 +364,7 @@
       }
 
-      ///Set the bottom right corner
-
-      ///Set the bottom right corner.
+      ///Set the bottom right corner of the box
+
+      ///Set the bottom right corner of the box.
       ///It should only be used for non-empty box.
       void bottomRight(Point<T> p) {
@@ -375,7 +373,7 @@
       }
  
-      ///Give back the top left corner
-
-      ///Give back the top left corner.
+      ///Give back the top left corner of the box
+
+      ///Give back the top left corner of the box.
       ///If the bounding box is empty, then the return value is not defined.
       Point<T> topLeft() const {
@@ -383,7 +381,7 @@
       }
 
-      ///Set the top left corner
-
-      ///Set the top left corner.
+      ///Set the top left corner of the box
+
+      ///Set the top left corner of the box.
       ///It should only be used for non-empty box.
       void topLeft(Point<T> p) {
@@ -669,11 +667,10 @@
 
 
-    ///\brief Map of the \ref Point::normSquare() "normSquare()"
-    ///of a \ref Point "Point"-map
-    ///
-    ///Map of the \ref Point::normSquare() "normSquare()"
-    ///of a \ref Point "Point"-map.
-    ///\ingroup maps
-    ///
+  ///\brief Map of the \ref Point::normSquare() "normSquare()"
+  ///of a \ref Point "Point"-map
+  ///
+  ///Map of the \ref Point::normSquare() "normSquare()"
+  ///of a \ref Point "Point"-map.
+  ///\ingroup maps
   template<class M>
   class NormSquareMap 
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 2)
+++ lemon/list_graph.h	(revision 39)
@@ -0,0 +1,18 @@
+/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 47)
+++ lemon/maps.h	(revision 44)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -82,7 +82,6 @@
   /// Constant map.
 
-  /// This is a \ref concepts::ReadMap "readable" map which assigns a 
-  /// specified value to each key.
-  /// In other aspects it is equivalent to \c NullMap.
+  /// This is a readable map which assigns a specified value to each key.
+  /// In other aspects it is equivalent to the \c NullMap.
   template<typename K, typename T>
   class ConstMap : public MapBase<K, T> {
@@ -135,7 +134,6 @@
   /// Constant map with inlined constant value.
 
-  /// This is a \ref concepts::ReadMap "readable" map which assigns a 
-  /// specified value to each key.
-  /// In other aspects it is equivalent to \c NullMap.
+  /// This is a readable map which assigns a specified value to each key.
+  /// In other aspects it is equivalent to the \c NullMap.
   template<typename K, typename V, V v>
   class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
@@ -152,5 +150,5 @@
   };
 
-  ///Returns a \c ConstMap class with inlined value
+  ///Returns a \c ConstMap class
 
   ///This function just returns a \c ConstMap class with inlined value.
@@ -161,26 +159,23 @@
   }
 
-  ///Map based on \c std::map
+  ///Map based on std::map
 
   ///This is essentially a wrapper for \c std::map with addition that
   ///you can specify a default value different from \c Value().
-  ///It meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
   template <typename K, typename T, typename Compare = std::less<K> >
-  class StdMap : public MapBase<K, T> {
+  class StdMap {
     template <typename K1, typename T1, typename C1>
     friend class StdMap;
   public:
 
-    typedef MapBase<K, T> Parent;
-    ///\e
-    typedef typename Parent::Key Key;
-    ///\e
-    typedef typename Parent::Value Value;
-    ///\e
+    typedef True ReferenceMapTag;
+    ///Key type
+    typedef K Key;
+    ///Value type
+    typedef T Value;
+    ///Reference Type
     typedef T& Reference;
-    ///\e
+    ///Const reference type
     typedef const T& ConstReference;
-
-    typedef True ReferenceMapTag;
 
   private:
@@ -194,11 +189,11 @@
     /// Constructor with specified default value
     StdMap(const T& value = T()) : _value(value) {}
-    /// \brief Constructs the map from an appropriate \c std::map, and 
-    /// explicitly specifies a default value.
+    /// \brief Constructs the map from an appropriate std::map, and explicitly
+    /// specifies a default value.
     template <typename T1, typename Comp1>
     StdMap(const std::map<Key, T1, Comp1> &map, const T& value = T()) 
       : _map(map.begin(), map.end()), _value(value) {}
     
-    /// \brief Constructs a map from an other \ref StdMap.
+    /// \brief Constructs a map from an other StdMap.
     template<typename T1, typename Comp1>
     StdMap(const StdMap<Key, T1, Comp1> &c) 
@@ -245,37 +240,15 @@
 
   };
-  
-  ///Returns a \c StdMap class
-
-  ///This function just returns a \c StdMap class with specified 
-  ///default value.
-  ///\relates StdMap
-  template<typename K, typename V, typename Compare = std::less<K> > 
-  inline StdMap<K, V, Compare> stdMap(const V& value = V()) {
-    return StdMap<K, V, Compare>(value);
-  }
-
-  ///Returns a \c StdMap class created from an appropriate std::map
-
-  ///This function just returns a \c StdMap class created from an 
-  ///appropriate std::map.
-  ///\relates StdMap
-  template<typename K, typename V, typename Compare = std::less<K> > 
-  inline StdMap<K, V, Compare> stdMap( const std::map<K, V, Compare> &map, 
-                                       const V& value = V() ) {
-    return StdMap<K, V, Compare>(map, value);
-  }
 
   /// \brief Map for storing values for keys from the range <tt>[0..size-1]</tt>
   ///
-  /// This map has the <tt>[0..size-1]</tt> keyset and the values
+  /// The current map has the <tt>[0..size-1]</tt> keyset and the values
   /// are stored in a \c std::vector<T>  container. It can be used with
   /// some data structures, for example \c UnionFind, \c BinHeap, when 
-  /// the used items are small integer numbers.
-  /// This map meets the \ref concepts::ReferenceMap "ReferenceMap" concept.
+  /// the used items are small integer numbers. 
   ///
   /// \todo Revise its name
   template <typename T>
-  class IntegerMap : public MapBase<int, T> {
+  class IntegerMap {
 
     template <typename T1>
@@ -284,15 +257,13 @@
   public:
 
-    typedef MapBase<int, T> Parent;
-    ///\e
-    typedef typename Parent::Key Key;
-    ///\e
-    typedef typename Parent::Value Value;
+    typedef True ReferenceMapTag;
+    ///\e
+    typedef int Key;
+    ///\e
+    typedef T Value;
     ///\e
     typedef T& Reference;
     ///\e
     typedef const T& ConstReference;
-
-    typedef True ReferenceMapTag;
 
   private:
@@ -306,10 +277,10 @@
     IntegerMap(int size = 0, const T& value = T()) : _vector(size, value) {}
 
-    /// \brief Constructs the map from an appropriate \c std::vector.
+    /// \brief Constructs the map from an appropriate std::vector.
     template <typename T1>
     IntegerMap(const std::vector<T1>& vector) 
       : _vector(vector.begin(), vector.end()) {}
     
-    /// \brief Constructs a map from an other \ref IntegerMap.
+    /// \brief Constructs a map from an other IntegerMap.
     template <typename T1>
     IntegerMap(const IntegerMap<T1> &c) 
@@ -343,13 +314,4 @@
 
   };
-  
-  ///Returns an \c IntegerMap class
-
-  ///This function just returns an \c IntegerMap class.
-  ///\relates IntegerMap
-  template<typename T>
-  inline IntegerMap<T> integerMap(int size = 0, const T& value = T()) {
-    return IntegerMap<T>(size, value);
-  }
 
   /// @}
@@ -388,5 +350,5 @@
   ///the default conversion.
   ///
-  ///This \ref concepts::ReadMap "read only map"
+  ///This \c concepts::ReadMap "read only map"
   ///converts the \c Value of a map to type \c T.
   ///Its \c Key is inherited from \c M.
@@ -405,5 +367,7 @@
     ConvertMap(const M &_m) : m(_m) {};
 
-    ///\e
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
     Value operator[](const Key& k) const {return m[k];}
   };
@@ -442,17 +406,8 @@
     Value operator[](Key k) const {return m[k];}
   };
-  
-  ///Returns a \c SimpleMap class
-
-  ///This function just returns a \c SimpleMap class.
-  ///\relates SimpleMap
-  template<typename M>
-  inline SimpleMap<M> simpleMap(const M &m) {
-    return SimpleMap<M>(m);
-  }
 
   ///Simple writable wrapping of a map
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the simple
+  ///This \ref concepts::WriteMap "write map" returns the simple
   ///wrapping of the given map. Sometimes the reference maps cannot be
   ///combined with simple read-write maps. This map adaptor wraps the
@@ -479,19 +434,10 @@
   };
 
-  ///Returns a \c SimpleWriteMap class
-
-  ///This function just returns a \c SimpleWriteMap class.
-  ///\relates SimpleWriteMap
-  template<typename M>
-  inline SimpleWriteMap<M> simpleWriteMap(M &m) {
-    return SimpleWriteMap<M>(m);
-  }
-
   ///Sum of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the sum of the two
+  ///This \c concepts::ReadMap "read only map" returns the sum of the two
   ///given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
-  ///The \c Key and \c Value of \c M2 must be convertible to those of \c M1.
+  ///The \c Key and \c Value of M2 must be convertible to those of \c M1.
   template<typename M1, typename M2> 
   class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
@@ -513,5 +459,5 @@
 
   ///This function just returns an \c AddMap class.
-  ///\todo Extend the documentation: how to call these type of functions?
+  ///\todo How to call these type of functions?
   ///
   ///\relates AddMap
@@ -523,5 +469,5 @@
   ///Shift a map with a constant.
 
-  ///This \ref concepts::ReadMap "read only map" returns the sum of the
+  ///This \c concepts::ReadMap "read only map" returns the sum of the
   ///given map and a constant value.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -559,5 +505,5 @@
   ///Shift a map with a constant (ReadWrite version).
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the sum of the
+  ///This \c concepts::ReadWriteMap "read-write map" returns the sum of the
   ///given map and a constant value. It makes also possible to write the map.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -605,5 +551,5 @@
   ///Difference of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the difference
+  ///This \c concepts::ReadMap "read only map" returns the difference
   ///of the values of the two given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
@@ -638,5 +584,5 @@
   ///Product of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the product of the
+  ///This \c concepts::ReadMap "read only map" returns the product of the
   ///values of the two given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
@@ -668,5 +614,5 @@
   ///Scales a map with a constant.
 
-  ///This \ref concepts::ReadMap "read only map" returns the value of the
+  ///This \c concepts::ReadMap "read only map" returns the value of the
   ///given map multiplied from the left side with a constant value.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -704,5 +650,5 @@
   ///Scales a map with a constant (ReadWrite version).
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the value of the
+  ///This \c concepts::ReadWriteMap "read-write map" returns the value of the
   ///given map multiplied from the left side with a constant value. It can
   ///also be used as write map if the \c / operator is defined between
@@ -752,5 +698,5 @@
   ///Quotient of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the quotient of the
+  ///This \c concepts::ReadMap "read only map" returns the quotient of the
   ///values of the two given maps.
   ///Its \c Key and \c Value are inherited from \c M1.
@@ -782,5 +728,5 @@
   ///Composition of two maps
 
-  ///This \ref concepts::ReadMap "read only map" returns the composition of
+  ///This \c concepts::ReadMap "read only map" returns the composition of
   ///two given maps.
   ///That is to say, if \c m1 is of type \c M1 and \c m2 is of \c M2,
@@ -833,5 +779,5 @@
   ///Combine of two maps using an STL (binary) functor.
   ///
-  ///This \ref concepts::ReadMap "read only map" takes two maps and a
+  ///This \c concepts::ReadMap "read only map" takes two maps and a
   ///binary functor and returns the composition of the two
   ///given maps unsing the functor. 
@@ -906,5 +852,5 @@
   ///Negative value of a map
 
-  ///This \ref concepts::ReadMap "read only map" returns the negative
+  ///This \c concepts::ReadMap "read only map" returns the negative
   ///value of the value returned by the given map.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -928,5 +874,5 @@
   ///Negative value of a map (ReadWrite version)
 
-  ///This \ref concepts::ReadWriteMap "read-write map" returns the negative
+  ///This \c concepts::ReadWriteMap "read-write map" returns the negative
   ///value of the value returned by the given map.
   ///Its \c Key and \c Value are inherited from \c M.
@@ -970,5 +916,5 @@
   ///Absolute value of a map
 
-  ///This \ref concepts::ReadMap "read only map" returns the absolute value
+  ///This \c concepts::ReadMap "read only map" returns the absolute value
   ///of the value returned by the given map.
   ///Its \c Key and \c Value are inherited from \c M. 
@@ -1004,5 +950,5 @@
   ///Converts an STL style functor to a map
 
-  ///This \ref concepts::ReadMap "read only map" returns the value
+  ///This \c concepts::ReadMap "read only map" returns the value
   ///of a given functor.
   ///
@@ -1010,6 +956,5 @@
   ///\c Key and \c Value. 
   ///In most cases they have to be given explicitly because a 
-  ///functor typically does not provide \c argument_type and 
-  ///\c result_type typedefs.
+  ///functor typically does not provide such typedefs.
   ///
   ///Parameter \c F is the type of the used functor.
@@ -1036,7 +981,6 @@
   ///This function just returns a \c FunctorMap class.
   ///
-  ///This function is specialized for adaptable binary function
-  ///classes and C++ functions.
-  ///
+  ///It is specialized for adaptable function classes and
+  ///C++ functions.
   ///\relates FunctorMap
   template<typename K, typename V, typename F> inline 
@@ -1061,8 +1005,8 @@
 
   ///This class Converts a map to an STL style (unary) functor.
-  ///That is it provides an <tt>operator()</tt> to read its values.
+  ///that is it provides an <tt>operator()</tt> to read its values.
   ///
   ///For the sake of convenience it also works as
-  ///a ususal \ref concepts::ReadMap "readable map",
+  ///a ususal \c concepts::ReadMap "readable map",
   ///i.e. <tt>operator[]</tt> and the \c Key and \c Value typedefs also exist.
   ///
@@ -1096,12 +1040,12 @@
   }
 
-  ///Just readable version of \ref ForkWriteMap
-
-  ///This map has two \ref concepts::ReadMap "readable map"
+  ///Applies all map setting operations to two maps
+
+  ///This map has two \c concepts::ReadMap "readable map"
   ///parameters and each read request will be passed just to the
-  ///first map. This class is the just readable map type of \c ForkWriteMap.
+  ///first map. This class is the just readable map type of the ForkWriteMap.
   ///
   ///The \c Key and \c Value are inherited from \c M1.
-  ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
+  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
   ///
   ///\sa ForkWriteMap
@@ -1126,12 +1070,12 @@
   ///Applies all map setting operations to two maps
 
-  ///This map has two \ref concepts::WriteMap "writable map"
+  ///This map has two \c concepts::WriteMap "writable map"
   ///parameters and each write request will be passed to both of them.
-  ///If \c M1 is also \ref concepts::ReadMap "readable",
+  ///If \c M1 is also \c concepts::ReadMap "readable",
   ///then the read operations will return the
   ///corresponding values of \c M1.
   ///
   ///The \c Key and \c Value are inherited from \c M1.
-  ///The \c Key and \c Value of \c M2 must be convertible from those of \c M1.
+  ///The \c Key and \c Value of M2 must be convertible from those of \c M1.
   ///
   ///\sa ForkMap
@@ -1177,7 +1121,7 @@
   ///Logical 'not' of a map
   
-  ///This bool \ref concepts::ReadMap "read only map" returns the 
+  ///This bool \c concepts::ReadMap "read only map" returns the 
   ///logical negation of the value returned by the given map.
-  ///Its \c Key is inherited from \c M, its \c Value is \c bool.
+  ///Its \c Key is inherited from \c M, its Value is \c bool.
   ///
   ///\sa NotWriteMap
@@ -1198,8 +1142,8 @@
   ///Logical 'not' of a map (ReadWrie version)
   
-  ///This bool \ref concepts::ReadWriteMap "read-write map" returns the 
+  ///This bool \c concepts::ReadWriteMap "read-write map" returns the 
   ///logical negation of the value returned by the given map. When it is set,
   ///the opposite value is set to the original map.
-  ///Its \c Key is inherited from \c M, its \c Value is \c bool.
+  ///Its \c Key is inherited from \c M, its Value is \c bool.
   ///
   ///\sa NotMap
@@ -1266,13 +1210,13 @@
   /// \brief Writable bool map for logging each \c true assigned element
   ///
-  /// A \ref concepts::ReadWriteMap "read-write" bool map for logging 
-  /// each \c true assigned element, i.e it copies all the keys set 
-  /// to \c true to the given iterator.
+  /// Writable bool map for logging each \c true assigned element, i.e it
+  /// copies all the keys set to \c true to the given iterator.
   ///
   /// \note The container of the iterator should contain space 
   /// for each element.
   ///
-  /// The following example shows how you can write the edges found by 
-  /// the \ref Prim algorithm directly to the standard output.
+  /// The following example shows how you can write the edges found by the Prim
+  /// algorithm directly
+  /// to the standard output.
   ///\code
   /// typedef IdMap<Graph, Edge> EdgeIdMap;
Index: lemon/random.cc
===================================================================
--- lemon/random.cc	(revision 16)
+++ lemon/random.cc	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 23)
+++ lemon/random.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -511,5 +511,5 @@
   ///\endcode
   ///
-  /// The lemon provides a global instance of the random number
+  /// LEMON provides a global instance of the random number
   /// generator which name is \ref lemon::rnd "rnd". Usually it is a
   /// good programming convenience to use this global generator to get
@@ -527,10 +527,10 @@
   public:
 
-    /// \brief Constructor
+    /// \brief Default constructor
     ///
     /// Constructor with constant seeding.
     Random() { core.initState(); }
 
-    /// \brief Constructor
+    /// \brief Constructor with seed
     ///
     /// Constructor with seed. The current number type will be converted
@@ -541,5 +541,5 @@
     }
 
-    /// \brief Constructor
+    /// \brief Constructor with array seeding
     ///
     /// Constructor with array seeding. The given range should contain
@@ -578,5 +578,5 @@
     ///
     /// It returns a random real number from the range [0, 1). The
-    /// default Number type is double.
+    /// default Number type is \c double.
     template <typename Number>
     Number real() {
@@ -654,6 +654,6 @@
     ///
     /// It returns a random non-negative integer uniformly from the
-    /// whole range of the current \c Number type.  The default result
-    /// type of this function is unsigned int.
+    /// whole range of the current \c Number type. The default result
+    /// type of this function is <tt>unsigned int</tt>.
     template <typename Number>
     Number uinteger() {
@@ -669,5 +669,5 @@
     /// It returns a random integer uniformly from the whole range of
     /// the current \c Number type. The default result type of this
-    /// function is int.
+    /// function is \c int.
     template <typename Number>
     Number integer() {
@@ -690,5 +690,5 @@
     }
 
-    ///\name Nonuniform distributions
+    ///\name Non-uniform distributions
     ///
     
Index: lemon/tolerance.h
===================================================================
--- lemon/tolerance.h	(revision 16)
+++ lemon/tolerance.h	(revision 49)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -37,10 +37,10 @@
   ///as a result of a probably inexact computation.
   ///
-  ///Tolerance is a class to provide a basic way to
+  ///\ref Tolerance is a class to provide a basic way to
   ///handle the comparison of numbers that are obtained
   ///as a result of a probably inexact computation.
   ///
   ///This is an abstract class, it should be specialized for all numerical
-  ///data types. These specialized classes like \ref Tolerance\<double\>
+  ///data types. These specialized classes like \ref Tolerance<double>
   ///may offer additional tuning parameters.
   ///
@@ -49,11 +49,7 @@
   ///\sa Tolerance<long double>
   ///\sa Tolerance<int>
-#if defined __GNUC__ && !defined __STRICT_ANSI__  
   ///\sa Tolerance<long long int>
-#endif
   ///\sa Tolerance<unsigned int>
-#if defined __GNUC__ && !defined __STRICT_ANSI__  
   ///\sa Tolerance<unsigned long long int>
-#endif
 
   template<class T>
@@ -64,5 +60,5 @@
 
     ///\name Comparisons
-    ///The concept is that these bool functions return with \c true only if
+    ///The concept is that these bool functions return \c true only if
     ///the related comparisons hold even if some numerical error appeared
     ///during the computations.
@@ -92,7 +88,7 @@
 
 
-  ///Float specialization of \ref Tolerance.
-
-  ///Float specialization of \ref Tolerance.
+  ///Float specialization of Tolerance.
+
+  ///Float specialization of Tolerance.
   ///\sa Tolerance
   ///\relates Tolerance
@@ -108,19 +104,19 @@
     ///Constructor setting the epsilon tolerance to the default value.
     Tolerance() : _epsilon(def_epsilon) {}
-    ///Constructor setting the epsilon tolerance.
+    ///Constructor setting the epsilon tolerance to the given value.
     Tolerance(float e) : _epsilon(e) {}
 
-    ///Return the epsilon value.
+    ///Returns the epsilon value.
     Value epsilon() const {return _epsilon;}
-    ///Set the epsilon value.
+    ///Sets the epsilon value.
     void epsilon(Value e) {_epsilon=e;}
 
-    ///Return the default epsilon value.
+    ///Returns the default epsilon value.
     static Value defaultEpsilon() {return def_epsilon;}
-    ///Set the default epsilon value.
+    ///Sets the default epsilon value.
     static void defaultEpsilon(Value e) {def_epsilon=e;}
 
     ///\name Comparisons
-    ///See class Tolerance for more details.
+    ///See \ref Tolerance for more details.
 
     ///@{
@@ -143,7 +139,7 @@
   };
 
-  ///Double specialization of \ref Tolerance.
-
-  ///Double specialization of \ref Tolerance.
+  ///Double specialization of Tolerance.
+
+  ///Double specialization of Tolerance.
   ///\sa Tolerance
   ///\relates Tolerance
@@ -159,19 +155,19 @@
     ///Constructor setting the epsilon tolerance to the default value.
     Tolerance() : _epsilon(def_epsilon) {}
-    ///Constructor setting the epsilon tolerance.
+    ///Constructor setting the epsilon tolerance to the given value.
     Tolerance(double e) : _epsilon(e) {}
 
-    ///Return the epsilon value.
+    ///Returns the epsilon value.
     Value epsilon() const {return _epsilon;}
-    ///Set the epsilon value.
+    ///Sets the epsilon value.
     void epsilon(Value e) {_epsilon=e;}
 
-    ///Return the default epsilon value.
+    ///Returns the default epsilon value.
     static Value defaultEpsilon() {return def_epsilon;}
-    ///Set the default epsilon value.
+    ///Sets the default epsilon value.
     static void defaultEpsilon(Value e) {def_epsilon=e;}
 
     ///\name Comparisons
-    ///See class Tolerance for more details.
+    ///See \ref Tolerance for more details.
 
     ///@{
@@ -194,7 +190,7 @@
   };
 
-  ///Long double specialization of \ref Tolerance.
-
-  ///Long double specialization of \ref Tolerance.
+  ///Long double specialization of Tolerance.
+
+  ///Long double specialization of Tolerance.
   ///\sa Tolerance
   ///\relates Tolerance
@@ -210,19 +206,19 @@
     ///Constructor setting the epsilon tolerance to the default value.
     Tolerance() : _epsilon(def_epsilon) {}
-    ///Constructor setting the epsilon tolerance.
+    ///Constructor setting the epsilon tolerance to the given value.
     Tolerance(long double e) : _epsilon(e) {}
 
-    ///Return the epsilon value.
+    ///Returns the epsilon value.
     Value epsilon() const {return _epsilon;}
-    ///Set the epsilon value.
+    ///Sets the epsilon value.
     void epsilon(Value e) {_epsilon=e;}
 
-    ///Return the default epsilon value.
+    ///Returns the default epsilon value.
     static Value defaultEpsilon() {return def_epsilon;}
-    ///Set the default epsilon value.
+    ///Sets the default epsilon value.
     static void defaultEpsilon(Value e) {def_epsilon=e;}
 
     ///\name Comparisons
-    ///See class Tolerance for more details.
+    ///See \ref Tolerance for more details.
 
     ///@{
@@ -245,7 +241,7 @@
   };
 
-  ///Integer specialization of \ref Tolerance.
-
-  ///Integer specialization of \ref Tolerance.
+  ///Integer specialization of Tolerance.
+
+  ///Integer specialization of Tolerance.
   ///\sa Tolerance
   template<>
@@ -278,7 +274,7 @@
   };
 
+  ///Unsigned integer specialization of Tolerance.
+
   ///Unsigned integer specialization of \ref Tolerance.
-
-  ///Unsigned integer specialization of \ref Tolerance.
   ///\sa Tolerance
   template<>
@@ -312,7 +308,7 @@
   
 
-  ///Long integer specialization of \ref Tolerance.
-
-  ///Long integer specialization of \ref Tolerance.
+  ///Long integer specialization of Tolerance.
+
+  ///Long integer specialization of Tolerance.
   ///\sa Tolerance
   template<>
@@ -345,7 +341,7 @@
   };
 
+  ///Unsigned long integer specialization of Tolerance.
+
   ///Unsigned long integer specialization of \ref Tolerance.
-
-  ///Unsigned long integer specialization of \ref Tolerance.
   ///\sa Tolerance
   template<>
@@ -380,5 +376,5 @@
 #if defined __GNUC__ && !defined __STRICT_ANSI__
 
-  ///Long long integer specialization of \ref Tolerance.
+  ///Long long integer specialization of Tolerance.
 
   ///Long long integer specialization of \ref Tolerance.
@@ -415,5 +411,5 @@
   };
 
-  ///Unsigned long long integer specialization of \ref Tolerance.
+  ///Unsigned long long integer specialization of Tolerance.
 
   ///Unsigned long long integer specialization of \ref Tolerance.
Index: scripts/update-copyright-header.sh
===================================================================
--- scripts/update-copyright-header.sh	(revision 38)
+++ scripts/update-copyright-header.sh	(revision 38)
@@ -0,0 +1,52 @@
+#!/bin/bash
+
+YEAR=`date +2003-%Y`
+HGROOT=`hg root`
+
+function update_file() {
+    TMP_FILE=`mktemp`
+    FILE_NAME=$1
+
+    (echo "/* -*- C++ -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) "$YEAR"
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided \"AS IS\" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+"
+	awk 'BEGIN { pm=0; }
+     pm==3 { print }
+     /\/\* / && pm==0 { pm=1;}
+     /[^:blank:]/ && (pm==0 || pm==2) { pm=3; print;}
+     /\*\// && pm==1 { pm=2;}
+    ' $1
+	) >$TMP_FILE
+    rm $FILE_NAME
+    mv $TMP_FILE $FILE_NAME
+}
+
+
+if [ $# == 0 ]; then
+    echo -n Update all source files...
+    for i in `hg manifest|grep -E  '\.(cc|h|dox)$'`
+    do
+	update_file $HGROOT/$i
+    done
+    echo ' done.'
+else
+    for i in $*
+    do
+	update_file $i
+    done
+fi
Index: test/dim_test.cc
===================================================================
--- test/dim_test.cc	(revision 14)
+++ test/dim_test.cc	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 25)
+++ test/maps_test.cc	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/random_test.cc
===================================================================
--- test/random_test.cc	(revision 10)
+++ test/random_test.cc	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/test_tools.h
===================================================================
--- test/test_tools.h	(revision 4)
+++ test/test_tools.h	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/test_tools_fail.cc
===================================================================
--- test/test_tools_fail.cc	(revision 4)
+++ test/test_tools_fail.cc	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/test_tools_pass.cc
===================================================================
--- test/test_tools_pass.cc	(revision 4)
+++ test/test_tools_pass.cc	(revision 39)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2007
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).