Unify the sources (#339)
authorAlpar Juttner <alpar@cs.elte.hu>
Sat, 06 Mar 2010 14:35:12 +0000
changeset 956141f9c0db4a3
parent 955 7f6e2bd76654
child 957 f802439d2b58
child 959 38213abd2911
child 1041 f112c18bc304
Unify the sources (#339)
demo/arg_parser_demo.cc
doc/groups.dox
doc/mainpage.dox
doc/min_cost_flow.dox
lemon/adaptors.h
lemon/arg_parser.cc
lemon/arg_parser.h
lemon/bellman_ford.h
lemon/bfs.h
lemon/binomial_heap.h
lemon/bits/array_map.h
lemon/bits/default_map.h
lemon/bits/edge_set_extender.h
lemon/bits/solver_bits.h
lemon/bits/windows.cc
lemon/bucket_heap.h
lemon/capacity_scaling.h
lemon/cbc.h
lemon/circulation.h
lemon/clp.cc
lemon/clp.h
lemon/concepts/digraph.h
lemon/concepts/graph.h
lemon/concepts/graph_components.h
lemon/concepts/heap.h
lemon/connectivity.h
lemon/core.h
lemon/cost_scaling.h
lemon/cplex.cc
lemon/cycle_canceling.h
lemon/dfs.h
lemon/dijkstra.h
lemon/dimacs.h
lemon/edge_set.h
lemon/euler.h
lemon/fractional_matching.h
lemon/full_graph.h
lemon/glpk.cc
lemon/glpk.h
lemon/gomory_hu.h
lemon/graph_to_eps.h
lemon/hao_orlin.h
lemon/hartmann_orlin_mmc.h
lemon/howard_mmc.h
lemon/karp_mmc.h
lemon/lgf_reader.h
lemon/lgf_writer.h
lemon/list_graph.h
lemon/lp.h
lemon/lp_base.cc
lemon/lp_base.h
lemon/lp_skeleton.cc
lemon/lp_skeleton.h
lemon/maps.h
lemon/matching.h
lemon/math.h
lemon/min_cost_arborescence.h
lemon/network_simplex.h
lemon/path.h
lemon/planarity.h
lemon/preflow.h
lemon/smart_graph.h
lemon/soplex.cc
lemon/soplex.h
lemon/static_graph.h
lemon/suurballe.h
lemon/unionfind.h
test/bellman_ford_test.cc
test/bfs_test.cc
test/circulation_test.cc
test/connectivity_test.cc
test/dfs_test.cc
test/digraph_test.cc
test/dijkstra_test.cc
test/edge_set_test.cc
test/euler_test.cc
test/fractional_matching_test.cc
test/gomory_hu_test.cc
test/graph_test.cc
test/hao_orlin_test.cc
test/maps_test.cc
test/matching_test.cc
test/min_cost_arborescence_test.cc
test/min_cost_flow_test.cc
test/min_mean_cycle_test.cc
test/preflow_test.cc
test/suurballe_test.cc
test/test_tools.h
tools/dimacs-solver.cc
     1.1 --- a/demo/arg_parser_demo.cc	Wed Mar 17 12:35:52 2010 +0100
     1.2 +++ b/demo/arg_parser_demo.cc	Sat Mar 06 14:35:12 2010 +0000
     1.3 @@ -2,7 +2,7 @@
     1.4   *
     1.5   * This file is a part of LEMON, a generic C++ optimization library.
     1.6   *
     1.7 - * Copyright (C) 2003-2009
     1.8 + * Copyright (C) 2003-2010
     1.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    1.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    1.11   *
    1.12 @@ -69,7 +69,7 @@
    1.13    // exit(1) on these cases, but this makes Valgrind falsely warn
    1.14    // about memory leaks.
    1.15    ap.throwOnProblems();
    1.16 -  
    1.17 +
    1.18    // Perform the parsing process
    1.19    // (in case of any error it terminates the program)
    1.20    // The try {} construct is necessary only if the ap.trowOnProblems()
     2.1 --- a/doc/groups.dox	Wed Mar 17 12:35:52 2010 +0100
     2.2 +++ b/doc/groups.dox	Sat Mar 06 14:35:12 2010 +0000
     2.3 @@ -2,7 +2,7 @@
     2.4   *
     2.5   * This file is a part of LEMON, a generic C++ optimization library.
     2.6   *
     2.7 - * Copyright (C) 2003-2009
     2.8 + * Copyright (C) 2003-2010
     2.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    2.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    2.11   *
     3.1 --- a/doc/mainpage.dox	Wed Mar 17 12:35:52 2010 +0100
     3.2 +++ b/doc/mainpage.dox	Sat Mar 06 14:35:12 2010 +0000
     3.3 @@ -2,7 +2,7 @@
     3.4   *
     3.5   * This file is a part of LEMON, a generic C++ optimization library.
     3.6   *
     3.7 - * Copyright (C) 2003-2009
     3.8 + * Copyright (C) 2003-2010
     3.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    3.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    3.11   *
    3.12 @@ -25,7 +25,7 @@
    3.13  and <b>O</b>ptimization in <b>N</b>etworks</i>.
    3.14  It is a C++ template library providing efficient implementations of common
    3.15  data structures and algorithms with focus on combinatorial optimization
    3.16 -tasks connected mainly with graphs and networks. 
    3.17 +tasks connected mainly with graphs and networks.
    3.18  
    3.19  <b>
    3.20  LEMON is an <a class="el" href="http://opensource.org/">open&nbsp;source</a>
    3.21 @@ -35,7 +35,7 @@
    3.22  \ref license "license terms".
    3.23  </b>
    3.24  
    3.25 -The project is maintained by the 
    3.26 +The project is maintained by the
    3.27  <a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
    3.28  Combinatorial Optimization</a> \ref egres
    3.29  at the Operations Research Department of the
     4.1 --- a/doc/min_cost_flow.dox	Wed Mar 17 12:35:52 2010 +0100
     4.2 +++ b/doc/min_cost_flow.dox	Sat Mar 06 14:35:12 2010 +0000
     4.3 @@ -2,7 +2,7 @@
     4.4   *
     4.5   * This file is a part of LEMON, a generic C++ optimization library.
     4.6   *
     4.7 - * Copyright (C) 2003-2009
     4.8 + * Copyright (C) 2003-2010
     4.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    4.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    4.11   *
    4.12 @@ -81,7 +81,7 @@
    4.13     - \f$\pi(u)\leq 0\f$;
    4.14     - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
    4.15       then \f$\pi(u)=0\f$.
    4.16 - 
    4.17 +
    4.18  Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc
    4.19  \f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e.
    4.20  \f[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f]
    4.21 @@ -119,7 +119,7 @@
    4.22      sup(u) \quad \forall u\in V \f]
    4.23  \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
    4.24  
    4.25 -It means that the total demand must be less or equal to the 
    4.26 +It means that the total demand must be less or equal to the
    4.27  total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
    4.28  positive) and all the demands have to be satisfied, but there
    4.29  could be supplies that are not carried out from the supply
     5.1 --- a/lemon/adaptors.h	Wed Mar 17 12:35:52 2010 +0100
     5.2 +++ b/lemon/adaptors.h	Sat Mar 06 14:35:12 2010 +0000
     5.3 @@ -2,7 +2,7 @@
     5.4   *
     5.5   * This file is a part of LEMON, a generic C++ optimization library.
     5.6   *
     5.7 - * Copyright (C) 2003-2009
     5.8 + * Copyright (C) 2003-2010
     5.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    5.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    5.11   *
    5.12 @@ -421,7 +421,7 @@
    5.13      void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
    5.14        Parent::initialize(digraph);
    5.15        _node_filter = &node_filter;
    5.16 -      _arc_filter = &arc_filter;      
    5.17 +      _arc_filter = &arc_filter;
    5.18      }
    5.19  
    5.20    public:
    5.21 @@ -508,11 +508,11 @@
    5.22    public:
    5.23  
    5.24      template <typename V>
    5.25 -    class NodeMap 
    5.26 -      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, 
    5.27 -	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
    5.28 +    class NodeMap
    5.29 +      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    5.30 +              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
    5.31        typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    5.32 -	LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
    5.33 +        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
    5.34  
    5.35      public:
    5.36        typedef V Value;
    5.37 @@ -535,9 +535,9 @@
    5.38      };
    5.39  
    5.40      template <typename V>
    5.41 -    class ArcMap 
    5.42 +    class ArcMap
    5.43        : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    5.44 -	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
    5.45 +              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
    5.46        typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    5.47          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
    5.48  
    5.49 @@ -582,7 +582,7 @@
    5.50      void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
    5.51        Parent::initialize(digraph);
    5.52        _node_filter = &node_filter;
    5.53 -      _arc_filter = &arc_filter;      
    5.54 +      _arc_filter = &arc_filter;
    5.55      }
    5.56  
    5.57    public:
    5.58 @@ -651,10 +651,10 @@
    5.59      }
    5.60  
    5.61      template <typename V>
    5.62 -    class NodeMap 
    5.63 +    class NodeMap
    5.64        : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    5.65            LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
    5.66 -      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, 
    5.67 +      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    5.68          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
    5.69  
    5.70      public:
    5.71 @@ -678,7 +678,7 @@
    5.72      };
    5.73  
    5.74      template <typename V>
    5.75 -    class ArcMap 
    5.76 +    class ArcMap
    5.77        : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    5.78            LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
    5.79        typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    5.80 @@ -1021,10 +1021,10 @@
    5.81      }
    5.82  
    5.83      template <typename V>
    5.84 -    class NodeMap 
    5.85 +    class NodeMap
    5.86        : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
    5.87            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
    5.88 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
    5.89 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
    5.90          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
    5.91  
    5.92      public:
    5.93 @@ -1048,10 +1048,10 @@
    5.94      };
    5.95  
    5.96      template <typename V>
    5.97 -    class ArcMap 
    5.98 +    class ArcMap
    5.99        : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   5.100            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
   5.101 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
   5.102 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   5.103          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
   5.104  
   5.105      public:
   5.106 @@ -1075,10 +1075,10 @@
   5.107      };
   5.108  
   5.109      template <typename V>
   5.110 -    class EdgeMap 
   5.111 +    class EdgeMap
   5.112        : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   5.113          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
   5.114 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
   5.115 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   5.116          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
   5.117  
   5.118      public:
   5.119 @@ -1117,8 +1117,8 @@
   5.120    protected:
   5.121      NF* _node_filter;
   5.122      EF* _edge_filter;
   5.123 -    SubGraphBase() 
   5.124 -	  : Parent(), _node_filter(0), _edge_filter(0) { }
   5.125 +    SubGraphBase()
   5.126 +          : Parent(), _node_filter(0), _edge_filter(0) { }
   5.127  
   5.128      void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
   5.129        Parent::initialize(graph);
   5.130 @@ -1219,10 +1219,10 @@
   5.131      }
   5.132  
   5.133      template <typename V>
   5.134 -    class NodeMap 
   5.135 +    class NodeMap
   5.136        : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   5.137            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
   5.138 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
   5.139 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   5.140          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
   5.141  
   5.142      public:
   5.143 @@ -1246,10 +1246,10 @@
   5.144      };
   5.145  
   5.146      template <typename V>
   5.147 -    class ArcMap 
   5.148 +    class ArcMap
   5.149        : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   5.150            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
   5.151 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
   5.152 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   5.153          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
   5.154  
   5.155      public:
   5.156 @@ -1273,11 +1273,11 @@
   5.157      };
   5.158  
   5.159      template <typename V>
   5.160 -    class EdgeMap 
   5.161 +    class EdgeMap
   5.162        : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   5.163          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
   5.164 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
   5.165 -	LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
   5.166 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   5.167 +        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
   5.168  
   5.169      public:
   5.170        typedef V Value;
   5.171 @@ -1504,7 +1504,7 @@
   5.172                       true> > {
   5.173  #endif
   5.174      typedef DigraphAdaptorExtender<
   5.175 -      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, 
   5.176 +      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
   5.177                       true> > Parent;
   5.178  
   5.179    public:
   5.180 @@ -1525,7 +1525,7 @@
   5.181      ///
   5.182      /// Creates a subgraph for the given digraph or graph with the
   5.183      /// given node filter map.
   5.184 -    FilterNodes(GR& graph, NF& node_filter) 
   5.185 +    FilterNodes(GR& graph, NF& node_filter)
   5.186        : Parent(), const_true_map()
   5.187      {
   5.188        Parent::initialize(graph, node_filter, const_true_map);
   5.189 @@ -1563,11 +1563,11 @@
   5.190    class FilterNodes<GR, NF,
   5.191                      typename enable_if<UndirectedTagIndicator<GR> >::type> :
   5.192      public GraphAdaptorExtender<
   5.193 -      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
   5.194 +      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
   5.195                     true> > {
   5.196  
   5.197      typedef GraphAdaptorExtender<
   5.198 -      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
   5.199 +      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
   5.200                     true> > Parent;
   5.201  
   5.202    public:
   5.203 @@ -1653,7 +1653,7 @@
   5.204                       AF, false> > {
   5.205  #endif
   5.206      typedef DigraphAdaptorExtender<
   5.207 -      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, 
   5.208 +      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
   5.209                       AF, false> > Parent;
   5.210  
   5.211    public:
   5.212 @@ -1761,11 +1761,11 @@
   5.213             typename EF = typename GR::template EdgeMap<bool> >
   5.214    class FilterEdges :
   5.215      public GraphAdaptorExtender<
   5.216 -      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >, 
   5.217 +      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
   5.218                     EF, false> > {
   5.219  #endif
   5.220      typedef GraphAdaptorExtender<
   5.221 -      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >, 
   5.222 +      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
   5.223                     EF, false> > Parent;
   5.224  
   5.225    public:
   5.226 @@ -1790,7 +1790,7 @@
   5.227      ///
   5.228      /// Creates a subgraph for the given graph with the given edge
   5.229      /// filter map.
   5.230 -    FilterEdges(GR& graph, EF& edge_filter) 
   5.231 +    FilterEdges(GR& graph, EF& edge_filter)
   5.232        : Parent(), const_true_map() {
   5.233        Parent::initialize(graph, const_true_map, edge_filter);
   5.234      }
   5.235 @@ -1858,7 +1858,7 @@
   5.236        Edge _edge;
   5.237        bool _forward;
   5.238  
   5.239 -      Arc(const Edge& edge, bool forward) 
   5.240 +      Arc(const Edge& edge, bool forward)
   5.241          : _edge(edge), _forward(forward) {}
   5.242  
   5.243      public:
   5.244 @@ -2098,7 +2098,7 @@
   5.245          _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
   5.246  
   5.247        ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
   5.248 -        : _forward(*adaptor._digraph, value), 
   5.249 +        : _forward(*adaptor._digraph, value),
   5.250            _backward(*adaptor._digraph, value) {}
   5.251  
   5.252        void set(const Arc& a, const V& value) {
   5.253 @@ -2216,7 +2216,7 @@
   5.254  
   5.255      typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
   5.256      EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
   5.257 -    
   5.258 +
   5.259      typedef EdgeNotifier ArcNotifier;
   5.260      ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
   5.261  
   5.262 @@ -2728,7 +2728,7 @@
   5.263             typename CM = typename DGR::template ArcMap<int>,
   5.264             typename FM = CM,
   5.265             typename TL = Tolerance<typename CM::Value> >
   5.266 -  class ResidualDigraph 
   5.267 +  class ResidualDigraph
   5.268      : public SubDigraph<
   5.269          Undirector<const DGR>,
   5.270          ConstMap<typename DGR::Node, Const<bool, true> >,
   5.271 @@ -2785,7 +2785,7 @@
   5.272      /// digraph, the capacity map, the flow map, and a tolerance object.
   5.273      ResidualDigraph(const DGR& digraph, const CM& capacity,
   5.274                      FM& flow, const TL& tolerance = Tolerance())
   5.275 -      : Parent(), _capacity(&capacity), _flow(&flow), 
   5.276 +      : Parent(), _capacity(&capacity), _flow(&flow),
   5.277          _graph(digraph), _node_filter(),
   5.278          _forward_filter(capacity, flow, tolerance),
   5.279          _backward_filter(capacity, flow, tolerance),
   5.280 @@ -2867,7 +2867,7 @@
   5.281        typedef typename CapacityMap::Value Value;
   5.282  
   5.283        /// Constructor
   5.284 -      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor) 
   5.285 +      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
   5.286          : _adaptor(&adaptor) {}
   5.287  
   5.288        /// Returns the value associated with the given residual arc
   5.289 @@ -3447,7 +3447,7 @@
   5.290      /// This map adaptor class adapts two node maps of the original digraph
   5.291      /// to get a node map of the split digraph.
   5.292      /// Its value type is inherited from the first node map type (\c IN).
   5.293 -    /// \tparam IN The type of the node map for the in-nodes. 
   5.294 +    /// \tparam IN The type of the node map for the in-nodes.
   5.295      /// \tparam OUT The type of the node map for the out-nodes.
   5.296      template <typename IN, typename OUT>
   5.297      class CombinedNodeMap {
     6.1 --- a/lemon/arg_parser.cc	Wed Mar 17 12:35:52 2010 +0100
     6.2 +++ b/lemon/arg_parser.cc	Sat Mar 06 14:35:12 2010 +0000
     6.3 @@ -2,7 +2,7 @@
     6.4   *
     6.5   * This file is a part of LEMON, a generic C++ optimization library.
     6.6   *
     6.7 - * Copyright (C) 2003-2009
     6.8 + * Copyright (C) 2003-2010
     6.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    6.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    6.11   *
    6.12 @@ -26,8 +26,8 @@
    6.13        exit(1);
    6.14      else throw(ArgParserException(reason));
    6.15    }
    6.16 -  
    6.17 -  
    6.18 +
    6.19 +
    6.20    void ArgParser::_showHelp(void *p)
    6.21    {
    6.22      (static_cast<ArgParser*>(p))->showHelp();
     7.1 --- a/lemon/arg_parser.h	Wed Mar 17 12:35:52 2010 +0100
     7.2 +++ b/lemon/arg_parser.h	Sat Mar 06 14:35:12 2010 +0000
     7.3 @@ -2,7 +2,7 @@
     7.4   *
     7.5   * This file is a part of LEMON, a generic C++ optimization library.
     7.6   *
     7.7 - * Copyright (C) 2003-2009
     7.8 + * Copyright (C) 2003-2010
     7.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    7.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    7.11   *
    7.12 @@ -42,10 +42,10 @@
    7.13        UNKNOWN_OPT,  /// Unknown option was given
    7.14        INVALID_OPT   /// Invalid combination of options
    7.15      };
    7.16 -    
    7.17 +
    7.18    private:
    7.19      Reason _reason;
    7.20 -    
    7.21 +
    7.22    public:
    7.23      ///Constructor
    7.24      ArgParserException(Reason r) throw() : _reason(r) {}
    7.25 @@ -141,7 +141,7 @@
    7.26      std::vector<std::string> _file_args;
    7.27      std::string _command_name;
    7.28  
    7.29 -    
    7.30 +
    7.31    private:
    7.32      //Bind a function to an option.
    7.33  
    7.34 @@ -155,7 +155,7 @@
    7.35                      void (*func)(void *),void *data);
    7.36  
    7.37      bool _exit_on_problems;
    7.38 -    
    7.39 +
    7.40      void _terminate(ArgParserException::Reason reason) const;
    7.41  
    7.42    public:
    7.43 @@ -423,7 +423,7 @@
    7.44      const std::vector<std::string> &files() const { return _file_args; }
    7.45  
    7.46      ///Throw instead of exit in case of problems
    7.47 -    void throwOnProblems() 
    7.48 +    void throwOnProblems()
    7.49      {
    7.50        _exit_on_problems=false;
    7.51      }
     8.1 --- a/lemon/bellman_ford.h	Wed Mar 17 12:35:52 2010 +0100
     8.2 +++ b/lemon/bellman_ford.h	Sat Mar 06 14:35:12 2010 +0000
     8.3 @@ -1,8 +1,8 @@
     8.4 -/* -*- C++ -*-
     8.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
     8.6   *
     8.7 - * This file is a part of LEMON, a generic C++ optimization library
     8.8 + * This file is a part of LEMON, a generic C++ optimization library.
     8.9   *
    8.10 - * Copyright (C) 2003-2008
    8.11 + * Copyright (C) 2003-2010
    8.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    8.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    8.14   *
    8.15 @@ -36,7 +36,7 @@
    8.16  namespace lemon {
    8.17  
    8.18    /// \brief Default operation traits for the BellmanFord algorithm class.
    8.19 -  ///  
    8.20 +  ///
    8.21    /// This operation traits class defines all computational operations
    8.22    /// and constants that are used in the Bellman-Ford algorithm.
    8.23    /// The default implementation is based on the \c numeric_limits class.
    8.24 @@ -45,7 +45,7 @@
    8.25    ///
    8.26    /// \see BellmanFordToleranceOperationTraits
    8.27    template <
    8.28 -    typename V, 
    8.29 +    typename V,
    8.30      bool has_inf = std::numeric_limits<V>::has_infinity>
    8.31    struct BellmanFordDefaultOperationTraits {
    8.32      /// \brief Value type for the algorithm.
    8.33 @@ -86,7 +86,7 @@
    8.34        return left < right;
    8.35      }
    8.36    };
    8.37 -  
    8.38 +
    8.39    /// \brief Operation traits for the BellmanFord algorithm class
    8.40    /// using tolerance.
    8.41    ///
    8.42 @@ -139,7 +139,7 @@
    8.43    /// \param LEN The type of the length map.
    8.44    template<typename GR, typename LEN>
    8.45    struct BellmanFordDefaultTraits {
    8.46 -    /// The type of the digraph the algorithm runs on. 
    8.47 +    /// The type of the digraph the algorithm runs on.
    8.48      typedef GR Digraph;
    8.49  
    8.50      /// \brief The type of the map that stores the arc lengths.
    8.51 @@ -158,18 +158,18 @@
    8.52      /// \see BellmanFordDefaultOperationTraits,
    8.53      /// BellmanFordToleranceOperationTraits
    8.54      typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
    8.55 - 
    8.56 -    /// \brief The type of the map that stores the last arcs of the 
    8.57 +
    8.58 +    /// \brief The type of the map that stores the last arcs of the
    8.59      /// shortest paths.
    8.60 -    /// 
    8.61 +    ///
    8.62      /// The type of the map that stores the last
    8.63      /// arcs of the shortest paths.
    8.64      /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
    8.65      typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
    8.66  
    8.67      /// \brief Instantiates a \c PredMap.
    8.68 -    /// 
    8.69 -    /// This function instantiates a \ref PredMap. 
    8.70 +    ///
    8.71 +    /// This function instantiates a \ref PredMap.
    8.72      /// \param g is the digraph to which we would like to define the
    8.73      /// \ref PredMap.
    8.74      static PredMap *createPredMap(const GR& g) {
    8.75 @@ -184,19 +184,19 @@
    8.76  
    8.77      /// \brief Instantiates a \c DistMap.
    8.78      ///
    8.79 -    /// This function instantiates a \ref DistMap. 
    8.80 -    /// \param g is the digraph to which we would like to define the 
    8.81 +    /// This function instantiates a \ref DistMap.
    8.82 +    /// \param g is the digraph to which we would like to define the
    8.83      /// \ref DistMap.
    8.84      static DistMap *createDistMap(const GR& g) {
    8.85        return new DistMap(g);
    8.86      }
    8.87  
    8.88    };
    8.89 -  
    8.90 +
    8.91    /// \brief %BellmanFord algorithm class.
    8.92    ///
    8.93    /// \ingroup shortest_path
    8.94 -  /// This class provides an efficient implementation of the Bellman-Ford 
    8.95 +  /// This class provides an efficient implementation of the Bellman-Ford
    8.96    /// algorithm. The maximum time complexity of the algorithm is
    8.97    /// <tt>O(ne)</tt>.
    8.98    ///
    8.99 @@ -207,7 +207,7 @@
   8.100    /// algorithm instead, since it is more efficient.
   8.101    ///
   8.102    /// The arc lengths are passed to the algorithm using a
   8.103 -  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
   8.104 +  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
   8.105    /// kind of length. The type of the length values is determined by the
   8.106    /// \ref concepts::ReadMap::Value "Value" type of the length map.
   8.107    ///
   8.108 @@ -237,7 +237,7 @@
   8.109  
   8.110      ///The type of the underlying digraph.
   8.111      typedef typename TR::Digraph Digraph;
   8.112 -    
   8.113 +
   8.114      /// \brief The type of the arc lengths.
   8.115      typedef typename TR::LengthMap::Value Value;
   8.116      /// \brief The type of the map that stores the arc lengths.
   8.117 @@ -284,20 +284,20 @@
   8.118      // Creates the maps if necessary.
   8.119      void create_maps() {
   8.120        if(!_pred) {
   8.121 -	_local_pred = true;
   8.122 -	_pred = Traits::createPredMap(*_gr);
   8.123 +        _local_pred = true;
   8.124 +        _pred = Traits::createPredMap(*_gr);
   8.125        }
   8.126        if(!_dist) {
   8.127 -	_local_dist = true;
   8.128 -	_dist = Traits::createDistMap(*_gr);
   8.129 +        _local_dist = true;
   8.130 +        _dist = Traits::createDistMap(*_gr);
   8.131        }
   8.132        if(!_mask) {
   8.133          _mask = new MaskMap(*_gr);
   8.134        }
   8.135      }
   8.136 -    
   8.137 +
   8.138    public :
   8.139 - 
   8.140 +
   8.141      typedef BellmanFord Create;
   8.142  
   8.143      /// \name Named Template Parameters
   8.144 @@ -320,11 +320,11 @@
   8.145      /// \c PredMap type.
   8.146      /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
   8.147      template <class T>
   8.148 -    struct SetPredMap 
   8.149 +    struct SetPredMap
   8.150        : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
   8.151        typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
   8.152      };
   8.153 -    
   8.154 +
   8.155      template <class T>
   8.156      struct SetDistMapTraits : public Traits {
   8.157        typedef T DistMap;
   8.158 @@ -341,7 +341,7 @@
   8.159      /// \c DistMap type.
   8.160      /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
   8.161      template <class T>
   8.162 -    struct SetDistMap 
   8.163 +    struct SetDistMap
   8.164        : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
   8.165        typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
   8.166      };
   8.167 @@ -350,8 +350,8 @@
   8.168      struct SetOperationTraitsTraits : public Traits {
   8.169        typedef T OperationTraits;
   8.170      };
   8.171 -    
   8.172 -    /// \brief \ref named-templ-param "Named parameter" for setting 
   8.173 +
   8.174 +    /// \brief \ref named-templ-param "Named parameter" for setting
   8.175      /// \c OperationTraits type.
   8.176      ///
   8.177      /// \ref named-templ-param "Named parameter" for setting
   8.178 @@ -363,15 +363,15 @@
   8.179        typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> >
   8.180        Create;
   8.181      };
   8.182 -    
   8.183 +
   8.184      ///@}
   8.185  
   8.186    protected:
   8.187 -    
   8.188 +
   8.189      BellmanFord() {}
   8.190  
   8.191 -  public:      
   8.192 -    
   8.193 +  public:
   8.194 +
   8.195      /// \brief Constructor.
   8.196      ///
   8.197      /// Constructor.
   8.198 @@ -381,7 +381,7 @@
   8.199        _gr(&g), _length(&length),
   8.200        _pred(0), _local_pred(false),
   8.201        _dist(0), _local_dist(false), _mask(0) {}
   8.202 -    
   8.203 +
   8.204      ///Destructor.
   8.205      ~BellmanFord() {
   8.206        if(_local_pred) delete _pred;
   8.207 @@ -408,8 +408,8 @@
   8.208      /// \return <tt>(*this)</tt>
   8.209      BellmanFord &predMap(PredMap &map) {
   8.210        if(_local_pred) {
   8.211 -	delete _pred;
   8.212 -	_local_pred=false;
   8.213 +        delete _pred;
   8.214 +        _local_pred=false;
   8.215        }
   8.216        _pred = &map;
   8.217        return *this;
   8.218 @@ -426,8 +426,8 @@
   8.219      /// \return <tt>(*this)</tt>
   8.220      BellmanFord &distMap(DistMap &map) {
   8.221        if(_local_dist) {
   8.222 -	delete _dist;
   8.223 -	_local_dist=false;
   8.224 +        delete _dist;
   8.225 +        _local_dist=false;
   8.226        }
   8.227        _dist = &map;
   8.228        return *this;
   8.229 @@ -445,28 +445,28 @@
   8.230      ///@{
   8.231  
   8.232      /// \brief Initializes the internal data structures.
   8.233 -    /// 
   8.234 +    ///
   8.235      /// Initializes the internal data structures. The optional parameter
   8.236      /// is the initial distance of each node.
   8.237      void init(const Value value = OperationTraits::infinity()) {
   8.238        create_maps();
   8.239        for (NodeIt it(*_gr); it != INVALID; ++it) {
   8.240 -	_pred->set(it, INVALID);
   8.241 -	_dist->set(it, value);
   8.242 +        _pred->set(it, INVALID);
   8.243 +        _dist->set(it, value);
   8.244        }
   8.245        _process.clear();
   8.246        if (OperationTraits::less(value, OperationTraits::infinity())) {
   8.247 -	for (NodeIt it(*_gr); it != INVALID; ++it) {
   8.248 -	  _process.push_back(it);
   8.249 -	  _mask->set(it, true);
   8.250 -	}
   8.251 +        for (NodeIt it(*_gr); it != INVALID; ++it) {
   8.252 +          _process.push_back(it);
   8.253 +          _mask->set(it, true);
   8.254 +        }
   8.255        } else {
   8.256 -	for (NodeIt it(*_gr); it != INVALID; ++it) {
   8.257 -	  _mask->set(it, false);
   8.258 -	}
   8.259 +        for (NodeIt it(*_gr); it != INVALID; ++it) {
   8.260 +          _mask->set(it, false);
   8.261 +        }
   8.262        }
   8.263      }
   8.264 -    
   8.265 +
   8.266      /// \brief Adds a new source node.
   8.267      ///
   8.268      /// This function adds a new source node. The optional second parameter
   8.269 @@ -474,8 +474,8 @@
   8.270      void addSource(Node source, Value dst = OperationTraits::zero()) {
   8.271        _dist->set(source, dst);
   8.272        if (!(*_mask)[source]) {
   8.273 -	_process.push_back(source);
   8.274 -	_mask->set(source, true);
   8.275 +        _process.push_back(source);
   8.276 +        _mask->set(source, true);
   8.277        }
   8.278      }
   8.279  
   8.280 @@ -500,26 +500,26 @@
   8.281      /// \see ActiveIt
   8.282      bool processNextRound() {
   8.283        for (int i = 0; i < int(_process.size()); ++i) {
   8.284 -	_mask->set(_process[i], false);
   8.285 +        _mask->set(_process[i], false);
   8.286        }
   8.287        std::vector<Node> nextProcess;
   8.288        std::vector<Value> values(_process.size());
   8.289        for (int i = 0; i < int(_process.size()); ++i) {
   8.290 -	values[i] = (*_dist)[_process[i]];
   8.291 +        values[i] = (*_dist)[_process[i]];
   8.292        }
   8.293        for (int i = 0; i < int(_process.size()); ++i) {
   8.294 -	for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
   8.295 -	  Node target = _gr->target(it);
   8.296 -	  Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
   8.297 -	  if (OperationTraits::less(relaxed, (*_dist)[target])) {
   8.298 -	    _pred->set(target, it);
   8.299 -	    _dist->set(target, relaxed);
   8.300 -	    if (!(*_mask)[target]) {
   8.301 -	      _mask->set(target, true);
   8.302 -	      nextProcess.push_back(target);
   8.303 -	    }
   8.304 -	  }	  
   8.305 -	}
   8.306 +        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
   8.307 +          Node target = _gr->target(it);
   8.308 +          Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
   8.309 +          if (OperationTraits::less(relaxed, (*_dist)[target])) {
   8.310 +            _pred->set(target, it);
   8.311 +            _dist->set(target, relaxed);
   8.312 +            if (!(*_mask)[target]) {
   8.313 +              _mask->set(target, true);
   8.314 +              nextProcess.push_back(target);
   8.315 +            }
   8.316 +          }
   8.317 +        }
   8.318        }
   8.319        _process.swap(nextProcess);
   8.320        return _process.empty();
   8.321 @@ -541,23 +541,23 @@
   8.322      /// \see ActiveIt
   8.323      bool processNextWeakRound() {
   8.324        for (int i = 0; i < int(_process.size()); ++i) {
   8.325 -	_mask->set(_process[i], false);
   8.326 +        _mask->set(_process[i], false);
   8.327        }
   8.328        std::vector<Node> nextProcess;
   8.329        for (int i = 0; i < int(_process.size()); ++i) {
   8.330 -	for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
   8.331 -	  Node target = _gr->target(it);
   8.332 -	  Value relaxed = 
   8.333 -	    OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
   8.334 -	  if (OperationTraits::less(relaxed, (*_dist)[target])) {
   8.335 -	    _pred->set(target, it);
   8.336 -	    _dist->set(target, relaxed);
   8.337 -	    if (!(*_mask)[target]) {
   8.338 -	      _mask->set(target, true);
   8.339 -	      nextProcess.push_back(target);
   8.340 -	    }
   8.341 -	  }	  
   8.342 -	}
   8.343 +        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
   8.344 +          Node target = _gr->target(it);
   8.345 +          Value relaxed =
   8.346 +            OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
   8.347 +          if (OperationTraits::less(relaxed, (*_dist)[target])) {
   8.348 +            _pred->set(target, it);
   8.349 +            _dist->set(target, relaxed);
   8.350 +            if (!(*_mask)[target]) {
   8.351 +              _mask->set(target, true);
   8.352 +              nextProcess.push_back(target);
   8.353 +            }
   8.354 +          }
   8.355 +        }
   8.356        }
   8.357        _process.swap(nextProcess);
   8.358        return _process.empty();
   8.359 @@ -579,7 +579,7 @@
   8.360      void start() {
   8.361        int num = countNodes(*_gr) - 1;
   8.362        for (int i = 0; i < num; ++i) {
   8.363 -	if (processNextWeakRound()) break;
   8.364 +        if (processNextWeakRound()) break;
   8.365        }
   8.366      }
   8.367  
   8.368 @@ -591,18 +591,18 @@
   8.369      /// in order to compute the shortest path to each node and also checks
   8.370      /// if the digraph contains cycles with negative total length.
   8.371      ///
   8.372 -    /// The algorithm computes 
   8.373 +    /// The algorithm computes
   8.374      /// - the shortest path tree (forest),
   8.375      /// - the distance of each node from the root(s).
   8.376 -    /// 
   8.377 +    ///
   8.378      /// \return \c false if there is a negative cycle in the digraph.
   8.379      ///
   8.380      /// \pre init() must be called and at least one root node should be
   8.381 -    /// added with addSource() before using this function. 
   8.382 +    /// added with addSource() before using this function.
   8.383      bool checkedStart() {
   8.384        int num = countNodes(*_gr);
   8.385        for (int i = 0; i < num; ++i) {
   8.386 -	if (processNextWeakRound()) return true;
   8.387 +        if (processNextWeakRound()) return true;
   8.388        }
   8.389        return _process.empty();
   8.390      }
   8.391 @@ -626,15 +626,15 @@
   8.392      /// and build the path manually.
   8.393      ///
   8.394      /// \pre init() must be called and at least one root node should be
   8.395 -    /// added with addSource() before using this function. 
   8.396 +    /// added with addSource() before using this function.
   8.397      void limitedStart(int num) {
   8.398        for (int i = 0; i < num; ++i) {
   8.399 -	if (processNextRound()) break;
   8.400 +        if (processNextRound()) break;
   8.401        }
   8.402      }
   8.403 -    
   8.404 +
   8.405      /// \brief Runs the algorithm from the given root node.
   8.406 -    ///    
   8.407 +    ///
   8.408      /// This method runs the Bellman-Ford algorithm from the given root
   8.409      /// node \c s in order to compute the shortest path to each node.
   8.410      ///
   8.411 @@ -653,10 +653,10 @@
   8.412        addSource(s);
   8.413        start();
   8.414      }
   8.415 -    
   8.416 +
   8.417      /// \brief Runs the algorithm from the given root node with arc
   8.418      /// number limit.
   8.419 -    ///    
   8.420 +    ///
   8.421      /// This method runs the Bellman-Ford algorithm from the given root
   8.422      /// node \c s in order to compute the shortest path distance for each
   8.423      /// node using only the paths consisting of at most \c num arcs.
   8.424 @@ -682,7 +682,7 @@
   8.425        addSource(s);
   8.426        limitedStart(num);
   8.427      }
   8.428 -    
   8.429 +
   8.430      ///@}
   8.431  
   8.432      /// \brief LEMON iterator for getting the active nodes.
   8.433 @@ -697,7 +697,7 @@
   8.434        /// \brief Constructor.
   8.435        ///
   8.436        /// Constructor for getting the active nodes of the given BellmanFord
   8.437 -      /// instance. 
   8.438 +      /// instance.
   8.439        ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
   8.440        {
   8.441          _index = _algorithm->_process.size() - 1;
   8.442 @@ -711,7 +711,7 @@
   8.443        /// \brief Conversion to \c Node.
   8.444        ///
   8.445        /// Conversion to \c Node.
   8.446 -      operator Node() const { 
   8.447 +      operator Node() const {
   8.448          return _index >= 0 ? _algorithm->_process[_index] : INVALID;
   8.449        }
   8.450  
   8.451 @@ -720,33 +720,33 @@
   8.452        /// Increment operator.
   8.453        ActiveIt& operator++() {
   8.454          --_index;
   8.455 -        return *this; 
   8.456 +        return *this;
   8.457        }
   8.458  
   8.459 -      bool operator==(const ActiveIt& it) const { 
   8.460 -        return static_cast<Node>(*this) == static_cast<Node>(it); 
   8.461 +      bool operator==(const ActiveIt& it) const {
   8.462 +        return static_cast<Node>(*this) == static_cast<Node>(it);
   8.463        }
   8.464 -      bool operator!=(const ActiveIt& it) const { 
   8.465 -        return static_cast<Node>(*this) != static_cast<Node>(it); 
   8.466 +      bool operator!=(const ActiveIt& it) const {
   8.467 +        return static_cast<Node>(*this) != static_cast<Node>(it);
   8.468        }
   8.469 -      bool operator<(const ActiveIt& it) const { 
   8.470 -        return static_cast<Node>(*this) < static_cast<Node>(it); 
   8.471 +      bool operator<(const ActiveIt& it) const {
   8.472 +        return static_cast<Node>(*this) < static_cast<Node>(it);
   8.473        }
   8.474 -      
   8.475 +
   8.476      private:
   8.477        const BellmanFord* _algorithm;
   8.478        int _index;
   8.479      };
   8.480 -    
   8.481 +
   8.482      /// \name Query Functions
   8.483      /// The result of the Bellman-Ford algorithm can be obtained using these
   8.484      /// functions.\n
   8.485      /// Either \ref run() or \ref init() should be called before using them.
   8.486 -    
   8.487 +
   8.488      ///@{
   8.489  
   8.490      /// \brief The shortest path to the given node.
   8.491 -    ///    
   8.492 +    ///
   8.493      /// Gives back the shortest path to the given node from the root(s).
   8.494      ///
   8.495      /// \warning \c t should be reached from the root(s).
   8.496 @@ -757,7 +757,7 @@
   8.497      {
   8.498        return Path(*_gr, *_pred, t);
   8.499      }
   8.500 -	  
   8.501 +
   8.502      /// \brief The distance of the given node from the root(s).
   8.503      ///
   8.504      /// Returns the distance of the given node from the root(s).
   8.505 @@ -797,10 +797,10 @@
   8.506      ///
   8.507      /// \pre Either \ref run() or \ref init() must be called before
   8.508      /// using this function.
   8.509 -    Node predNode(Node v) const { 
   8.510 -      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]); 
   8.511 +    Node predNode(Node v) const {
   8.512 +      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
   8.513      }
   8.514 -    
   8.515 +
   8.516      /// \brief Returns a const reference to the node map that stores the
   8.517      /// distances of the nodes.
   8.518      ///
   8.519 @@ -810,7 +810,7 @@
   8.520      /// \pre Either \ref run() or \ref init() must be called before
   8.521      /// using this function.
   8.522      const DistMap &distMap() const { return *_dist;}
   8.523 - 
   8.524 +
   8.525      /// \brief Returns a const reference to the node map that stores the
   8.526      /// predecessor arcs.
   8.527      ///
   8.528 @@ -820,7 +820,7 @@
   8.529      /// \pre Either \ref run() or \ref init() must be called before
   8.530      /// using this function.
   8.531      const PredMap &predMap() const { return *_pred; }
   8.532 - 
   8.533 +
   8.534      /// \brief Checks if a node is reached from the root(s).
   8.535      ///
   8.536      /// Returns \c true if \c v is reached from the root(s).
   8.537 @@ -832,7 +832,7 @@
   8.538      }
   8.539  
   8.540      /// \brief Gives back a negative cycle.
   8.541 -    ///    
   8.542 +    ///
   8.543      /// This function gives back a directed cycle with negative total
   8.544      /// length if the algorithm has already found one.
   8.545      /// Otherwise it gives back an empty path.
   8.546 @@ -859,10 +859,10 @@
   8.547        }
   8.548        return cycle;
   8.549      }
   8.550 -    
   8.551 +
   8.552      ///@}
   8.553    };
   8.554 - 
   8.555 +
   8.556    /// \brief Default traits class of bellmanFord() function.
   8.557    ///
   8.558    /// Default traits class of bellmanFord() function.
   8.559 @@ -870,7 +870,7 @@
   8.560    /// \tparam LEN The type of the length map.
   8.561    template <typename GR, typename LEN>
   8.562    struct BellmanFordWizardDefaultTraits {
   8.563 -    /// The type of the digraph the algorithm runs on. 
   8.564 +    /// The type of the digraph the algorithm runs on.
   8.565      typedef GR Digraph;
   8.566  
   8.567      /// \brief The type of the map that stores the arc lengths.
   8.568 @@ -892,13 +892,13 @@
   8.569  
   8.570      /// \brief The type of the map that stores the last
   8.571      /// arcs of the shortest paths.
   8.572 -    /// 
   8.573 +    ///
   8.574      /// The type of the map that stores the last arcs of the shortest paths.
   8.575      /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
   8.576      typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
   8.577  
   8.578      /// \brief Instantiates a \c PredMap.
   8.579 -    /// 
   8.580 +    ///
   8.581      /// This function instantiates a \ref PredMap.
   8.582      /// \param g is the digraph to which we would like to define the
   8.583      /// \ref PredMap.
   8.584 @@ -914,7 +914,7 @@
   8.585  
   8.586      /// \brief Instantiates a \c DistMap.
   8.587      ///
   8.588 -    /// This function instantiates a \ref DistMap. 
   8.589 +    /// This function instantiates a \ref DistMap.
   8.590      /// \param g is the digraph to which we would like to define the
   8.591      /// \ref DistMap.
   8.592      static DistMap *createDistMap(const GR &g) {
   8.593 @@ -927,14 +927,14 @@
   8.594      ///It must meet the \ref concepts::Path "Path" concept.
   8.595      typedef lemon::Path<Digraph> Path;
   8.596    };
   8.597 -  
   8.598 +
   8.599    /// \brief Default traits class used by BellmanFordWizard.
   8.600    ///
   8.601    /// Default traits class used by BellmanFordWizard.
   8.602    /// \tparam GR The type of the digraph.
   8.603    /// \tparam LEN The type of the length map.
   8.604    template <typename GR, typename LEN>
   8.605 -  class BellmanFordWizardBase 
   8.606 +  class BellmanFordWizardBase
   8.607      : public BellmanFordWizardDefaultTraits<GR, LEN> {
   8.608  
   8.609      typedef BellmanFordWizardDefaultTraits<GR, LEN> Base;
   8.610 @@ -957,26 +957,26 @@
   8.611  
   8.612      public:
   8.613      /// Constructor.
   8.614 -    
   8.615 +
   8.616      /// This constructor does not require parameters, it initiates
   8.617      /// all of the attributes to default values \c 0.
   8.618      BellmanFordWizardBase() :
   8.619        _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {}
   8.620  
   8.621      /// Constructor.
   8.622 -    
   8.623 +
   8.624      /// This constructor requires two parameters,
   8.625      /// others are initiated to \c 0.
   8.626      /// \param gr The digraph the algorithm runs on.
   8.627      /// \param len The length map.
   8.628 -    BellmanFordWizardBase(const GR& gr, 
   8.629 -			  const LEN& len) :
   8.630 -      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))), 
   8.631 -      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))), 
   8.632 +    BellmanFordWizardBase(const GR& gr,
   8.633 +                          const LEN& len) :
   8.634 +      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))),
   8.635 +      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))),
   8.636        _pred(0), _dist(0), _path(0), _di(0) {}
   8.637  
   8.638    };
   8.639 -  
   8.640 +
   8.641    /// \brief Auxiliary class for the function-type interface of the
   8.642    /// \ref BellmanFord "Bellman-Ford" algorithm.
   8.643    ///
   8.644 @@ -1001,7 +1001,7 @@
   8.645      typedef typename Digraph::NodeIt NodeIt;
   8.646      typedef typename Digraph::Arc Arc;
   8.647      typedef typename Digraph::OutArcIt ArcIt;
   8.648 -    
   8.649 +
   8.650      typedef typename TR::LengthMap LengthMap;
   8.651      typedef typename LengthMap::Value Value;
   8.652      typedef typename TR::PredMap PredMap;
   8.653 @@ -1018,7 +1018,7 @@
   8.654      /// These parameters will be the default values for the traits class.
   8.655      /// \param gr The digraph the algorithm runs on.
   8.656      /// \param len The length map.
   8.657 -    BellmanFordWizard(const Digraph& gr, const LengthMap& len) 
   8.658 +    BellmanFordWizard(const Digraph& gr, const LengthMap& len)
   8.659        : TR(gr, len) {}
   8.660  
   8.661      /// \brief Copy constructor
   8.662 @@ -1027,12 +1027,12 @@
   8.663      ~BellmanFordWizard() {}
   8.664  
   8.665      /// \brief Runs the Bellman-Ford algorithm from the given source node.
   8.666 -    ///    
   8.667 +    ///
   8.668      /// This method runs the Bellman-Ford algorithm from the given source
   8.669      /// node in order to compute the shortest path to each node.
   8.670      void run(Node s) {
   8.671 -      BellmanFord<Digraph,LengthMap,TR> 
   8.672 -	bf(*reinterpret_cast<const Digraph*>(Base::_graph), 
   8.673 +      BellmanFord<Digraph,LengthMap,TR>
   8.674 +        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
   8.675             *reinterpret_cast<const LengthMap*>(Base::_length));
   8.676        if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
   8.677        if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
   8.678 @@ -1067,7 +1067,7 @@
   8.679        static PredMap *createPredMap(const Digraph &) { return 0; };
   8.680        SetPredMapBase(const TR &b) : TR(b) {}
   8.681      };
   8.682 -    
   8.683 +
   8.684      /// \brief \ref named-templ-param "Named parameter" for setting
   8.685      /// the predecessor map.
   8.686      ///
   8.687 @@ -1078,14 +1078,14 @@
   8.688        Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
   8.689        return BellmanFordWizard<SetPredMapBase<T> >(*this);
   8.690      }
   8.691 -    
   8.692 +
   8.693      template<class T>
   8.694      struct SetDistMapBase : public Base {
   8.695        typedef T DistMap;
   8.696        static DistMap *createDistMap(const Digraph &) { return 0; };
   8.697        SetDistMapBase(const TR &b) : TR(b) {}
   8.698      };
   8.699 -    
   8.700 +
   8.701      /// \brief \ref named-templ-param "Named parameter" for setting
   8.702      /// the distance map.
   8.703      ///
   8.704 @@ -1126,9 +1126,9 @@
   8.705        Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
   8.706        return *this;
   8.707      }
   8.708 -    
   8.709 +
   8.710    };
   8.711 -  
   8.712 +
   8.713    /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
   8.714    /// algorithm.
   8.715    ///
   8.716 @@ -1136,8 +1136,8 @@
   8.717    /// Function type interface for the \ref BellmanFord "Bellman-Ford"
   8.718    /// algorithm.
   8.719    ///
   8.720 -  /// This function also has several \ref named-templ-func-param 
   8.721 -  /// "named parameters", they are declared as the members of class 
   8.722 +  /// This function also has several \ref named-templ-func-param
   8.723 +  /// "named parameters", they are declared as the members of class
   8.724    /// \ref BellmanFordWizard.
   8.725    /// The following examples show how to use these parameters.
   8.726    /// \code
   8.727 @@ -1154,7 +1154,7 @@
   8.728    template<typename GR, typename LEN>
   8.729    BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
   8.730    bellmanFord(const GR& digraph,
   8.731 -	      const LEN& length)
   8.732 +              const LEN& length)
   8.733    {
   8.734      return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);
   8.735    }
     9.1 --- a/lemon/bfs.h	Wed Mar 17 12:35:52 2010 +0100
     9.2 +++ b/lemon/bfs.h	Sat Mar 06 14:35:12 2010 +0000
     9.3 @@ -2,7 +2,7 @@
     9.4   *
     9.5   * This file is a part of LEMON, a generic C++ optimization library.
     9.6   *
     9.7 - * Copyright (C) 2003-2009
     9.8 + * Copyright (C) 2003-2010
     9.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    9.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    9.11   *
    9.12 @@ -82,7 +82,8 @@
    9.13      ///The type of the map that indicates which nodes are reached.
    9.14  
    9.15      ///The type of the map that indicates which nodes are reached.
    9.16 -    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.17 +    ///It must conform to
    9.18 +    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.19      typedef typename Digraph::template NodeMap<bool> ReachedMap;
    9.20      ///Instantiates a \c ReachedMap.
    9.21  
    9.22 @@ -271,7 +272,8 @@
    9.23      ///
    9.24      ///\ref named-templ-param "Named parameter" for setting
    9.25      ///\c ReachedMap type.
    9.26 -    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.27 +    ///It must conform to
    9.28 +    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.29      template <class T>
    9.30      struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
    9.31        typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
    9.32 @@ -872,7 +874,8 @@
    9.33      ///The type of the map that indicates which nodes are reached.
    9.34  
    9.35      ///The type of the map that indicates which nodes are reached.
    9.36 -    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.37 +    ///It must conform to
    9.38 +    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.39      typedef typename Digraph::template NodeMap<bool> ReachedMap;
    9.40      ///Instantiates a ReachedMap.
    9.41  
    9.42 @@ -1265,7 +1268,8 @@
    9.43      /// \brief The type of the map that indicates which nodes are reached.
    9.44      ///
    9.45      /// The type of the map that indicates which nodes are reached.
    9.46 -    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.47 +    /// It must conform to
    9.48 +    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    9.49      typedef typename Digraph::template NodeMap<bool> ReachedMap;
    9.50  
    9.51      /// \brief Instantiates a ReachedMap.
    10.1 --- a/lemon/binomial_heap.h	Wed Mar 17 12:35:52 2010 +0100
    10.2 +++ b/lemon/binomial_heap.h	Sat Mar 06 14:35:12 2010 +0000
    10.3 @@ -2,7 +2,7 @@
    10.4   *
    10.5   * This file is a part of LEMON, a generic C++ optimization library.
    10.6   *
    10.7 - * Copyright (C) 2003-2009
    10.8 + * Copyright (C) 2003-2010
    10.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   10.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   10.11   *
   10.12 @@ -258,7 +258,7 @@
   10.13        int i=_iim[item];
   10.14        int p=_data[i].parent;
   10.15        _data[i].prio=value;
   10.16 -      
   10.17 +
   10.18        while( p!=-1 && _comp(value, _data[p].prio) ) {
   10.19          _data[i].name=_data[p].name;
   10.20          _data[i].prio=_data[p].prio;
   10.21 @@ -322,7 +322,7 @@
   10.22      }
   10.23  
   10.24    private:
   10.25 -    
   10.26 +
   10.27      // Find the minimum of the roots
   10.28      int findMin() {
   10.29        if( _head!=-1 ) {
   10.30 @@ -350,7 +350,7 @@
   10.31          interleave(a);
   10.32        }
   10.33        if( _data[_head].right_neighbor==-1 ) return;
   10.34 -      
   10.35 +
   10.36        int x=_head;
   10.37        int x_prev=-1, x_next=_data[x].right_neighbor;
   10.38        while( x_next!=-1 ) {
   10.39 @@ -384,7 +384,7 @@
   10.40        int p=_head, q=a;
   10.41        int curr=_data.size();
   10.42        _data.push_back(Store());
   10.43 -      
   10.44 +
   10.45        while( p!=-1 || q!=-1 ) {
   10.46          if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
   10.47            _data[curr].right_neighbor=p;
   10.48 @@ -397,7 +397,7 @@
   10.49            q=_data[q].right_neighbor;
   10.50          }
   10.51        }
   10.52 -      
   10.53 +
   10.54        _head=_data.back().right_neighbor;
   10.55        _data.pop_back();
   10.56      }
    11.1 --- a/lemon/bits/array_map.h	Wed Mar 17 12:35:52 2010 +0100
    11.2 +++ b/lemon/bits/array_map.h	Sat Mar 06 14:35:12 2010 +0000
    11.3 @@ -2,7 +2,7 @@
    11.4   *
    11.5   * This file is a part of LEMON, a generic C++ optimization library.
    11.6   *
    11.7 - * Copyright (C) 2003-2009
    11.8 + * Copyright (C) 2003-2010
    11.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   11.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   11.11   *
   11.12 @@ -70,7 +70,7 @@
   11.13      typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
   11.14  
   11.15    private:
   11.16 -  
   11.17 +
   11.18      // The MapBase of the Map which imlements the core regisitry function.
   11.19      typedef typename Notifier::ObserverBase Parent;
   11.20  
    12.1 --- a/lemon/bits/default_map.h	Wed Mar 17 12:35:52 2010 +0100
    12.2 +++ b/lemon/bits/default_map.h	Sat Mar 06 14:35:12 2010 +0000
    12.3 @@ -2,7 +2,7 @@
    12.4   *
    12.5   * This file is a part of LEMON, a generic C++ optimization library.
    12.6   *
    12.7 - * Copyright (C) 2003-2009
    12.8 + * Copyright (C) 2003-2010
    12.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   12.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   12.11   *
   12.12 @@ -157,7 +157,7 @@
   12.13  
   12.14    public:
   12.15      typedef DefaultMap<_Graph, _Item, _Value> Map;
   12.16 -    
   12.17 +
   12.18      typedef typename Parent::GraphType GraphType;
   12.19      typedef typename Parent::Value Value;
   12.20  
    13.1 --- a/lemon/bits/edge_set_extender.h	Wed Mar 17 12:35:52 2010 +0100
    13.2 +++ b/lemon/bits/edge_set_extender.h	Sat Mar 06 14:35:12 2010 +0000
    13.3 @@ -1,8 +1,8 @@
    13.4 -/* -*- C++ -*-
    13.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    13.6   *
    13.7 - * This file is a part of LEMON, a generic C++ optimization library
    13.8 + * This file is a part of LEMON, a generic C++ optimization library.
    13.9   *
   13.10 - * Copyright (C) 2003-2008
   13.11 + * Copyright (C) 2003-2010
   13.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   13.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   13.14   *
   13.15 @@ -63,11 +63,11 @@
   13.16  
   13.17      Node oppositeNode(const Node &n, const Arc &e) const {
   13.18        if (n == Parent::source(e))
   13.19 -	return Parent::target(e);
   13.20 +        return Parent::target(e);
   13.21        else if(n==Parent::target(e))
   13.22 -	return Parent::source(e);
   13.23 +        return Parent::source(e);
   13.24        else
   13.25 -	return INVALID;
   13.26 +        return INVALID;
   13.27      }
   13.28  
   13.29  
   13.30 @@ -91,7 +91,7 @@
   13.31  
   13.32      // Iterable extensions
   13.33  
   13.34 -    class NodeIt : public Node { 
   13.35 +    class NodeIt : public Node {
   13.36        const Digraph* digraph;
   13.37      public:
   13.38  
   13.39 @@ -100,21 +100,21 @@
   13.40        NodeIt(Invalid i) : Node(i) { }
   13.41  
   13.42        explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
   13.43 -	_graph.first(static_cast<Node&>(*this));
   13.44 +        _graph.first(static_cast<Node&>(*this));
   13.45        }
   13.46  
   13.47 -      NodeIt(const Digraph& _graph, const Node& node) 
   13.48 -	: Node(node), digraph(&_graph) {}
   13.49 +      NodeIt(const Digraph& _graph, const Node& node)
   13.50 +        : Node(node), digraph(&_graph) {}
   13.51  
   13.52 -      NodeIt& operator++() { 
   13.53 -	digraph->next(*this);
   13.54 -	return *this; 
   13.55 +      NodeIt& operator++() {
   13.56 +        digraph->next(*this);
   13.57 +        return *this;
   13.58        }
   13.59  
   13.60      };
   13.61  
   13.62  
   13.63 -    class ArcIt : public Arc { 
   13.64 +    class ArcIt : public Arc {
   13.65        const Digraph* digraph;
   13.66      public:
   13.67  
   13.68 @@ -123,21 +123,21 @@
   13.69        ArcIt(Invalid i) : Arc(i) { }
   13.70  
   13.71        explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
   13.72 -	_graph.first(static_cast<Arc&>(*this));
   13.73 +        _graph.first(static_cast<Arc&>(*this));
   13.74        }
   13.75  
   13.76 -      ArcIt(const Digraph& _graph, const Arc& e) : 
   13.77 -	Arc(e), digraph(&_graph) { }
   13.78 +      ArcIt(const Digraph& _graph, const Arc& e) :
   13.79 +        Arc(e), digraph(&_graph) { }
   13.80  
   13.81 -      ArcIt& operator++() { 
   13.82 -	digraph->next(*this);
   13.83 -	return *this; 
   13.84 +      ArcIt& operator++() {
   13.85 +        digraph->next(*this);
   13.86 +        return *this;
   13.87        }
   13.88  
   13.89      };
   13.90  
   13.91  
   13.92 -    class OutArcIt : public Arc { 
   13.93 +    class OutArcIt : public Arc {
   13.94        const Digraph* digraph;
   13.95      public:
   13.96  
   13.97 @@ -145,23 +145,23 @@
   13.98  
   13.99        OutArcIt(Invalid i) : Arc(i) { }
  13.100  
  13.101 -      OutArcIt(const Digraph& _graph, const Node& node) 
  13.102 -	: digraph(&_graph) {
  13.103 -	_graph.firstOut(*this, node);
  13.104 +      OutArcIt(const Digraph& _graph, const Node& node)
  13.105 +        : digraph(&_graph) {
  13.106 +        _graph.firstOut(*this, node);
  13.107        }
  13.108  
  13.109 -      OutArcIt(const Digraph& _graph, const Arc& arc) 
  13.110 -	: Arc(arc), digraph(&_graph) {}
  13.111 +      OutArcIt(const Digraph& _graph, const Arc& arc)
  13.112 +        : Arc(arc), digraph(&_graph) {}
  13.113  
  13.114 -      OutArcIt& operator++() { 
  13.115 -	digraph->nextOut(*this);
  13.116 -	return *this; 
  13.117 +      OutArcIt& operator++() {
  13.118 +        digraph->nextOut(*this);
  13.119 +        return *this;
  13.120        }
  13.121  
  13.122      };
  13.123  
  13.124  
  13.125 -    class InArcIt : public Arc { 
  13.126 +    class InArcIt : public Arc {
  13.127        const Digraph* digraph;
  13.128      public:
  13.129  
  13.130 @@ -169,17 +169,17 @@
  13.131  
  13.132        InArcIt(Invalid i) : Arc(i) { }
  13.133  
  13.134 -      InArcIt(const Digraph& _graph, const Node& node) 
  13.135 -	: digraph(&_graph) {
  13.136 -	_graph.firstIn(*this, node);
  13.137 +      InArcIt(const Digraph& _graph, const Node& node)
  13.138 +        : digraph(&_graph) {
  13.139 +        _graph.firstIn(*this, node);
  13.140        }
  13.141  
  13.142 -      InArcIt(const Digraph& _graph, const Arc& arc) : 
  13.143 -	Arc(arc), digraph(&_graph) {}
  13.144 +      InArcIt(const Digraph& _graph, const Arc& arc) :
  13.145 +        Arc(arc), digraph(&_graph) {}
  13.146  
  13.147 -      InArcIt& operator++() { 
  13.148 -	digraph->nextIn(*this);
  13.149 -	return *this; 
  13.150 +      InArcIt& operator++() {
  13.151 +        digraph->nextIn(*this);
  13.152 +        return *this;
  13.153        }
  13.154  
  13.155      };
  13.156 @@ -215,26 +215,26 @@
  13.157      using Parent::first;
  13.158  
  13.159      // Mappable extension
  13.160 -    
  13.161 +
  13.162      template <typename _Value>
  13.163 -    class ArcMap 
  13.164 +    class ArcMap
  13.165        : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
  13.166        typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
  13.167  
  13.168      public:
  13.169 -      explicit ArcMap(const Digraph& _g) 
  13.170 -	: Parent(_g) {}
  13.171 -      ArcMap(const Digraph& _g, const _Value& _v) 
  13.172 -	: Parent(_g, _v) {}
  13.173 +      explicit ArcMap(const Digraph& _g)
  13.174 +        : Parent(_g) {}
  13.175 +      ArcMap(const Digraph& _g, const _Value& _v)
  13.176 +        : Parent(_g, _v) {}
  13.177  
  13.178        ArcMap& operator=(const ArcMap& cmap) {
  13.179 -	return operator=<ArcMap>(cmap);
  13.180 +        return operator=<ArcMap>(cmap);
  13.181        }
  13.182  
  13.183        template <typename CMap>
  13.184        ArcMap& operator=(const CMap& cmap) {
  13.185          Parent::operator=(cmap);
  13.186 -	return *this;
  13.187 +        return *this;
  13.188        }
  13.189  
  13.190      };
  13.191 @@ -247,7 +247,7 @@
  13.192        notifier(Arc()).add(arc);
  13.193        return arc;
  13.194      }
  13.195 -    
  13.196 +
  13.197      void clear() {
  13.198        notifier(Arc()).clear();
  13.199        Parent::clear();
  13.200 @@ -310,11 +310,11 @@
  13.201  
  13.202      Node oppositeNode(const Node &n, const Edge &e) const {
  13.203        if( n == Parent::u(e))
  13.204 -	return Parent::v(e);
  13.205 +        return Parent::v(e);
  13.206        else if( n == Parent::v(e))
  13.207 -	return Parent::u(e);
  13.208 +        return Parent::u(e);
  13.209        else
  13.210 -	return INVALID;
  13.211 +        return INVALID;
  13.212      }
  13.213  
  13.214      Arc oppositeArc(const Arc &e) const {
  13.215 @@ -338,7 +338,7 @@
  13.216    public:
  13.217  
  13.218      using Parent::notifier;
  13.219 -    
  13.220 +
  13.221      ArcNotifier& notifier(Arc) const {
  13.222        return arc_notifier;
  13.223      }
  13.224 @@ -348,7 +348,7 @@
  13.225      }
  13.226  
  13.227  
  13.228 -    class NodeIt : public Node { 
  13.229 +    class NodeIt : public Node {
  13.230        const Graph* graph;
  13.231      public:
  13.232  
  13.233 @@ -357,21 +357,21 @@
  13.234        NodeIt(Invalid i) : Node(i) { }
  13.235  
  13.236        explicit NodeIt(const Graph& _graph) : graph(&_graph) {
  13.237 -	_graph.first(static_cast<Node&>(*this));
  13.238 +        _graph.first(static_cast<Node&>(*this));
  13.239        }
  13.240  
  13.241 -      NodeIt(const Graph& _graph, const Node& node) 
  13.242 -	: Node(node), graph(&_graph) {}
  13.243 +      NodeIt(const Graph& _graph, const Node& node)
  13.244 +        : Node(node), graph(&_graph) {}
  13.245  
  13.246 -      NodeIt& operator++() { 
  13.247 -	graph->next(*this);
  13.248 -	return *this; 
  13.249 +      NodeIt& operator++() {
  13.250 +        graph->next(*this);
  13.251 +        return *this;
  13.252        }
  13.253  
  13.254      };
  13.255  
  13.256  
  13.257 -    class ArcIt : public Arc { 
  13.258 +    class ArcIt : public Arc {
  13.259        const Graph* graph;
  13.260      public:
  13.261  
  13.262 @@ -380,21 +380,21 @@
  13.263        ArcIt(Invalid i) : Arc(i) { }
  13.264  
  13.265        explicit ArcIt(const Graph& _graph) : graph(&_graph) {
  13.266 -	_graph.first(static_cast<Arc&>(*this));
  13.267 +        _graph.first(static_cast<Arc&>(*this));
  13.268        }
  13.269  
  13.270 -      ArcIt(const Graph& _graph, const Arc& e) : 
  13.271 -	Arc(e), graph(&_graph) { }
  13.272 +      ArcIt(const Graph& _graph, const Arc& e) :
  13.273 +        Arc(e), graph(&_graph) { }
  13.274  
  13.275 -      ArcIt& operator++() { 
  13.276 -	graph->next(*this);
  13.277 -	return *this; 
  13.278 +      ArcIt& operator++() {
  13.279 +        graph->next(*this);
  13.280 +        return *this;
  13.281        }
  13.282  
  13.283      };
  13.284  
  13.285  
  13.286 -    class OutArcIt : public Arc { 
  13.287 +    class OutArcIt : public Arc {
  13.288        const Graph* graph;
  13.289      public:
  13.290  
  13.291 @@ -402,23 +402,23 @@
  13.292  
  13.293        OutArcIt(Invalid i) : Arc(i) { }
  13.294  
  13.295 -      OutArcIt(const Graph& _graph, const Node& node) 
  13.296 -	: graph(&_graph) {
  13.297 -	_graph.firstOut(*this, node);
  13.298 +      OutArcIt(const Graph& _graph, const Node& node)
  13.299 +        : graph(&_graph) {
  13.300 +        _graph.firstOut(*this, node);
  13.301        }
  13.302  
  13.303 -      OutArcIt(const Graph& _graph, const Arc& arc) 
  13.304 -	: Arc(arc), graph(&_graph) {}
  13.305 +      OutArcIt(const Graph& _graph, const Arc& arc)
  13.306 +        : Arc(arc), graph(&_graph) {}
  13.307  
  13.308 -      OutArcIt& operator++() { 
  13.309 -	graph->nextOut(*this);
  13.310 -	return *this; 
  13.311 +      OutArcIt& operator++() {
  13.312 +        graph->nextOut(*this);
  13.313 +        return *this;
  13.314        }
  13.315  
  13.316      };
  13.317  
  13.318  
  13.319 -    class InArcIt : public Arc { 
  13.320 +    class InArcIt : public Arc {
  13.321        const Graph* graph;
  13.322      public:
  13.323  
  13.324 @@ -426,23 +426,23 @@
  13.325  
  13.326        InArcIt(Invalid i) : Arc(i) { }
  13.327  
  13.328 -      InArcIt(const Graph& _graph, const Node& node) 
  13.329 -	: graph(&_graph) {
  13.330 -	_graph.firstIn(*this, node);
  13.331 +      InArcIt(const Graph& _graph, const Node& node)
  13.332 +        : graph(&_graph) {
  13.333 +        _graph.firstIn(*this, node);
  13.334        }
  13.335  
  13.336 -      InArcIt(const Graph& _graph, const Arc& arc) : 
  13.337 -	Arc(arc), graph(&_graph) {}
  13.338 +      InArcIt(const Graph& _graph, const Arc& arc) :
  13.339 +        Arc(arc), graph(&_graph) {}
  13.340  
  13.341 -      InArcIt& operator++() { 
  13.342 -	graph->nextIn(*this);
  13.343 -	return *this; 
  13.344 +      InArcIt& operator++() {
  13.345 +        graph->nextIn(*this);
  13.346 +        return *this;
  13.347        }
  13.348  
  13.349      };
  13.350  
  13.351  
  13.352 -    class EdgeIt : public Parent::Edge { 
  13.353 +    class EdgeIt : public Parent::Edge {
  13.354        const Graph* graph;
  13.355      public:
  13.356  
  13.357 @@ -451,15 +451,15 @@
  13.358        EdgeIt(Invalid i) : Edge(i) { }
  13.359  
  13.360        explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
  13.361 -	_graph.first(static_cast<Edge&>(*this));
  13.362 +        _graph.first(static_cast<Edge&>(*this));
  13.363        }
  13.364  
  13.365 -      EdgeIt(const Graph& _graph, const Edge& e) : 
  13.366 -	Edge(e), graph(&_graph) { }
  13.367 +      EdgeIt(const Graph& _graph, const Edge& e) :
  13.368 +        Edge(e), graph(&_graph) { }
  13.369  
  13.370 -      EdgeIt& operator++() { 
  13.371 -	graph->next(*this);
  13.372 -	return *this; 
  13.373 +      EdgeIt& operator++() {
  13.374 +        graph->next(*this);
  13.375 +        return *this;
  13.376        }
  13.377  
  13.378      };
  13.379 @@ -475,17 +475,17 @@
  13.380        IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
  13.381  
  13.382        IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
  13.383 -	_graph.firstInc(*this, direction, n);
  13.384 +        _graph.firstInc(*this, direction, n);
  13.385        }
  13.386  
  13.387        IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
  13.388 -	: graph(&_graph), Edge(ue) {
  13.389 -	direction = (_graph.source(ue) == n);
  13.390 +        : graph(&_graph), Edge(ue) {
  13.391 +        direction = (_graph.source(ue) == n);
  13.392        }
  13.393  
  13.394        IncEdgeIt& operator++() {
  13.395 -	graph->nextInc(*this, direction);
  13.396 -	return *this; 
  13.397 +        graph->nextInc(*this, direction);
  13.398 +        return *this;
  13.399        }
  13.400      };
  13.401  
  13.402 @@ -532,49 +532,49 @@
  13.403  
  13.404  
  13.405      template <typename _Value>
  13.406 -    class ArcMap 
  13.407 +    class ArcMap
  13.408        : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
  13.409        typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
  13.410  
  13.411      public:
  13.412 -      explicit ArcMap(const Graph& _g) 
  13.413 -	: Parent(_g) {}
  13.414 -      ArcMap(const Graph& _g, const _Value& _v) 
  13.415 -	: Parent(_g, _v) {}
  13.416 +      explicit ArcMap(const Graph& _g)
  13.417 +        : Parent(_g) {}
  13.418 +      ArcMap(const Graph& _g, const _Value& _v)
  13.419 +        : Parent(_g, _v) {}
  13.420  
  13.421        ArcMap& operator=(const ArcMap& cmap) {
  13.422 -	return operator=<ArcMap>(cmap);
  13.423 +        return operator=<ArcMap>(cmap);
  13.424        }
  13.425  
  13.426        template <typename CMap>
  13.427        ArcMap& operator=(const CMap& cmap) {
  13.428          Parent::operator=(cmap);
  13.429 -	return *this;
  13.430 +        return *this;
  13.431        }
  13.432  
  13.433      };
  13.434  
  13.435  
  13.436      template <typename _Value>
  13.437 -    class EdgeMap 
  13.438 +    class EdgeMap
  13.439        : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
  13.440        typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
  13.441  
  13.442      public:
  13.443 -      explicit EdgeMap(const Graph& _g) 
  13.444 -	: Parent(_g) {}
  13.445 +      explicit EdgeMap(const Graph& _g)
  13.446 +        : Parent(_g) {}
  13.447  
  13.448 -      EdgeMap(const Graph& _g, const _Value& _v) 
  13.449 -	: Parent(_g, _v) {}
  13.450 +      EdgeMap(const Graph& _g, const _Value& _v)
  13.451 +        : Parent(_g, _v) {}
  13.452  
  13.453        EdgeMap& operator=(const EdgeMap& cmap) {
  13.454 -	return operator=<EdgeMap>(cmap);
  13.455 +        return operator=<EdgeMap>(cmap);
  13.456        }
  13.457  
  13.458        template <typename CMap>
  13.459        EdgeMap& operator=(const CMap& cmap) {
  13.460          Parent::operator=(cmap);
  13.461 -	return *this;
  13.462 +        return *this;
  13.463        }
  13.464  
  13.465      };
  13.466 @@ -591,7 +591,7 @@
  13.467        notifier(Arc()).add(arcs);
  13.468        return edge;
  13.469      }
  13.470 -    
  13.471 +
  13.472      void clear() {
  13.473        notifier(Arc()).clear();
  13.474        notifier(Edge()).clear();
  13.475 @@ -617,7 +617,7 @@
  13.476        edge_notifier.clear();
  13.477        arc_notifier.clear();
  13.478      }
  13.479 -    
  13.480 +
  13.481    };
  13.482  
  13.483  }
    14.1 --- a/lemon/bits/solver_bits.h	Wed Mar 17 12:35:52 2010 +0100
    14.2 +++ b/lemon/bits/solver_bits.h	Sat Mar 06 14:35:12 2010 +0000
    14.3 @@ -2,7 +2,7 @@
    14.4   *
    14.5   * This file is a part of LEMON, a generic C++ optimization library.
    14.6   *
    14.7 - * Copyright (C) 2003-2008
    14.8 + * Copyright (C) 2003-2010
    14.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   14.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   14.11   *
    15.1 --- a/lemon/bits/windows.cc	Wed Mar 17 12:35:52 2010 +0100
    15.2 +++ b/lemon/bits/windows.cc	Sat Mar 06 14:35:12 2010 +0000
    15.3 @@ -2,7 +2,7 @@
    15.4   *
    15.5   * This file is a part of LEMON, a generic C++ optimization library.
    15.6   *
    15.7 - * Copyright (C) 2003-2009
    15.8 + * Copyright (C) 2003-2010
    15.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   15.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   15.11   *
   15.12 @@ -96,7 +96,7 @@
   15.13        SYSTEMTIME time;
   15.14        GetSystemTime(&time);
   15.15        char buf1[11], buf2[9], buf3[5];
   15.16 -	  if (GetDateFormat(MY_LOCALE, 0, &time,
   15.17 +          if (GetDateFormat(MY_LOCALE, 0, &time,
   15.18                          ("ddd MMM dd"), buf1, 11) &&
   15.19            GetTimeFormat(MY_LOCALE, 0, &time,
   15.20                          ("HH':'mm':'ss"), buf2, 9) &&
    16.1 --- a/lemon/bucket_heap.h	Wed Mar 17 12:35:52 2010 +0100
    16.2 +++ b/lemon/bucket_heap.h	Sat Mar 06 14:35:12 2010 +0000
    16.3 @@ -2,7 +2,7 @@
    16.4   *
    16.5   * This file is a part of LEMON, a generic C++ optimization library.
    16.6   *
    16.7 - * Copyright (C) 2003-2009
    16.8 + * Copyright (C) 2003-2010
    16.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   16.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   16.11   *
   16.12 @@ -384,7 +384,7 @@
   16.13    /// key increasing and decreasing.
   16.14    ///
   16.15    /// Note that this implementation does not conform to the
   16.16 -  /// \ref concepts::Heap "heap concept" due to the lack of some 
   16.17 +  /// \ref concepts::Heap "heap concept" due to the lack of some
   16.18    /// functionality.
   16.19    ///
   16.20    /// \tparam IM A read-writable item map with \c int values, used
    17.1 --- a/lemon/capacity_scaling.h	Wed Mar 17 12:35:52 2010 +0100
    17.2 +++ b/lemon/capacity_scaling.h	Sat Mar 06 14:35:12 2010 +0000
    17.3 @@ -1,8 +1,8 @@
    17.4 -/* -*- C++ -*-
    17.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    17.6   *
    17.7 - * This file is a part of LEMON, a generic C++ optimization library
    17.8 + * This file is a part of LEMON, a generic C++ optimization library.
    17.9   *
   17.10 - * Copyright (C) 2003-2008
   17.11 + * Copyright (C) 2003-2010
   17.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   17.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   17.14   *
   17.15 @@ -133,7 +133,7 @@
   17.16        /// these cases.
   17.17        UNBOUNDED
   17.18      };
   17.19 -  
   17.20 +
   17.21    private:
   17.22  
   17.23      TEMPLATE_DIGRAPH_TYPEDEFS(GR);
   17.24 @@ -184,7 +184,7 @@
   17.25      IntVector _pred;
   17.26  
   17.27    public:
   17.28 -  
   17.29 +
   17.30      /// \brief Constant for infinite upper bounds (capacities).
   17.31      ///
   17.32      /// Constant for infinite upper bounds (capacities).
   17.33 @@ -211,10 +211,10 @@
   17.34        const ValueVector &_excess;
   17.35        CostVector &_pi;
   17.36        IntVector &_pred;
   17.37 -      
   17.38 +
   17.39        IntVector _proc_nodes;
   17.40        CostVector _dist;
   17.41 -      
   17.42 +
   17.43      public:
   17.44  
   17.45        ResidualDijkstra(CapacityScaling& cs) :
   17.46 @@ -439,7 +439,7 @@
   17.47        _supply[_node_id[t]] = -k;
   17.48        return *this;
   17.49      }
   17.50 -    
   17.51 +
   17.52      /// @}
   17.53  
   17.54      /// \name Execution control
   17.55 @@ -575,7 +575,7 @@
   17.56        _upper.resize(_res_arc_num);
   17.57        _cost.resize(_res_arc_num);
   17.58        _supply.resize(_node_num);
   17.59 -      
   17.60 +
   17.61        _res_cap.resize(_res_arc_num);
   17.62        _pi.resize(_node_num);
   17.63        _excess.resize(_node_num);
   17.64 @@ -619,7 +619,7 @@
   17.65          _reverse[fi] = bi;
   17.66          _reverse[bi] = fi;
   17.67        }
   17.68 -      
   17.69 +
   17.70        // Reset parameters
   17.71        resetParams();
   17.72        return *this;
   17.73 @@ -728,7 +728,7 @@
   17.74          _sum_supply += _supply[i];
   17.75        }
   17.76        if (_sum_supply > 0) return INFEASIBLE;
   17.77 -      
   17.78 +
   17.79        // Initialize vectors
   17.80        for (int i = 0; i != _root; ++i) {
   17.81          _pi[i] = 0;
   17.82 @@ -776,7 +776,7 @@
   17.83            }
   17.84          }
   17.85        }
   17.86 -      
   17.87 +
   17.88        // Handle GEQ supply type
   17.89        if (_sum_supply < 0) {
   17.90          _pi[_root] = 0;
   17.91 @@ -844,9 +844,9 @@
   17.92        if (_sum_supply < 0 || pr > 0) {
   17.93          for (int i = 0; i != _node_num; ++i) {
   17.94            _pi[i] -= pr;
   17.95 -        }        
   17.96 +        }
   17.97        }
   17.98 -      
   17.99 +
  17.100        return pt;
  17.101      }
  17.102  
    18.1 --- a/lemon/cbc.h	Wed Mar 17 12:35:52 2010 +0100
    18.2 +++ b/lemon/cbc.h	Sat Mar 06 14:35:12 2010 +0000
    18.3 @@ -2,7 +2,7 @@
    18.4   *
    18.5   * This file is a part of LEMON, a generic C++ optimization library.
    18.6   *
    18.7 - * Copyright (C) 2003-2009
    18.8 + * Copyright (C) 2003-2010
    18.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   18.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   18.11   *
   18.12 @@ -121,7 +121,7 @@
   18.13  
   18.14      int _message_level;
   18.15  
   18.16 -    
   18.17 +
   18.18  
   18.19    };
   18.20  
    19.1 --- a/lemon/circulation.h	Wed Mar 17 12:35:52 2010 +0100
    19.2 +++ b/lemon/circulation.h	Sat Mar 06 14:35:12 2010 +0000
    19.3 @@ -2,7 +2,7 @@
    19.4   *
    19.5   * This file is a part of LEMON, a generic C++ optimization library.
    19.6   *
    19.7 - * Copyright (C) 2003-2009
    19.8 + * Copyright (C) 2003-2010
    19.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   19.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   19.11   *
   19.12 @@ -59,8 +59,8 @@
   19.13  
   19.14      /// \brief The type of supply map.
   19.15      ///
   19.16 -    /// The type of the map that stores the signed supply values of the 
   19.17 -    /// nodes. 
   19.18 +    /// The type of the map that stores the signed supply values of the
   19.19 +    /// nodes.
   19.20      /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
   19.21      typedef SM SupplyMap;
   19.22  
   19.23 @@ -141,7 +141,7 @@
   19.24       \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu)
   19.25       \geq sup(u) \quad \forall u\in V, \f]
   19.26       \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
   19.27 -     
   19.28 +
   19.29       The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
   19.30       zero or negative in order to have a feasible solution (since the sum
   19.31       of the expressions on the left-hand side of the inequalities is zero).
   19.32 @@ -151,7 +151,7 @@
   19.33       If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand
   19.34       constraints have to be satisfied with equality, i.e. all demands
   19.35       have to be satisfied and all supplies have to be used.
   19.36 -     
   19.37 +
   19.38       If you need the opposite inequalities in the supply/demand constraints
   19.39       (i.e. the total demand is less than the total supply and all the demands
   19.40       have to be satisfied while there could be supplies that are not used),
   19.41 @@ -337,7 +337,7 @@
   19.42      ///
   19.43      /// \param graph The digraph the algorithm runs on.
   19.44      /// \param lower The lower bounds for the flow values on the arcs.
   19.45 -    /// \param upper The upper bounds (capacities) for the flow values 
   19.46 +    /// \param upper The upper bounds (capacities) for the flow values
   19.47      /// on the arcs.
   19.48      /// \param supply The signed supply values of the nodes.
   19.49      Circulation(const Digraph &graph, const LowerMap &lower,
    20.1 --- a/lemon/clp.cc	Wed Mar 17 12:35:52 2010 +0100
    20.2 +++ b/lemon/clp.cc	Sat Mar 06 14:35:12 2010 +0000
    20.3 @@ -2,7 +2,7 @@
    20.4   *
    20.5   * This file is a part of LEMON, a generic C++ optimization library.
    20.6   *
    20.7 - * Copyright (C) 2003-2008
    20.8 + * Copyright (C) 2003-2010
    20.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   20.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   20.11   *
    21.1 --- a/lemon/clp.h	Wed Mar 17 12:35:52 2010 +0100
    21.2 +++ b/lemon/clp.h	Sat Mar 06 14:35:12 2010 +0000
    21.3 @@ -2,7 +2,7 @@
    21.4   *
    21.5   * This file is a part of LEMON, a generic C++ optimization library.
    21.6   *
    21.7 - * Copyright (C) 2003-2008
    21.8 + * Copyright (C) 2003-2010
    21.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   21.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   21.11   *
   21.12 @@ -138,7 +138,7 @@
   21.13      virtual void _clear();
   21.14  
   21.15      virtual void _messageLevel(MessageLevel);
   21.16 -    
   21.17 +
   21.18    public:
   21.19  
   21.20      ///Solves LP with primal simplex method.
    22.1 --- a/lemon/concepts/digraph.h	Wed Mar 17 12:35:52 2010 +0100
    22.2 +++ b/lemon/concepts/digraph.h	Sat Mar 06 14:35:12 2010 +0000
    22.3 @@ -2,7 +2,7 @@
    22.4   *
    22.5   * This file is a part of LEMON, a generic C++ optimization library.
    22.6   *
    22.7 - * Copyright (C) 2003-2009
    22.8 + * Copyright (C) 2003-2010
    22.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   22.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   22.11   *
   22.12 @@ -434,7 +434,7 @@
   22.13  
   22.14        private:
   22.15          ///Copy constructor
   22.16 -        NodeMap(const NodeMap& nm) : 
   22.17 +        NodeMap(const NodeMap& nm) :
   22.18            ReferenceMap<Node, T, T&, const T&>(nm) { }
   22.19          ///Assignment operator
   22.20          template <typename CMap>
    23.1 --- a/lemon/concepts/graph.h	Wed Mar 17 12:35:52 2010 +0100
    23.2 +++ b/lemon/concepts/graph.h	Sat Mar 06 14:35:12 2010 +0000
    23.3 @@ -2,7 +2,7 @@
    23.4   *
    23.5   * This file is a part of LEMON, a generic C++ optimization library.
    23.6   *
    23.7 - * Copyright (C) 2003-2009
    23.8 + * Copyright (C) 2003-2010
    23.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   23.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   23.11   *
   23.12 @@ -43,7 +43,7 @@
   23.13      /// undirected graphs should compile with this class, but it will not
   23.14      /// run properly, of course.
   23.15      /// An actual graph implementation like \ref ListGraph or
   23.16 -    /// \ref SmartGraph may have additional functionality.    
   23.17 +    /// \ref SmartGraph may have additional functionality.
   23.18      ///
   23.19      /// The undirected graphs also fulfill the concept of \ref Digraph
   23.20      /// "directed graphs", since each edge can also be regarded as two
   23.21 @@ -85,7 +85,7 @@
   23.22        /// \brief Undirected graphs should be tagged with \c UndirectedTag.
   23.23        ///
   23.24        /// Undirected graphs should be tagged with \c UndirectedTag.
   23.25 -      /// 
   23.26 +      ///
   23.27        /// This tag helps the \c enable_if technics to make compile time
   23.28        /// specializations for undirected graphs.
   23.29        typedef True UndirectedTag;
   23.30 @@ -360,7 +360,7 @@
   23.31          bool operator<(Arc) const { return false; }
   23.32  
   23.33          /// Converison to \c Edge
   23.34 -        
   23.35 +
   23.36          /// Converison to \c Edge.
   23.37          ///
   23.38          operator Edge() const { return Edge(); }
    24.1 --- a/lemon/concepts/graph_components.h	Wed Mar 17 12:35:52 2010 +0100
    24.2 +++ b/lemon/concepts/graph_components.h	Sat Mar 06 14:35:12 2010 +0000
    24.3 @@ -2,7 +2,7 @@
    24.4   *
    24.5   * This file is a part of LEMON, a generic C++ optimization library.
    24.6   *
    24.7 - * Copyright (C) 2003-2009
    24.8 + * Copyright (C) 2003-2010
    24.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   24.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   24.11   *
   24.12 @@ -38,7 +38,7 @@
   24.13      ///
   24.14      /// \note This class is a template class so that we can use it to
   24.15      /// create graph skeleton classes. The reason for this is that \c Node
   24.16 -    /// and \c Arc (or \c Edge) types should \e not derive from the same 
   24.17 +    /// and \c Arc (or \c Edge) types should \e not derive from the same
   24.18      /// base class. For \c Node you should instantiate it with character
   24.19      /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
   24.20  #ifndef DOXYGEN
   24.21 @@ -89,7 +89,7 @@
   24.22        /// \brief Ordering operator.
   24.23        ///
   24.24        /// This operator defines an ordering of the items.
   24.25 -      /// It makes possible to use graph item types as key types in 
   24.26 +      /// It makes possible to use graph item types as key types in
   24.27        /// associative containers (e.g. \c std::map).
   24.28        ///
   24.29        /// \note This operator only has to define some strict ordering of
   24.30 @@ -122,7 +122,7 @@
   24.31      ///
   24.32      /// This class describes the base interface of directed graph types.
   24.33      /// All digraph %concepts have to conform to this class.
   24.34 -    /// It just provides types for nodes and arcs and functions 
   24.35 +    /// It just provides types for nodes and arcs and functions
   24.36      /// to get the source and the target nodes of arcs.
   24.37      class BaseDigraphComponent {
   24.38      public:
   24.39 @@ -426,7 +426,7 @@
   24.40  
   24.41      /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
   24.42      ///
   24.43 -    /// This class describes the concept of \c NodeIt, \c ArcIt and 
   24.44 +    /// This class describes the concept of \c NodeIt, \c ArcIt and
   24.45      /// \c EdgeIt subtypes of digraph and graph types.
   24.46      template <typename GR, typename Item>
   24.47      class GraphItemIt : public Item {
   24.48 @@ -466,7 +466,7 @@
   24.49        /// This operator increments the iterator, i.e. assigns it to the
   24.50        /// next item.
   24.51        GraphItemIt& operator++() { return *this; }
   24.52 - 
   24.53 +
   24.54        /// \brief Equality operator
   24.55        ///
   24.56        /// Equality operator.
   24.57 @@ -501,15 +501,15 @@
   24.58        };
   24.59      };
   24.60  
   24.61 -    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
   24.62 +    /// \brief Concept class for \c InArcIt, \c OutArcIt and
   24.63      /// \c IncEdgeIt types.
   24.64      ///
   24.65 -    /// This class describes the concept of \c InArcIt, \c OutArcIt 
   24.66 +    /// This class describes the concept of \c InArcIt, \c OutArcIt
   24.67      /// and \c IncEdgeIt subtypes of digraph and graph types.
   24.68      ///
   24.69      /// \note Since these iterator classes do not inherit from the same
   24.70      /// base class, there is an additional template parameter (selector)
   24.71 -    /// \c sel. For \c InArcIt you should instantiate it with character 
   24.72 +    /// \c sel. For \c InArcIt you should instantiate it with character
   24.73      /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
   24.74      template <typename GR,
   24.75                typename Item = typename GR::Arc,
   24.76 @@ -530,10 +530,10 @@
   24.77        /// Copy constructor.
   24.78        GraphIncIt(const GraphIncIt& it) : Item(it) {}
   24.79  
   24.80 -      /// \brief Constructor that sets the iterator to the first 
   24.81 +      /// \brief Constructor that sets the iterator to the first
   24.82        /// incoming or outgoing arc.
   24.83        ///
   24.84 -      /// Constructor that sets the iterator to the first arc 
   24.85 +      /// Constructor that sets the iterator to the first arc
   24.86        /// incoming to or outgoing from the given node.
   24.87        explicit GraphIncIt(const GR&, const Base&) {}
   24.88  
   24.89 @@ -804,16 +804,16 @@
   24.90  
   24.91        /// \brief Return the first edge incident to the given node.
   24.92        ///
   24.93 -      /// This function gives back the first edge incident to the given 
   24.94 +      /// This function gives back the first edge incident to the given
   24.95        /// node. The bool parameter gives back the direction for which the
   24.96 -      /// source node of the directed arc representing the edge is the 
   24.97 +      /// source node of the directed arc representing the edge is the
   24.98        /// given node.
   24.99        void firstInc(Edge&, bool&, const Node&) const {}
  24.100  
  24.101        /// \brief Gives back the next of the edges from the
  24.102        /// given node.
  24.103        ///
  24.104 -      /// This function gives back the next edge incident to the given 
  24.105 +      /// This function gives back the next edge incident to the given
  24.106        /// node. The bool parameter should be used as \c firstInc() use it.
  24.107        void nextInc(Edge&, bool&) const {}
  24.108  
  24.109 @@ -990,7 +990,7 @@
  24.110      /// \brief Concept class for standard graph maps.
  24.111      ///
  24.112      /// This class describes the concept of standard graph maps, i.e.
  24.113 -    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
  24.114 +    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
  24.115      /// graph types, which can be used for associating data to graph items.
  24.116      /// The standard graph maps must conform to the ReferenceMap concept.
  24.117      template <typename GR, typename K, typename V>
  24.118 @@ -1045,7 +1045,7 @@
  24.119              <ReferenceMap<Key, Value, Value&, const Value&>, _Map>();
  24.120            _Map m1(g);
  24.121            _Map m2(g,t);
  24.122 -          
  24.123 +
  24.124            // Copy constructor
  24.125            // _Map m3(m);
  24.126  
  24.127 @@ -1068,7 +1068,7 @@
  24.128      /// \brief Skeleton class for mappable directed graphs.
  24.129      ///
  24.130      /// This class describes the interface of mappable directed graphs.
  24.131 -    /// It extends \ref BaseDigraphComponent with the standard digraph 
  24.132 +    /// It extends \ref BaseDigraphComponent with the standard digraph
  24.133      /// map classes, namely \c NodeMap and \c ArcMap.
  24.134      /// This concept is part of the Digraph concept.
  24.135      template <typename BAS = BaseDigraphComponent>
  24.136 @@ -1205,7 +1205,7 @@
  24.137      /// \brief Skeleton class for mappable undirected graphs.
  24.138      ///
  24.139      /// This class describes the interface of mappable undirected graphs.
  24.140 -    /// It extends \ref MappableDigraphComponent with the standard graph 
  24.141 +    /// It extends \ref MappableDigraphComponent with the standard graph
  24.142      /// map class for edges (\c EdgeMap).
  24.143      /// This concept is part of the Graph concept.
  24.144      template <typename BAS = BaseGraphComponent>
  24.145 @@ -1290,7 +1290,7 @@
  24.146      /// \brief Skeleton class for extendable directed graphs.
  24.147      ///
  24.148      /// This class describes the interface of extendable directed graphs.
  24.149 -    /// It extends \ref BaseDigraphComponent with functions for adding 
  24.150 +    /// It extends \ref BaseDigraphComponent with functions for adding
  24.151      /// nodes and arcs to the digraph.
  24.152      /// This concept requires \ref AlterableDigraphComponent.
  24.153      template <typename BAS = BaseDigraphComponent>
  24.154 @@ -1334,7 +1334,7 @@
  24.155      /// \brief Skeleton class for extendable undirected graphs.
  24.156      ///
  24.157      /// This class describes the interface of extendable undirected graphs.
  24.158 -    /// It extends \ref BaseGraphComponent with functions for adding 
  24.159 +    /// It extends \ref BaseGraphComponent with functions for adding
  24.160      /// nodes and edges to the graph.
  24.161      /// This concept requires \ref AlterableGraphComponent.
  24.162      template <typename BAS = BaseGraphComponent>
  24.163 @@ -1378,7 +1378,7 @@
  24.164      /// \brief Skeleton class for erasable directed graphs.
  24.165      ///
  24.166      /// This class describes the interface of erasable directed graphs.
  24.167 -    /// It extends \ref BaseDigraphComponent with functions for removing 
  24.168 +    /// It extends \ref BaseDigraphComponent with functions for removing
  24.169      /// nodes and arcs from the digraph.
  24.170      /// This concept requires \ref AlterableDigraphComponent.
  24.171      template <typename BAS = BaseDigraphComponent>
  24.172 @@ -1391,7 +1391,7 @@
  24.173  
  24.174        /// \brief Erase a node from the digraph.
  24.175        ///
  24.176 -      /// This function erases the given node from the digraph and all arcs 
  24.177 +      /// This function erases the given node from the digraph and all arcs
  24.178        /// connected to the node.
  24.179        void erase(const Node&) {}
  24.180  
  24.181 @@ -1417,7 +1417,7 @@
  24.182      /// \brief Skeleton class for erasable undirected graphs.
  24.183      ///
  24.184      /// This class describes the interface of erasable undirected graphs.
  24.185 -    /// It extends \ref BaseGraphComponent with functions for removing 
  24.186 +    /// It extends \ref BaseGraphComponent with functions for removing
  24.187      /// nodes and edges from the graph.
  24.188      /// This concept requires \ref AlterableGraphComponent.
  24.189      template <typename BAS = BaseGraphComponent>
    25.1 --- a/lemon/concepts/heap.h	Wed Mar 17 12:35:52 2010 +0100
    25.2 +++ b/lemon/concepts/heap.h	Sat Mar 06 14:35:12 2010 +0000
    25.3 @@ -2,7 +2,7 @@
    25.4   *
    25.5   * This file is a part of LEMON, a generic C++ optimization library.
    25.6   *
    25.7 - * Copyright (C) 2003-2009
    25.8 + * Copyright (C) 2003-2010
    25.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   25.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   25.11   *
   25.12 @@ -92,7 +92,7 @@
   25.13        explicit Heap(ItemIntMap &map) {}
   25.14  #else
   25.15        explicit Heap(ItemIntMap&) {}
   25.16 -#endif      
   25.17 +#endif
   25.18  
   25.19        /// \brief Constructor.
   25.20        ///
   25.21 @@ -106,7 +106,7 @@
   25.22        explicit Heap(ItemIntMap &map, const CMP &comp) {}
   25.23  #else
   25.24        explicit Heap(ItemIntMap&, const CMP&) {}
   25.25 -#endif      
   25.26 +#endif
   25.27  
   25.28        /// \brief The number of items stored in the heap.
   25.29        ///
   25.30 @@ -138,7 +138,7 @@
   25.31        void push(const Item &i, const Prio &p) {}
   25.32  #else
   25.33        void push(const Item&, const Prio&) {}
   25.34 -#endif      
   25.35 +#endif
   25.36  
   25.37        /// \brief Return the item having minimum priority.
   25.38        ///
   25.39 @@ -168,7 +168,7 @@
   25.40        void erase(const Item &i) {}
   25.41  #else
   25.42        void erase(const Item&) {}
   25.43 -#endif      
   25.44 +#endif
   25.45  
   25.46        /// \brief The priority of the given item.
   25.47        ///
   25.48 @@ -179,7 +179,7 @@
   25.49        Prio operator[](const Item &i) const {}
   25.50  #else
   25.51        Prio operator[](const Item&) const { return Prio(); }
   25.52 -#endif      
   25.53 +#endif
   25.54  
   25.55        /// \brief Set the priority of an item or insert it, if it is
   25.56        /// not stored in the heap.
   25.57 @@ -194,7 +194,7 @@
   25.58        void set(const Item &i, const Prio &p) {}
   25.59  #else
   25.60        void set(const Item&, const Prio&) {}
   25.61 -#endif      
   25.62 +#endif
   25.63  
   25.64        /// \brief Decrease the priority of an item to the given value.
   25.65        ///
   25.66 @@ -206,7 +206,7 @@
   25.67        void decrease(const Item &i, const Prio &p) {}
   25.68  #else
   25.69        void decrease(const Item&, const Prio&) {}
   25.70 -#endif      
   25.71 +#endif
   25.72  
   25.73        /// \brief Increase the priority of an item to the given value.
   25.74        ///
   25.75 @@ -218,7 +218,7 @@
   25.76        void increase(const Item &i, const Prio &p) {}
   25.77  #else
   25.78        void increase(const Item&, const Prio&) {}
   25.79 -#endif      
   25.80 +#endif
   25.81  
   25.82        /// \brief Return the state of an item.
   25.83        ///
   25.84 @@ -232,7 +232,7 @@
   25.85        State state(const Item &i) const {}
   25.86  #else
   25.87        State state(const Item&) const { return PRE_HEAP; }
   25.88 -#endif      
   25.89 +#endif
   25.90  
   25.91        /// \brief Set the state of an item in the heap.
   25.92        ///
   25.93 @@ -245,7 +245,7 @@
   25.94        void state(const Item& i, State st) {}
   25.95  #else
   25.96        void state(const Item&, State) {}
   25.97 -#endif      
   25.98 +#endif
   25.99  
  25.100  
  25.101        template <typename _Heap>
    26.1 --- a/lemon/connectivity.h	Wed Mar 17 12:35:52 2010 +0100
    26.2 +++ b/lemon/connectivity.h	Sat Mar 06 14:35:12 2010 +0000
    26.3 @@ -2,7 +2,7 @@
    26.4   *
    26.5   * This file is a part of LEMON, a generic C++ optimization library.
    26.6   *
    26.7 - * Copyright (C) 2003-2009
    26.8 + * Copyright (C) 2003-2010
    26.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   26.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   26.11   *
   26.12 @@ -258,7 +258,7 @@
   26.13    ///
   26.14    /// \return \c true if the digraph is strongly connected.
   26.15    /// \note By definition, the empty digraph is strongly connected.
   26.16 -  /// 
   26.17 +  ///
   26.18    /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   26.19    /// \see connected()
   26.20    template <typename Digraph>
   26.21 @@ -310,7 +310,7 @@
   26.22  
   26.23    /// \ingroup graph_properties
   26.24    ///
   26.25 -  /// \brief Count the number of strongly connected components of a 
   26.26 +  /// \brief Count the number of strongly connected components of a
   26.27    /// directed graph
   26.28    ///
   26.29    /// This function counts the number of strongly connected components of
   26.30 @@ -744,7 +744,7 @@
   26.31    ///
   26.32    /// \brief Check whether an undirected graph is bi-node-connected.
   26.33    ///
   26.34 -  /// This function checks whether the given undirected graph is 
   26.35 +  /// This function checks whether the given undirected graph is
   26.36    /// bi-node-connected, i.e. any two edges are on same circle.
   26.37    ///
   26.38    /// \return \c true if the graph bi-node-connected.
   26.39 @@ -758,7 +758,7 @@
   26.40  
   26.41    /// \ingroup graph_properties
   26.42    ///
   26.43 -  /// \brief Count the number of bi-node-connected components of an 
   26.44 +  /// \brief Count the number of bi-node-connected components of an
   26.45    /// undirected graph.
   26.46    ///
   26.47    /// This function counts the number of bi-node-connected components of
   26.48 @@ -812,7 +812,7 @@
   26.49    /// \param graph The undirected graph.
   26.50    /// \retval compMap A writable edge map. The values will be set from 0
   26.51    /// to the number of the bi-node-connected components minus one. Each
   26.52 -  /// value of the map will be set exactly once, and the values of a 
   26.53 +  /// value of the map will be set exactly once, and the values of a
   26.54    /// certain component will be set continuously.
   26.55    /// \return The number of bi-node-connected components.
   26.56    ///
   26.57 @@ -858,7 +858,7 @@
   26.58    /// the components.
   26.59    ///
   26.60    /// \param graph The undirected graph.
   26.61 -  /// \retval cutMap A writable node map. The values will be set to 
   26.62 +  /// \retval cutMap A writable node map. The values will be set to
   26.63    /// \c true for the nodes that separate two or more components
   26.64    /// (exactly once for each cut node), and will not be changed for
   26.65    /// other nodes.
   26.66 @@ -1085,7 +1085,7 @@
   26.67    ///
   26.68    /// \brief Check whether an undirected graph is bi-edge-connected.
   26.69    ///
   26.70 -  /// This function checks whether the given undirected graph is 
   26.71 +  /// This function checks whether the given undirected graph is
   26.72    /// bi-edge-connected, i.e. any two nodes are connected with at least
   26.73    /// two edge-disjoint paths.
   26.74    ///
   26.75 @@ -1192,7 +1192,7 @@
   26.76    /// \brief Find the bi-edge-connected cut edges in an undirected graph.
   26.77    ///
   26.78    /// This function finds the bi-edge-connected cut edges in the given
   26.79 -  /// undirected graph. 
   26.80 +  /// undirected graph.
   26.81    ///
   26.82    /// The bi-edge-connected components are the classes of an equivalence
   26.83    /// relation on the nodes of an undirected graph. Two nodes are in the
   26.84 @@ -1349,7 +1349,7 @@
   26.85    ///
   26.86    /// \param digraph The digraph.
   26.87    /// \retval order A readable and writable node map. The values will be
   26.88 -  /// set from 0 to the number of the nodes in the digraph minus one. 
   26.89 +  /// set from 0 to the number of the nodes in the digraph minus one.
   26.90    /// Each value of the map will be set exactly once, and the values will
   26.91    /// be set descending order.
   26.92    /// \return \c false if the digraph is not DAG.
    27.1 --- a/lemon/core.h	Wed Mar 17 12:35:52 2010 +0100
    27.2 +++ b/lemon/core.h	Sat Mar 06 14:35:12 2010 +0000
    27.3 @@ -2,7 +2,7 @@
    27.4   *
    27.5   * This file is a part of LEMON, a generic C++ optimization library.
    27.6   *
    27.7 - * Copyright (C) 2003-2009
    27.8 + * Copyright (C) 2003-2010
    27.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   27.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   27.11   *
   27.12 @@ -1239,7 +1239,8 @@
   27.13  
   27.14    protected:
   27.15  
   27.16 -    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
   27.17 +    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type
   27.18 +    {
   27.19        typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
   27.20  
   27.21      public:
   27.22 @@ -1278,7 +1279,7 @@
   27.23        }
   27.24      };
   27.25  
   27.26 -  protected: 
   27.27 +  protected:
   27.28  
   27.29      const Digraph &_g;
   27.30      AutoNodeMap _head;
    28.1 --- a/lemon/cost_scaling.h	Wed Mar 17 12:35:52 2010 +0100
    28.2 +++ b/lemon/cost_scaling.h	Sat Mar 06 14:35:12 2010 +0000
    28.3 @@ -1,8 +1,8 @@
    28.4 -/* -*- C++ -*-
    28.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    28.6   *
    28.7 - * This file is a part of LEMON, a generic C++ optimization library
    28.8 + * This file is a part of LEMON, a generic C++ optimization library.
    28.9   *
   28.10 - * Copyright (C) 2003-2008
   28.11 + * Copyright (C) 2003-2010
   28.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   28.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   28.14   *
   28.15 @@ -92,7 +92,7 @@
   28.16    /// \ref CostScaling implements a cost scaling algorithm that performs
   28.17    /// push/augment and relabel operations for finding a \ref min_cost_flow
   28.18    /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation,
   28.19 -  /// \ref goldberg97efficient, \ref bunnagel98efficient. 
   28.20 +  /// \ref goldberg97efficient, \ref bunnagel98efficient.
   28.21    /// It is a highly efficient primal-dual solution method, which
   28.22    /// can be viewed as the generalization of the \ref Preflow
   28.23    /// "preflow push-relabel" algorithm for the maximum flow problem.
   28.24 @@ -189,7 +189,7 @@
   28.25        /// Augment operations are used, i.e. flow is moved on admissible
   28.26        /// paths from a node with excess to a node with deficit.
   28.27        AUGMENT,
   28.28 -      /// Partial augment operations are used, i.e. flow is moved on 
   28.29 +      /// Partial augment operations are used, i.e. flow is moved on
   28.30        /// admissible paths started from a node with excess, but the
   28.31        /// lengths of these paths are limited. This method can be viewed
   28.32        /// as a combined version of the previous two operations.
   28.33 @@ -208,15 +208,15 @@
   28.34      // Note: vector<char> is used instead of vector<bool> for efficiency reasons
   28.35  
   28.36    private:
   28.37 -  
   28.38 +
   28.39      template <typename KT, typename VT>
   28.40      class StaticVectorMap {
   28.41      public:
   28.42        typedef KT Key;
   28.43        typedef VT Value;
   28.44 -      
   28.45 +
   28.46        StaticVectorMap(std::vector<Value>& v) : _v(v) {}
   28.47 -      
   28.48 +
   28.49        const Value& operator[](const Key& key) const {
   28.50          return _v[StaticDigraph::id(key)];
   28.51        }
   28.52 @@ -224,7 +224,7 @@
   28.53        Value& operator[](const Key& key) {
   28.54          return _v[StaticDigraph::id(key)];
   28.55        }
   28.56 -      
   28.57 +
   28.58        void set(const Key& key, const Value& val) {
   28.59          _v[StaticDigraph::id(key)] = val;
   28.60        }
   28.61 @@ -283,7 +283,7 @@
   28.62      IntVector _bucket_prev;
   28.63      IntVector _rank;
   28.64      int _max_rank;
   28.65 -  
   28.66 +
   28.67      // Data for a StaticDigraph structure
   28.68      typedef std::pair<int, int> IntPair;
   28.69      StaticDigraph _sgr;
   28.70 @@ -291,9 +291,9 @@
   28.71      std::vector<LargeCost> _cost_vec;
   28.72      LargeCostArcMap _cost_map;
   28.73      LargeCostNodeMap _pi_map;
   28.74 -  
   28.75 +
   28.76    public:
   28.77 -  
   28.78 +
   28.79      /// \brief Constant for infinite upper bounds (capacities).
   28.80      ///
   28.81      /// Constant for infinite upper bounds (capacities).
   28.82 @@ -348,7 +348,7 @@
   28.83          "The flow type of CostScaling must be signed");
   28.84        LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
   28.85          "The cost type of CostScaling must be signed");
   28.86 -      
   28.87 +
   28.88        // Reset data structures
   28.89        reset();
   28.90      }
   28.91 @@ -464,7 +464,7 @@
   28.92        _supply[_node_id[t]] = -k;
   28.93        return *this;
   28.94      }
   28.95 -    
   28.96 +
   28.97      /// @}
   28.98  
   28.99      /// \name Execution control
  28.100 @@ -566,7 +566,7 @@
  28.101          _upper[j] = INF;
  28.102          _scost[j] = 0;
  28.103          _scost[_reverse[j]] = 0;
  28.104 -      }      
  28.105 +      }
  28.106        _have_lower = false;
  28.107        return *this;
  28.108      }
  28.109 @@ -601,7 +601,7 @@
  28.110        _upper.resize(_res_arc_num);
  28.111        _scost.resize(_res_arc_num);
  28.112        _supply.resize(_res_node_num);
  28.113 -      
  28.114 +
  28.115        _res_cap.resize(_res_arc_num);
  28.116        _cost.resize(_res_arc_num);
  28.117        _pi.resize(_res_node_num);
  28.118 @@ -649,7 +649,7 @@
  28.119          _reverse[fi] = bi;
  28.120          _reverse[bi] = fi;
  28.121        }
  28.122 -      
  28.123 +
  28.124        // Reset parameters
  28.125        resetParams();
  28.126        return *this;
  28.127 @@ -758,14 +758,14 @@
  28.128          _sum_supply += _supply[i];
  28.129        }
  28.130        if (_sum_supply > 0) return INFEASIBLE;
  28.131 -      
  28.132 +
  28.133  
  28.134        // Initialize vectors
  28.135        for (int i = 0; i != _res_node_num; ++i) {
  28.136          _pi[i] = 0;
  28.137          _excess[i] = _supply[i];
  28.138        }
  28.139 -      
  28.140 +
  28.141        // Remove infinite upper bounds and check negative arcs
  28.142        const Value MAX = std::numeric_limits<Value>::max();
  28.143        int last_out;
  28.144 @@ -885,7 +885,7 @@
  28.145            _cost[ra] = 0;
  28.146          }
  28.147        }
  28.148 -      
  28.149 +
  28.150        return OPTIMAL;
  28.151      }
  28.152  
  28.153 @@ -894,13 +894,13 @@
  28.154        // Maximum path length for partial augment
  28.155        const int MAX_PATH_LENGTH = 4;
  28.156  
  28.157 -      // Initialize data structures for buckets      
  28.158 +      // Initialize data structures for buckets
  28.159        _max_rank = _alpha * _res_node_num;
  28.160        _buckets.resize(_max_rank);
  28.161        _bucket_next.resize(_res_node_num + 1);
  28.162        _bucket_prev.resize(_res_node_num + 1);
  28.163        _rank.resize(_res_node_num + 1);
  28.164 -  
  28.165 +
  28.166        // Execute the algorithm
  28.167        switch (method) {
  28.168          case PUSH:
  28.169 @@ -939,7 +939,7 @@
  28.170          }
  28.171        }
  28.172      }
  28.173 -    
  28.174 +
  28.175      // Initialize a cost scaling phase
  28.176      void initPhase() {
  28.177        // Saturate arcs not satisfying the optimality condition
  28.178 @@ -957,7 +957,7 @@
  28.179            }
  28.180          }
  28.181        }
  28.182 -      
  28.183 +
  28.184        // Find active nodes (i.e. nodes with positive excess)
  28.185        for (int u = 0; u != _res_node_num; ++u) {
  28.186          if (_excess[u] > 0) _active_nodes.push_back(u);
  28.187 @@ -968,7 +968,7 @@
  28.188          _next_out[u] = _first_out[u];
  28.189        }
  28.190      }
  28.191 -    
  28.192 +
  28.193      // Early termination heuristic
  28.194      bool earlyTermination() {
  28.195        const double EARLY_TERM_FACTOR = 3.0;
  28.196 @@ -998,7 +998,7 @@
  28.197      // Global potential update heuristic
  28.198      void globalUpdate() {
  28.199        int bucket_end = _root + 1;
  28.200 -    
  28.201 +
  28.202        // Initialize buckets
  28.203        for (int r = 0; r != _max_rank; ++r) {
  28.204          _buckets[r] = bucket_end;
  28.205 @@ -1024,7 +1024,7 @@
  28.206            // Remove the first node from the current bucket
  28.207            int u = _buckets[r];
  28.208            _buckets[r] = _bucket_next[u];
  28.209 -          
  28.210 +
  28.211            // Search the incomming arcs of u
  28.212            LargeCost pi_u = _pi[u];
  28.213            int last_out = _first_out[u+1];
  28.214 @@ -1039,12 +1039,12 @@
  28.215                  int new_rank_v = old_rank_v;
  28.216                  if (nrc < LargeCost(_max_rank))
  28.217                    new_rank_v = r + 1 + int(nrc);
  28.218 -                  
  28.219 +
  28.220                  // Change the rank of v
  28.221                  if (new_rank_v < old_rank_v) {
  28.222                    _rank[v] = new_rank_v;
  28.223                    _next_out[v] = _first_out[v];
  28.224 -                  
  28.225 +
  28.226                    // Remove v from its old bucket
  28.227                    if (old_rank_v < _max_rank) {
  28.228                      if (_buckets[old_rank_v] == v) {
  28.229 @@ -1054,7 +1054,7 @@
  28.230                        _bucket_prev[_bucket_next[v]] = _bucket_prev[v];
  28.231                      }
  28.232                    }
  28.233 -                  
  28.234 +
  28.235                    // Insert v to its new bucket
  28.236                    _bucket_next[v] = _buckets[new_rank_v];
  28.237                    _bucket_prev[_buckets[new_rank_v]] = v;
  28.238 @@ -1072,7 +1072,7 @@
  28.239          }
  28.240          if (total_excess <= 0) break;
  28.241        }
  28.242 -      
  28.243 +
  28.244        // Relabel nodes
  28.245        for (int u = 0; u != _res_node_num; ++u) {
  28.246          int k = std::min(_rank[u], r);
  28.247 @@ -1092,9 +1092,9 @@
  28.248        const int global_update_freq = int(GLOBAL_UPDATE_FACTOR *
  28.249          (_res_node_num + _sup_node_num * _sup_node_num));
  28.250        int next_update_limit = global_update_freq;
  28.251 -      
  28.252 +
  28.253        int relabel_cnt = 0;
  28.254 -      
  28.255 +
  28.256        // Perform cost scaling phases
  28.257        std::vector<int> path;
  28.258        for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
  28.259 @@ -1104,10 +1104,10 @@
  28.260          if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {
  28.261            if (earlyTermination()) break;
  28.262          }
  28.263 -        
  28.264 +
  28.265          // Initialize current phase
  28.266          initPhase();
  28.267 -        
  28.268 +
  28.269          // Perform partial augment and relabel operations
  28.270          while (true) {
  28.271            // Select an active node (FIFO selection)
  28.272 @@ -1196,7 +1196,7 @@
  28.273        int next_update_limit = global_update_freq;
  28.274  
  28.275        int relabel_cnt = 0;
  28.276 -      
  28.277 +
  28.278        // Perform cost scaling phases
  28.279        BoolVector hyper(_res_node_num, false);
  28.280        LargeCostVector hyper_cost(_res_node_num);
  28.281 @@ -1207,7 +1207,7 @@
  28.282          if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {
  28.283            if (earlyTermination()) break;
  28.284          }
  28.285 -        
  28.286 +
  28.287          // Initialize current phase
  28.288          initPhase();
  28.289  
  28.290 @@ -1222,7 +1222,7 @@
  28.291            n = _active_nodes.front();
  28.292            last_out = _first_out[n+1];
  28.293            pi_n = _pi[n];
  28.294 -          
  28.295 +
  28.296            // Perform push operations if there are admissible arcs
  28.297            if (_excess[n] > 0) {
  28.298              for (a = _next_out[n]; a != last_out; ++a) {
  28.299 @@ -1236,7 +1236,7 @@
  28.300                  int last_out_t = _first_out[t+1];
  28.301                  LargeCost pi_t = _pi[t];
  28.302                  for (int ta = _next_out[t]; ta != last_out_t; ++ta) {
  28.303 -                  if (_res_cap[ta] > 0 && 
  28.304 +                  if (_res_cap[ta] > 0 &&
  28.305                        _cost[ta] + pi_t - _pi[_target[ta]] < 0)
  28.306                      ahead += _res_cap[ta];
  28.307                    if (ahead >= delta) break;
  28.308 @@ -1287,7 +1287,7 @@
  28.309              hyper[n] = false;
  28.310              ++relabel_cnt;
  28.311            }
  28.312 -        
  28.313 +
  28.314            // Remove nodes that are not active nor hyper
  28.315          remove_nodes:
  28.316            while ( _active_nodes.size() > 0 &&
  28.317 @@ -1295,7 +1295,7 @@
  28.318                    !hyper[_active_nodes.front()] ) {
  28.319              _active_nodes.pop_front();
  28.320            }
  28.321 -          
  28.322 +
  28.323            // Global update heuristic
  28.324            if (relabel_cnt >= next_update_limit) {
  28.325              globalUpdate();
    29.1 --- a/lemon/cplex.cc	Wed Mar 17 12:35:52 2010 +0100
    29.2 +++ b/lemon/cplex.cc	Sat Mar 06 14:35:12 2010 +0000
    29.3 @@ -2,7 +2,7 @@
    29.4   *
    29.5   * This file is a part of LEMON, a generic C++ optimization library.
    29.6   *
    29.7 - * Copyright (C) 2003-2009
    29.8 + * Copyright (C) 2003-2010
    29.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   29.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   29.11   *
   29.12 @@ -111,7 +111,7 @@
   29.13      return i;
   29.14    }
   29.15  
   29.16 -  int CplexBase::_addRow(Value lb, ExprIterator b, 
   29.17 +  int CplexBase::_addRow(Value lb, ExprIterator b,
   29.18                           ExprIterator e, Value ub) {
   29.19      int i = CPXgetnumrows(cplexEnv(), _prob);
   29.20      if (lb == -INF) {
   29.21 @@ -489,7 +489,7 @@
   29.22    }
   29.23  
   29.24    void CplexBase::_applyMessageLevel() {
   29.25 -    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, 
   29.26 +    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
   29.27                     _message_enabled ? CPX_ON : CPX_OFF);
   29.28    }
   29.29  
    30.1 --- a/lemon/cycle_canceling.h	Wed Mar 17 12:35:52 2010 +0100
    30.2 +++ b/lemon/cycle_canceling.h	Sat Mar 06 14:35:12 2010 +0000
    30.3 @@ -1,8 +1,8 @@
    30.4 -/* -*- C++ -*-
    30.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    30.6   *
    30.7 - * This file is a part of LEMON, a generic C++ optimization library
    30.8 + * This file is a part of LEMON, a generic C++ optimization library.
    30.9   *
   30.10 - * Copyright (C) 2003-2008
   30.11 + * Copyright (C) 2003-2010
   30.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   30.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   30.14   *
   30.15 @@ -142,7 +142,7 @@
   30.16    private:
   30.17  
   30.18      TEMPLATE_DIGRAPH_TYPEDEFS(GR);
   30.19 -    
   30.20 +
   30.21      typedef std::vector<int> IntVector;
   30.22      typedef std::vector<double> DoubleVector;
   30.23      typedef std::vector<Value> ValueVector;
   30.24 @@ -151,15 +151,15 @@
   30.25      // Note: vector<char> is used instead of vector<bool> for efficiency reasons
   30.26  
   30.27    private:
   30.28 -  
   30.29 +
   30.30      template <typename KT, typename VT>
   30.31      class StaticVectorMap {
   30.32      public:
   30.33        typedef KT Key;
   30.34        typedef VT Value;
   30.35 -      
   30.36 +
   30.37        StaticVectorMap(std::vector<Value>& v) : _v(v) {}
   30.38 -      
   30.39 +
   30.40        const Value& operator[](const Key& key) const {
   30.41          return _v[StaticDigraph::id(key)];
   30.42        }
   30.43 @@ -167,7 +167,7 @@
   30.44        Value& operator[](const Key& key) {
   30.45          return _v[StaticDigraph::id(key)];
   30.46        }
   30.47 -      
   30.48 +
   30.49        void set(const Key& key, const Value& val) {
   30.50          _v[StaticDigraph::id(key)] = val;
   30.51        }
   30.52 @@ -221,9 +221,9 @@
   30.53      IntVector _id_vec;
   30.54      CostArcMap _cost_map;
   30.55      CostNodeMap _pi_map;
   30.56 -  
   30.57 +
   30.58    public:
   30.59 -  
   30.60 +
   30.61      /// \brief Constant for infinite upper bounds (capacities).
   30.62      ///
   30.63      /// Constant for infinite upper bounds (capacities).
   30.64 @@ -366,7 +366,7 @@
   30.65        _supply[_node_id[t]] = -k;
   30.66        return *this;
   30.67      }
   30.68 -    
   30.69 +
   30.70      /// @}
   30.71  
   30.72      /// \name Execution control
   30.73 @@ -466,7 +466,7 @@
   30.74          _upper[j] = INF;
   30.75          _cost[j] = 0;
   30.76          _cost[_reverse[j]] = 0;
   30.77 -      }      
   30.78 +      }
   30.79        _have_lower = false;
   30.80        return *this;
   30.81      }
   30.82 @@ -508,7 +508,7 @@
   30.83        _upper.resize(_res_arc_num);
   30.84        _cost.resize(_res_arc_num);
   30.85        _supply.resize(_res_node_num);
   30.86 -      
   30.87 +
   30.88        _res_cap.resize(_res_arc_num);
   30.89        _pi.resize(_res_node_num);
   30.90  
   30.91 @@ -554,7 +554,7 @@
   30.92          _reverse[fi] = bi;
   30.93          _reverse[bi] = fi;
   30.94        }
   30.95 -      
   30.96 +
   30.97        // Reset parameters
   30.98        resetParams();
   30.99        return *this;
  30.100 @@ -663,14 +663,14 @@
  30.101          _sum_supply += _supply[i];
  30.102        }
  30.103        if (_sum_supply > 0) return INFEASIBLE;
  30.104 -      
  30.105 +
  30.106  
  30.107        // Initialize vectors
  30.108        for (int i = 0; i != _res_node_num; ++i) {
  30.109          _pi[i] = 0;
  30.110        }
  30.111        ValueVector excess(_supply);
  30.112 -      
  30.113 +
  30.114        // Remove infinite upper bounds and check negative arcs
  30.115        const Value MAX = std::numeric_limits<Value>::max();
  30.116        int last_out;
  30.117 @@ -770,10 +770,10 @@
  30.118            _cost[ra] = 0;
  30.119          }
  30.120        }
  30.121 -      
  30.122 +
  30.123        return OPTIMAL;
  30.124      }
  30.125 -    
  30.126 +
  30.127      // Build a StaticDigraph structure containing the current
  30.128      // residual network
  30.129      void buildResidualNetwork() {
  30.130 @@ -829,14 +829,14 @@
  30.131        // Constants for computing the iteration limits
  30.132        const int BF_FIRST_LIMIT  = 2;
  30.133        const double BF_LIMIT_FACTOR = 1.5;
  30.134 -      
  30.135 +
  30.136        typedef StaticVectorMap<StaticDigraph::Arc, Value> FilterMap;
  30.137        typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;
  30.138        typedef StaticVectorMap<StaticDigraph::Node, StaticDigraph::Arc> PredMap;
  30.139        typedef typename BellmanFord<ResDigraph, CostArcMap>
  30.140          ::template SetDistMap<CostNodeMap>
  30.141          ::template SetPredMap<PredMap>::Create BF;
  30.142 -      
  30.143 +
  30.144        // Build the residual network
  30.145        _arc_vec.clear();
  30.146        _cost_vec.clear();
  30.147 @@ -926,7 +926,7 @@
  30.148        typedef typename SPath::ArcIt SPathArcIt;
  30.149        typedef typename HowardMmc<StaticDigraph, CostArcMap>
  30.150          ::template SetPath<SPath>::Create MMC;
  30.151 -      
  30.152 +
  30.153        SPath cycle;
  30.154        MMC mmc(_sgr, _cost_map);
  30.155        mmc.cycle(cycle);
  30.156 @@ -949,7 +949,7 @@
  30.157            _res_cap[_reverse[j]] += delta;
  30.158          }
  30.159  
  30.160 -        // Rebuild the residual network        
  30.161 +        // Rebuild the residual network
  30.162          buildResidualNetwork();
  30.163        }
  30.164      }
  30.165 @@ -1143,7 +1143,7 @@
  30.166            epsilon = -mmc.cycleMean();
  30.167            Cost cycle_cost = mmc.cycleCost();
  30.168            int cycle_size = mmc.cycleSize();
  30.169 -          
  30.170 +
  30.171            // Compute feasible potentials for the current epsilon
  30.172            for (int i = 0; i != int(_cost_vec.size()); ++i) {
  30.173              _cost_vec[i] = cycle_size * _cost_vec[i] - cycle_cost;
  30.174 @@ -1155,7 +1155,7 @@
  30.175            for (int u = 0; u != _res_node_num; ++u) {
  30.176              pi[u] = static_cast<double>(_pi[u]) / cycle_size;
  30.177            }
  30.178 -        
  30.179 +
  30.180            iter = limit;
  30.181          }
  30.182        }
    31.1 --- a/lemon/dfs.h	Wed Mar 17 12:35:52 2010 +0100
    31.2 +++ b/lemon/dfs.h	Sat Mar 06 14:35:12 2010 +0000
    31.3 @@ -2,7 +2,7 @@
    31.4   *
    31.5   * This file is a part of LEMON, a generic C++ optimization library.
    31.6   *
    31.7 - * Copyright (C) 2003-2009
    31.8 + * Copyright (C) 2003-2010
    31.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   31.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   31.11   *
   31.12 @@ -82,7 +82,8 @@
   31.13      ///The type of the map that indicates which nodes are reached.
   31.14  
   31.15      ///The type of the map that indicates which nodes are reached.
   31.16 -    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.17 +    ///It must conform to
   31.18 +    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.19      typedef typename Digraph::template NodeMap<bool> ReachedMap;
   31.20      ///Instantiates a \c ReachedMap.
   31.21  
   31.22 @@ -270,7 +271,8 @@
   31.23      ///
   31.24      ///\ref named-templ-param "Named parameter" for setting
   31.25      ///\c ReachedMap type.
   31.26 -    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.27 +    ///It must conform to
   31.28 +    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.29      template <class T>
   31.30      struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
   31.31        typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
   31.32 @@ -802,7 +804,8 @@
   31.33      ///The type of the map that indicates which nodes are reached.
   31.34  
   31.35      ///The type of the map that indicates which nodes are reached.
   31.36 -    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.37 +    ///It must conform to
   31.38 +    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.39      typedef typename Digraph::template NodeMap<bool> ReachedMap;
   31.40      ///Instantiates a ReachedMap.
   31.41  
   31.42 @@ -1207,7 +1210,8 @@
   31.43      /// \brief The type of the map that indicates which nodes are reached.
   31.44      ///
   31.45      /// The type of the map that indicates which nodes are reached.
   31.46 -    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.47 +    /// It must conform to the
   31.48 +    /// \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   31.49      typedef typename Digraph::template NodeMap<bool> ReachedMap;
   31.50  
   31.51      /// \brief Instantiates a ReachedMap.
    32.1 --- a/lemon/dijkstra.h	Wed Mar 17 12:35:52 2010 +0100
    32.2 +++ b/lemon/dijkstra.h	Sat Mar 06 14:35:12 2010 +0000
    32.3 @@ -2,7 +2,7 @@
    32.4   *
    32.5   * This file is a part of LEMON, a generic C++ optimization library.
    32.6   *
    32.7 - * Copyright (C) 2003-2009
    32.8 + * Copyright (C) 2003-2010
    32.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   32.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   32.11   *
    33.1 --- a/lemon/dimacs.h	Wed Mar 17 12:35:52 2010 +0100
    33.2 +++ b/lemon/dimacs.h	Sat Mar 06 14:35:12 2010 +0000
    33.3 @@ -2,7 +2,7 @@
    33.4   *
    33.5   * This file is a part of LEMON, a generic C++ optimization library.
    33.6   *
    33.7 - * Copyright (C) 2003-2009
    33.8 + * Copyright (C) 2003-2010
    33.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   33.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   33.11   *
   33.12 @@ -61,7 +61,7 @@
   33.13    ///Discover the type of a DIMACS file
   33.14  
   33.15    ///This function starts seeking the beginning of the given file for the
   33.16 -  ///problem type and size info. 
   33.17 +  ///problem type and size info.
   33.18    ///The found data is returned in a special struct that can be evaluated
   33.19    ///and passed to the appropriate reader function.
   33.20    DimacsDescriptor dimacsType(std::istream& is)
   33.21 @@ -212,7 +212,7 @@
   33.22        infty = std::numeric_limits<Capacity>::has_infinity ?
   33.23          std::numeric_limits<Capacity>::infinity() :
   33.24          std::numeric_limits<Capacity>::max();
   33.25 - 
   33.26 +
   33.27      while (is >> c) {
   33.28        switch (c) {
   33.29        case 'c': // comment line
   33.30 @@ -237,7 +237,7 @@
   33.31            getline(is, str);
   33.32            e = g.addArc(nodes[i], nodes[j]);
   33.33            capacity.set(e, _cap);
   33.34 -        } 
   33.35 +        }
   33.36          else if (desc.type==DimacsDescriptor::MAX) {
   33.37            is >> i >> j >> _cap;
   33.38            getline(is, str);
   33.39 @@ -362,11 +362,11 @@
   33.40    {
   33.41      g.addArc(s,t);
   33.42    }
   33.43 -  
   33.44 +
   33.45    /// \brief DIMACS plain (di)graph reader function.
   33.46    ///
   33.47    /// This function reads a plain (di)graph without any designated nodes
   33.48 -  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
   33.49 +  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
   33.50    /// DIMACS files having a line starting with
   33.51    /// \code
   33.52    ///   p mat
   33.53 @@ -392,7 +392,7 @@
   33.54      for (int k = 1; k <= desc.nodeNum; ++k) {
   33.55        nodes[k] = g.addNode();
   33.56      }
   33.57 -    
   33.58 +
   33.59      while (is >> c) {
   33.60        switch (c) {
   33.61        case 'c': // comment line
    34.1 --- a/lemon/edge_set.h	Wed Mar 17 12:35:52 2010 +0100
    34.2 +++ b/lemon/edge_set.h	Sat Mar 06 14:35:12 2010 +0000
    34.3 @@ -2,7 +2,7 @@
    34.4   *
    34.5   * This file is a part of LEMON, a generic C++ optimization library.
    34.6   *
    34.7 - * Copyright (C) 2003-2008
    34.8 + * Copyright (C) 2003-2010
    34.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   34.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   34.11   *
    35.1 --- a/lemon/euler.h	Wed Mar 17 12:35:52 2010 +0100
    35.2 +++ b/lemon/euler.h	Sat Mar 06 14:35:12 2010 +0000
    35.3 @@ -2,7 +2,7 @@
    35.4   *
    35.5   * This file is a part of LEMON, a generic C++ optimization library.
    35.6   *
    35.7 - * Copyright (C) 2003-2009
    35.8 + * Copyright (C) 2003-2010
    35.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   35.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   35.11   *
   35.12 @@ -26,7 +26,7 @@
   35.13  
   35.14  /// \ingroup graph_properties
   35.15  /// \file
   35.16 -/// \brief Euler tour iterators and a function for checking the \e Eulerian 
   35.17 +/// \brief Euler tour iterators and a function for checking the \e Eulerian
   35.18  /// property.
   35.19  ///
   35.20  ///This file provides Euler tour iterators and a function to check
   35.21 @@ -41,7 +41,7 @@
   35.22    ///graph (if there exists) and it converts to the \c Arc type of the digraph.
   35.23    ///
   35.24    ///For example, if the given digraph has an Euler tour (i.e it has only one
   35.25 -  ///non-trivial component and the in-degree is equal to the out-degree 
   35.26 +  ///non-trivial component and the in-degree is equal to the out-degree
   35.27    ///for all nodes), then the following code will put the arcs of \c g
   35.28    ///to the vector \c et according to an Euler tour of \c g.
   35.29    ///\code
   35.30 @@ -138,7 +138,7 @@
   35.31    ///\e undirected graph (if there exists) and it converts to the \c Arc
   35.32    ///and \c Edge types of the graph.
   35.33    ///
   35.34 -  ///For example, if the given graph has an Euler tour (i.e it has only one 
   35.35 +  ///For example, if the given graph has an Euler tour (i.e it has only one
   35.36    ///non-trivial component and the degree of each node is even),
   35.37    ///the following code will print the arc IDs according to an
   35.38    ///Euler tour of \c g.
   35.39 @@ -147,7 +147,7 @@
   35.40    ///    std::cout << g.id(Edge(e)) << std::eol;
   35.41    ///  }
   35.42    ///\endcode
   35.43 -  ///Although this iterator is for undirected graphs, it still returns 
   35.44 +  ///Although this iterator is for undirected graphs, it still returns
   35.45    ///arcs in order to indicate the direction of the tour.
   35.46    ///(But arcs convert to edges, of course.)
   35.47    ///
   35.48 @@ -233,7 +233,7 @@
   35.49  
   35.50      /// Postfix incrementation.
   35.51      ///
   35.52 -    ///\warning This incrementation returns an \c Arc (which converts to 
   35.53 +    ///\warning This incrementation returns an \c Arc (which converts to
   35.54      ///an \c Edge), not an \ref EulerIt, as one may expect.
   35.55      Arc operator++(int)
   35.56      {
    36.1 --- a/lemon/fractional_matching.h	Wed Mar 17 12:35:52 2010 +0100
    36.2 +++ b/lemon/fractional_matching.h	Sat Mar 06 14:35:12 2010 +0000
    36.3 @@ -2,7 +2,7 @@
    36.4   *
    36.5   * This file is a part of LEMON, a generic C++ optimization library.
    36.6   *
    36.7 - * Copyright (C) 2003-2009
    36.8 + * Copyright (C) 2003-2010
    36.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   36.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   36.11   *
   36.12 @@ -2009,7 +2009,7 @@
   36.13  
   36.14      /// \brief Run the algorithm.
   36.15      ///
   36.16 -    /// This method runs the \c %MaxWeightedPerfectFractionalMatching 
   36.17 +    /// This method runs the \c %MaxWeightedPerfectFractionalMatching
   36.18      /// algorithm.
   36.19      ///
   36.20      /// \note mwfm.run() is just a shortcut of the following code.
    37.1 --- a/lemon/full_graph.h	Wed Mar 17 12:35:52 2010 +0100
    37.2 +++ b/lemon/full_graph.h	Sat Mar 06 14:35:12 2010 +0000
    37.3 @@ -2,7 +2,7 @@
    37.4   *
    37.5   * This file is a part of LEMON, a generic C++ optimization library.
    37.6   *
    37.7 - * Copyright (C) 2003-2009
    37.8 + * Copyright (C) 2003-2010
    37.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   37.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   37.11   *
   37.12 @@ -203,7 +203,7 @@
   37.13  
   37.14      /// \brief Returns the node with the given index.
   37.15      ///
   37.16 -    /// Returns the node with the given index. Since this structure is 
   37.17 +    /// Returns the node with the given index. Since this structure is
   37.18      /// completely static, the nodes can be indexed with integers from
   37.19      /// the range <tt>[0..nodeNum()-1]</tt>.
   37.20      /// The index of a node is the same as its ID.
   37.21 @@ -212,7 +212,7 @@
   37.22  
   37.23      /// \brief Returns the index of the given node.
   37.24      ///
   37.25 -    /// Returns the index of the given node. Since this structure is 
   37.26 +    /// Returns the index of the given node. Since this structure is
   37.27      /// completely static, the nodes can be indexed with integers from
   37.28      /// the range <tt>[0..nodeNum()-1]</tt>.
   37.29      /// The index of a node is the same as its ID.
   37.30 @@ -582,7 +582,7 @@
   37.31  
   37.32      /// \brief Returns the node with the given index.
   37.33      ///
   37.34 -    /// Returns the node with the given index. Since this structure is 
   37.35 +    /// Returns the node with the given index. Since this structure is
   37.36      /// completely static, the nodes can be indexed with integers from
   37.37      /// the range <tt>[0..nodeNum()-1]</tt>.
   37.38      /// The index of a node is the same as its ID.
   37.39 @@ -591,7 +591,7 @@
   37.40  
   37.41      /// \brief Returns the index of the given node.
   37.42      ///
   37.43 -    /// Returns the index of the given node. Since this structure is 
   37.44 +    /// Returns the index of the given node. Since this structure is
   37.45      /// completely static, the nodes can be indexed with integers from
   37.46      /// the range <tt>[0..nodeNum()-1]</tt>.
   37.47      /// The index of a node is the same as its ID.
    38.1 --- a/lemon/glpk.cc	Wed Mar 17 12:35:52 2010 +0100
    38.2 +++ b/lemon/glpk.cc	Sat Mar 06 14:35:12 2010 +0000
    38.3 @@ -2,7 +2,7 @@
    38.4   *
    38.5   * This file is a part of LEMON, a generic C++ optimization library.
    38.6   *
    38.7 - * Copyright (C) 2003-2009
    38.8 + * Copyright (C) 2003-2010
    38.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   38.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   38.11   *
   38.12 @@ -59,7 +59,7 @@
   38.13      return i;
   38.14    }
   38.15  
   38.16 -  int GlpkBase::_addRow(Value lo, ExprIterator b, 
   38.17 +  int GlpkBase::_addRow(Value lo, ExprIterator b,
   38.18                          ExprIterator e, Value up) {
   38.19      int i = glp_add_rows(lp, 1);
   38.20  
   38.21 @@ -68,11 +68,11 @@
   38.22          glp_set_row_bnds(lp, i, GLP_FR, lo, up);
   38.23        } else {
   38.24          glp_set_row_bnds(lp, i, GLP_UP, lo, up);
   38.25 -      }    
   38.26 +      }
   38.27      } else {
   38.28        if (up == INF) {
   38.29          glp_set_row_bnds(lp, i, GLP_LO, lo, up);
   38.30 -      } else if (lo != up) {        
   38.31 +      } else if (lo != up) {
   38.32          glp_set_row_bnds(lp, i, GLP_DB, lo, up);
   38.33        } else {
   38.34          glp_set_row_bnds(lp, i, GLP_FX, lo, up);
    39.1 --- a/lemon/glpk.h	Wed Mar 17 12:35:52 2010 +0100
    39.2 +++ b/lemon/glpk.h	Sat Mar 06 14:35:12 2010 +0000
    39.3 @@ -2,7 +2,7 @@
    39.4   *
    39.5   * This file is a part of LEMON, a generic C++ optimization library.
    39.6   *
    39.7 - * Copyright (C) 2003-2008
    39.8 + * Copyright (C) 2003-2010
    39.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   39.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   39.11   *
   39.12 @@ -30,7 +30,7 @@
   39.13    namespace _solver_bits {
   39.14      class VoidPtr {
   39.15      private:
   39.16 -      void *_ptr;      
   39.17 +      void *_ptr;
   39.18      public:
   39.19        VoidPtr() : _ptr(0) {}
   39.20  
   39.21 @@ -38,8 +38,8 @@
   39.22        VoidPtr(T* ptr) : _ptr(reinterpret_cast<void*>(ptr)) {}
   39.23  
   39.24        template <typename T>
   39.25 -      VoidPtr& operator=(T* ptr) { 
   39.26 -        _ptr = reinterpret_cast<void*>(ptr); 
   39.27 +      VoidPtr& operator=(T* ptr) {
   39.28 +        _ptr = reinterpret_cast<void*>(ptr);
   39.29          return *this;
   39.30        }
   39.31  
   39.32 @@ -124,13 +124,13 @@
   39.33          freeEnv();
   39.34        }
   39.35      };
   39.36 -    
   39.37 +
   39.38      static FreeEnvHelper freeEnvHelper;
   39.39  
   39.40    protected:
   39.41 -    
   39.42 +
   39.43      int _message_level;
   39.44 -    
   39.45 +
   39.46    public:
   39.47  
   39.48      ///Pointer to the underlying GLPK data structure.
    40.1 --- a/lemon/gomory_hu.h	Wed Mar 17 12:35:52 2010 +0100
    40.2 +++ b/lemon/gomory_hu.h	Sat Mar 06 14:35:12 2010 +0000
    40.3 @@ -1,8 +1,8 @@
    40.4 -/* -*- C++ -*-
    40.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    40.6   *
    40.7 - * This file is a part of LEMON, a generic C++ optimization library
    40.8 + * This file is a part of LEMON, a generic C++ optimization library.
    40.9   *
   40.10 - * Copyright (C) 2003-2008
   40.11 + * Copyright (C) 2003-2010
   40.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   40.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   40.14   *
   40.15 @@ -27,7 +27,7 @@
   40.16  #include <lemon/concepts/maps.h>
   40.17  
   40.18  /// \ingroup min_cut
   40.19 -/// \file 
   40.20 +/// \file
   40.21  /// \brief Gomory-Hu cut tree in graphs.
   40.22  
   40.23  namespace lemon {
   40.24 @@ -38,13 +38,13 @@
   40.25    ///
   40.26    /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   40.27    /// may contain edges which are not in the original graph. It has the
   40.28 -  /// property that the minimum capacity edge of the path between two nodes 
   40.29 +  /// property that the minimum capacity edge of the path between two nodes
   40.30    /// in this tree has the same weight as the minimum cut in the graph
   40.31    /// between these nodes. Moreover the components obtained by removing
   40.32    /// this edge from the tree determine the corresponding minimum cut.
   40.33    /// Therefore once this tree is computed, the minimum cut between any pair
   40.34    /// of nodes can easily be obtained.
   40.35 -  /// 
   40.36 +  ///
   40.37    /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
   40.38    /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
   40.39    /// time complexity. It calculates a rooted Gomory-Hu tree.
   40.40 @@ -60,10 +60,10 @@
   40.41    /// The default map type is \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
   40.42  #ifdef DOXYGEN
   40.43    template <typename GR,
   40.44 -	    typename CAP>
   40.45 +            typename CAP>
   40.46  #else
   40.47    template <typename GR,
   40.48 -	    typename CAP = typename GR::template EdgeMap<int> >
   40.49 +            typename CAP = typename GR::template EdgeMap<int> >
   40.50  #endif
   40.51    class GomoryHu {
   40.52    public:
   40.53 @@ -74,7 +74,7 @@
   40.54      typedef CAP Capacity;
   40.55      /// The value type of capacities
   40.56      typedef typename Capacity::Value Value;
   40.57 -    
   40.58 +
   40.59    private:
   40.60  
   40.61      TEMPLATE_GRAPH_TYPEDEFS(Graph);
   40.62 @@ -89,28 +89,28 @@
   40.63  
   40.64      void createStructures() {
   40.65        if (!_pred) {
   40.66 -	_pred = new typename Graph::template NodeMap<Node>(_graph);
   40.67 +        _pred = new typename Graph::template NodeMap<Node>(_graph);
   40.68        }
   40.69        if (!_weight) {
   40.70 -	_weight = new typename Graph::template NodeMap<Value>(_graph);
   40.71 +        _weight = new typename Graph::template NodeMap<Value>(_graph);
   40.72        }
   40.73        if (!_order) {
   40.74 -	_order = new typename Graph::template NodeMap<int>(_graph);
   40.75 +        _order = new typename Graph::template NodeMap<int>(_graph);
   40.76        }
   40.77      }
   40.78  
   40.79      void destroyStructures() {
   40.80        if (_pred) {
   40.81 -	delete _pred;
   40.82 +        delete _pred;
   40.83        }
   40.84        if (_weight) {
   40.85 -	delete _weight;
   40.86 +        delete _weight;
   40.87        }
   40.88        if (_order) {
   40.89 -	delete _order;
   40.90 +        delete _order;
   40.91        }
   40.92      }
   40.93 -  
   40.94 +
   40.95    public:
   40.96  
   40.97      /// \brief Constructor
   40.98 @@ -118,9 +118,9 @@
   40.99      /// Constructor.
  40.100      /// \param graph The undirected graph the algorithm runs on.
  40.101      /// \param capacity The edge capacity map.
  40.102 -    GomoryHu(const Graph& graph, const Capacity& capacity) 
  40.103 +    GomoryHu(const Graph& graph, const Capacity& capacity)
  40.104        : _graph(graph), _capacity(capacity),
  40.105 -	_pred(0), _weight(0), _order(0) 
  40.106 +        _pred(0), _weight(0), _order(0)
  40.107      {
  40.108        checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
  40.109      }
  40.110 @@ -134,7 +134,7 @@
  40.111      }
  40.112  
  40.113    private:
  40.114 -  
  40.115 +
  40.116      // Initialize the internal data structures
  40.117      void init() {
  40.118        createStructures();
  40.119 @@ -145,7 +145,7 @@
  40.120          (*_order)[n] = -1;
  40.121        }
  40.122        (*_pred)[_root] = INVALID;
  40.123 -      (*_weight)[_root] = std::numeric_limits<Value>::max(); 
  40.124 +      (*_weight)[_root] = std::numeric_limits<Value>::max();
  40.125      }
  40.126  
  40.127  
  40.128 @@ -154,50 +154,50 @@
  40.129        Preflow<Graph, Capacity> fa(_graph, _capacity, _root, INVALID);
  40.130  
  40.131        for (NodeIt n(_graph); n != INVALID; ++n) {
  40.132 -	if (n == _root) continue;
  40.133 +        if (n == _root) continue;
  40.134  
  40.135 -	Node pn = (*_pred)[n];
  40.136 -	fa.source(n);
  40.137 -	fa.target(pn);
  40.138 +        Node pn = (*_pred)[n];
  40.139 +        fa.source(n);
  40.140 +        fa.target(pn);
  40.141  
  40.142 -	fa.runMinCut();
  40.143 +        fa.runMinCut();
  40.144  
  40.145 -	(*_weight)[n] = fa.flowValue();
  40.146 +        (*_weight)[n] = fa.flowValue();
  40.147  
  40.148 -	for (NodeIt nn(_graph); nn != INVALID; ++nn) {
  40.149 -	  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
  40.150 -	    (*_pred)[nn] = n;
  40.151 -	  }
  40.152 -	}
  40.153 -	if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
  40.154 -	  (*_pred)[n] = (*_pred)[pn];
  40.155 -	  (*_pred)[pn] = n;
  40.156 -	  (*_weight)[n] = (*_weight)[pn];
  40.157 -	  (*_weight)[pn] = fa.flowValue();
  40.158 -	}
  40.159 +        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
  40.160 +          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
  40.161 +            (*_pred)[nn] = n;
  40.162 +          }
  40.163 +        }
  40.164 +        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
  40.165 +          (*_pred)[n] = (*_pred)[pn];
  40.166 +          (*_pred)[pn] = n;
  40.167 +          (*_weight)[n] = (*_weight)[pn];
  40.168 +          (*_weight)[pn] = fa.flowValue();
  40.169 +        }
  40.170        }
  40.171  
  40.172        (*_order)[_root] = 0;
  40.173        int index = 1;
  40.174  
  40.175        for (NodeIt n(_graph); n != INVALID; ++n) {
  40.176 -	std::vector<Node> st;
  40.177 -	Node nn = n;
  40.178 -	while ((*_order)[nn] == -1) {
  40.179 -	  st.push_back(nn);
  40.180 -	  nn = (*_pred)[nn];
  40.181 -	}
  40.182 -	while (!st.empty()) {
  40.183 -	  (*_order)[st.back()] = index++;
  40.184 -	  st.pop_back();
  40.185 -	}
  40.186 +        std::vector<Node> st;
  40.187 +        Node nn = n;
  40.188 +        while ((*_order)[nn] == -1) {
  40.189 +          st.push_back(nn);
  40.190 +          nn = (*_pred)[nn];
  40.191 +        }
  40.192 +        while (!st.empty()) {
  40.193 +          (*_order)[st.back()] = index++;
  40.194 +          st.pop_back();
  40.195 +        }
  40.196        }
  40.197      }
  40.198  
  40.199    public:
  40.200  
  40.201      ///\name Execution Control
  40.202 - 
  40.203 +
  40.204      ///@{
  40.205  
  40.206      /// \brief Run the Gomory-Hu algorithm.
  40.207 @@ -207,7 +207,7 @@
  40.208        init();
  40.209        start();
  40.210      }
  40.211 -    
  40.212 +
  40.213      /// @}
  40.214  
  40.215      ///\name Query Functions
  40.216 @@ -232,7 +232,7 @@
  40.217      /// \brief Return the weight of the predecessor edge in the
  40.218      /// Gomory-Hu tree.
  40.219      ///
  40.220 -    /// This function returns the weight of the predecessor edge of the 
  40.221 +    /// This function returns the weight of the predecessor edge of the
  40.222      /// given node in the Gomory-Hu tree.
  40.223      /// If \c node is the root of the tree, the result is undefined.
  40.224      ///
  40.225 @@ -254,7 +254,7 @@
  40.226      /// \brief Return the minimum cut value between two nodes
  40.227      ///
  40.228      /// This function returns the minimum cut value between the nodes
  40.229 -    /// \c s and \c t. 
  40.230 +    /// \c s and \c t.
  40.231      /// It finds the nearest common ancestor of the given nodes in the
  40.232      /// Gomory-Hu tree and calculates the minimum weight edge on the
  40.233      /// paths to the ancestor.
  40.234 @@ -263,15 +263,15 @@
  40.235      Value minCutValue(const Node& s, const Node& t) const {
  40.236        Node sn = s, tn = t;
  40.237        Value value = std::numeric_limits<Value>::max();
  40.238 -      
  40.239 +
  40.240        while (sn != tn) {
  40.241 -	if ((*_order)[sn] < (*_order)[tn]) {
  40.242 -	  if ((*_weight)[tn] <= value) value = (*_weight)[tn];
  40.243 -	  tn = (*_pred)[tn];
  40.244 -	} else {
  40.245 -	  if ((*_weight)[sn] <= value) value = (*_weight)[sn];
  40.246 -	  sn = (*_pred)[sn];
  40.247 -	}
  40.248 +        if ((*_order)[sn] < (*_order)[tn]) {
  40.249 +          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
  40.250 +          tn = (*_pred)[tn];
  40.251 +        } else {
  40.252 +          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
  40.253 +          sn = (*_pred)[sn];
  40.254 +        }
  40.255        }
  40.256        return value;
  40.257      }
  40.258 @@ -302,23 +302,23 @@
  40.259        bool s_root=false;
  40.260        Node rn = INVALID;
  40.261        Value value = std::numeric_limits<Value>::max();
  40.262 -      
  40.263 +
  40.264        while (sn != tn) {
  40.265 -	if ((*_order)[sn] < (*_order)[tn]) {
  40.266 -	  if ((*_weight)[tn] <= value) {
  40.267 -	    rn = tn;
  40.268 +        if ((*_order)[sn] < (*_order)[tn]) {
  40.269 +          if ((*_weight)[tn] <= value) {
  40.270 +            rn = tn;
  40.271              s_root = false;
  40.272 -	    value = (*_weight)[tn];
  40.273 -	  }
  40.274 -	  tn = (*_pred)[tn];
  40.275 -	} else {
  40.276 -	  if ((*_weight)[sn] <= value) {
  40.277 -	    rn = sn;
  40.278 +            value = (*_weight)[tn];
  40.279 +          }
  40.280 +          tn = (*_pred)[tn];
  40.281 +        } else {
  40.282 +          if ((*_weight)[sn] <= value) {
  40.283 +            rn = sn;
  40.284              s_root = true;
  40.285 -	    value = (*_weight)[sn];
  40.286 -	  }
  40.287 -	  sn = (*_pred)[sn];
  40.288 -	}
  40.289 +            value = (*_weight)[sn];
  40.290 +          }
  40.291 +          sn = (*_pred)[sn];
  40.292 +        }
  40.293        }
  40.294  
  40.295        typename Graph::template NodeMap<bool> reached(_graph, false);
  40.296 @@ -329,18 +329,18 @@
  40.297  
  40.298        std::vector<Node> st;
  40.299        for (NodeIt n(_graph); n != INVALID; ++n) {
  40.300 -	st.clear();
  40.301 +        st.clear();
  40.302          Node nn = n;
  40.303 -	while (!reached[nn]) {
  40.304 -	  st.push_back(nn);
  40.305 -	  nn = (*_pred)[nn];
  40.306 -	}
  40.307 -	while (!st.empty()) {
  40.308 -	  cutMap.set(st.back(), cutMap[nn]);
  40.309 -	  st.pop_back();
  40.310 -	}
  40.311 +        while (!reached[nn]) {
  40.312 +          st.push_back(nn);
  40.313 +          nn = (*_pred)[nn];
  40.314 +        }
  40.315 +        while (!st.empty()) {
  40.316 +          cutMap.set(st.back(), cutMap[nn]);
  40.317 +          st.pop_back();
  40.318 +        }
  40.319        }
  40.320 -      
  40.321 +
  40.322        return value;
  40.323      }
  40.324  
  40.325 @@ -349,7 +349,7 @@
  40.326      friend class MinCutNodeIt;
  40.327  
  40.328      /// Iterate on the nodes of a minimum cut
  40.329 -    
  40.330 +
  40.331      /// This iterator class lists the nodes of a minimum cut found by
  40.332      /// GomoryHu. Before using it, you must allocate a GomoryHu class
  40.333      /// and call its \ref GomoryHu::run() "run()" method.
  40.334 @@ -442,11 +442,11 @@
  40.335          return n;
  40.336        }
  40.337      };
  40.338 -    
  40.339 +
  40.340      friend class MinCutEdgeIt;
  40.341 -    
  40.342 +
  40.343      /// Iterate on the edges of a minimum cut
  40.344 -    
  40.345 +
  40.346      /// This iterator class lists the edges of a minimum cut found by
  40.347      /// GomoryHu. Before using it, you must allocate a GomoryHu class
  40.348      /// and call its \ref GomoryHu::run() "run()" method.
  40.349 @@ -479,7 +479,7 @@
  40.350                _arc_it=typename Graph::OutArcIt(_graph,_node_it);
  40.351            }
  40.352        }
  40.353 -      
  40.354 +
  40.355      public:
  40.356        /// Constructor
  40.357  
  40.358 @@ -548,7 +548,7 @@
  40.359          return *this;
  40.360        }
  40.361        /// Postfix incrementation
  40.362 -      
  40.363 +
  40.364        /// Postfix incrementation.
  40.365        ///
  40.366        /// \warning This incrementation
    41.1 --- a/lemon/graph_to_eps.h	Wed Mar 17 12:35:52 2010 +0100
    41.2 +++ b/lemon/graph_to_eps.h	Sat Mar 06 14:35:12 2010 +0000
    41.3 @@ -2,7 +2,7 @@
    41.4   *
    41.5   * This file is a part of LEMON, a generic C++ optimization library.
    41.6   *
    41.7 - * Copyright (C) 2003-2009
    41.8 + * Copyright (C) 2003-2010
    41.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   41.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   41.11   *
    42.1 --- a/lemon/hao_orlin.h	Wed Mar 17 12:35:52 2010 +0100
    42.2 +++ b/lemon/hao_orlin.h	Sat Mar 06 14:35:12 2010 +0000
    42.3 @@ -2,7 +2,7 @@
    42.4   *
    42.5   * This file is a part of LEMON, a generic C++ optimization library.
    42.6   *
    42.7 - * Copyright (C) 2003-2009
    42.8 + * Copyright (C) 2003-2010
    42.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   42.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   42.11   *
   42.12 @@ -31,7 +31,7 @@
   42.13  /// \ingroup min_cut
   42.14  /// \brief Implementation of the Hao-Orlin algorithm.
   42.15  ///
   42.16 -/// Implementation of the Hao-Orlin algorithm for finding a minimum cut 
   42.17 +/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
   42.18  /// in a digraph.
   42.19  
   42.20  namespace lemon {
   42.21 @@ -41,7 +41,7 @@
   42.22    /// \brief Hao-Orlin algorithm for finding a minimum cut in a digraph.
   42.23    ///
   42.24    /// This class implements the Hao-Orlin algorithm for finding a minimum
   42.25 -  /// value cut in a directed graph \f$D=(V,A)\f$. 
   42.26 +  /// value cut in a directed graph \f$D=(V,A)\f$.
   42.27    /// It takes a fixed node \f$ source \in V \f$ and
   42.28    /// consists of two phases: in the first phase it determines a
   42.29    /// minimum cut with \f$ source \f$ on the source-side (i.e. a set
   42.30 @@ -58,7 +58,7 @@
   42.31    ///
   42.32    /// For an undirected graph you can run just the first phase of the
   42.33    /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
   42.34 -  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ 
   42.35 +  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
   42.36    /// time. It is implemented in the NagamochiIbaraki algorithm class.
   42.37    ///
   42.38    /// \tparam GR The type of the digraph the algorithm runs on.
   42.39 @@ -76,7 +76,7 @@
   42.40  #endif
   42.41    class HaoOrlin {
   42.42    public:
   42.43 -   
   42.44 +
   42.45      /// The digraph type of the algorithm
   42.46      typedef GR Digraph;
   42.47      /// The capacity map type of the algorithm
   42.48 @@ -864,7 +864,7 @@
   42.49      /// \brief Initialize the internal data structures.
   42.50      ///
   42.51      /// This function initializes the internal data structures. It creates
   42.52 -    /// the maps and some bucket structures for the algorithm. 
   42.53 +    /// the maps and some bucket structures for the algorithm.
   42.54      /// The given node is used as the source node for the push-relabel
   42.55      /// algorithm.
   42.56      void init(const Node& source) {
   42.57 @@ -944,7 +944,7 @@
   42.58  
   42.59      /// \brief Run the algorithm.
   42.60      ///
   42.61 -    /// This function runs the algorithm. It uses the given \c source node, 
   42.62 +    /// This function runs the algorithm. It uses the given \c source node,
   42.63      /// finds a proper \c target node and then calls the \ref init(),
   42.64      /// \ref calculateOut() and \ref calculateIn().
   42.65      void run(const Node& s) {
   42.66 @@ -958,7 +958,7 @@
   42.67      /// \name Query Functions
   42.68      /// The result of the %HaoOrlin algorithm
   42.69      /// can be obtained using these functions.\n
   42.70 -    /// \ref run(), \ref calculateOut() or \ref calculateIn() 
   42.71 +    /// \ref run(), \ref calculateOut() or \ref calculateIn()
   42.72      /// should be called before using them.
   42.73  
   42.74      /// @{
   42.75 @@ -967,7 +967,7 @@
   42.76      ///
   42.77      /// This function returns the value of the minimum cut.
   42.78      ///
   42.79 -    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
   42.80 +    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
   42.81      /// must be called before using this function.
   42.82      Value minCutValue() const {
   42.83        return _min_cut;
   42.84 @@ -986,7 +986,7 @@
   42.85      ///
   42.86      /// \return The value of the minimum cut.
   42.87      ///
   42.88 -    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
   42.89 +    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
   42.90      /// must be called before using this function.
   42.91      template <typename CutMap>
   42.92      Value minCutMap(CutMap& cutMap) const {
    43.1 --- a/lemon/hartmann_orlin_mmc.h	Wed Mar 17 12:35:52 2010 +0100
    43.2 +++ b/lemon/hartmann_orlin_mmc.h	Sat Mar 06 14:35:12 2010 +0000
    43.3 @@ -1,8 +1,8 @@
    43.4 -/* -*- C++ -*-
    43.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    43.6   *
    43.7 - * This file is a part of LEMON, a generic C++ optimization library
    43.8 + * This file is a part of LEMON, a generic C++ optimization library.
    43.9   *
   43.10 - * Copyright (C) 2003-2008
   43.11 + * Copyright (C) 2003-2010
   43.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   43.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   43.14   *
   43.15 @@ -343,14 +343,14 @@
   43.16        // Initialization and find strongly connected components
   43.17        init();
   43.18        findComponents();
   43.19 -      
   43.20 +
   43.21        // Find the minimum cycle mean in the components
   43.22        for (int comp = 0; comp < _comp_num; ++comp) {
   43.23          if (!initComponent(comp)) continue;
   43.24          processRounds();
   43.25 -        
   43.26 +
   43.27          // Update the best cycle (global minimum mean cycle)
   43.28 -        if ( _curr_found && (!_best_found || 
   43.29 +        if ( _curr_found && (!_best_found ||
   43.30               _curr_cost * _best_size < _best_cost * _curr_size) ) {
   43.31            _best_found = true;
   43.32            _best_cost = _curr_cost;
   43.33 @@ -503,7 +503,7 @@
   43.34        int n = _nodes->size();
   43.35        if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
   43.36          return false;
   43.37 -      }      
   43.38 +      }
   43.39        for (int i = 0; i < n; ++i) {
   43.40          _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
   43.41        }
   43.42 @@ -576,7 +576,7 @@
   43.43          }
   43.44        }
   43.45      }
   43.46 -    
   43.47 +
   43.48      // Check early termination
   43.49      bool checkTermination(int k) {
   43.50        typedef std::pair<int, int> Pair;
   43.51 @@ -586,7 +586,7 @@
   43.52        LargeCost cost;
   43.53        int size;
   43.54        Node u;
   43.55 -      
   43.56 +
   43.57        // Search for cycles that are already found
   43.58        _curr_found = false;
   43.59        for (int i = 0; i < n; ++i) {
   43.60 @@ -607,8 +607,8 @@
   43.61            }
   43.62            level[u] = Pair(i, j);
   43.63            if (j != 0) {
   43.64 -	    u = _gr.source(_data[u][j].pred);
   43.65 -	  }
   43.66 +            u = _gr.source(_data[u][j].pred);
   43.67 +          }
   43.68          }
   43.69        }
   43.70  
    44.1 --- a/lemon/howard_mmc.h	Wed Mar 17 12:35:52 2010 +0100
    44.2 +++ b/lemon/howard_mmc.h	Sat Mar 06 14:35:12 2010 +0000
    44.3 @@ -1,8 +1,8 @@
    44.4 -/* -*- C++ -*-
    44.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    44.6   *
    44.7 - * This file is a part of LEMON, a generic C++ optimization library
    44.8 + * This file is a part of LEMON, a generic C++ optimization library.
    44.9   *
   44.10 - * Copyright (C) 2003-2008
   44.11 + * Copyright (C) 2003-2010
   44.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   44.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   44.14   *
   44.15 @@ -121,7 +121,7 @@
   44.16    class HowardMmc
   44.17    {
   44.18    public:
   44.19 -  
   44.20 +
   44.21      /// The type of the digraph
   44.22      typedef typename TR::Digraph Digraph;
   44.23      /// The type of the cost map
   44.24 @@ -152,7 +152,7 @@
   44.25    private:
   44.26  
   44.27      TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
   44.28 -  
   44.29 +
   44.30      // The digraph the algorithm runs on
   44.31      const Digraph &_gr;
   44.32      // The cost of the arcs
   44.33 @@ -179,18 +179,18 @@
   44.34      std::vector<std::vector<Node> > _comp_nodes;
   44.35      std::vector<Node>* _nodes;
   44.36      typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;
   44.37 -    
   44.38 +
   44.39      // Queue used for BFS search
   44.40      std::vector<Node> _queue;
   44.41      int _qfront, _qback;
   44.42  
   44.43      Tolerance _tolerance;
   44.44 -  
   44.45 +
   44.46      // Infinite constant
   44.47      const LargeCost INF;
   44.48  
   44.49    public:
   44.50 -  
   44.51 +
   44.52      /// \name Named Template Parameters
   44.53      /// @{
   44.54  
   44.55 @@ -228,7 +228,7 @@
   44.56        : public HowardMmc<GR, CM, SetPathTraits<T> > {
   44.57        typedef HowardMmc<GR, CM, SetPathTraits<T> > Create;
   44.58      };
   44.59 -    
   44.60 +
   44.61      /// @}
   44.62  
   44.63    protected:
   44.64 @@ -334,7 +334,7 @@
   44.65        // Initialize and find strongly connected components
   44.66        init();
   44.67        findComponents();
   44.68 -      
   44.69 +
   44.70        // Find the minimum cycle mean in the components
   44.71        for (int comp = 0; comp < _comp_num; ++comp) {
   44.72          // Find the minimum mean cycle in the current component
   44.73 @@ -445,7 +445,7 @@
   44.74        _best_size = 1;
   44.75        _cycle_path->clear();
   44.76      }
   44.77 -    
   44.78 +
   44.79      // Find strongly connected components and initialize _comp_nodes
   44.80      // and _in_arcs
   44.81      void findComponents() {
    45.1 --- a/lemon/karp_mmc.h	Wed Mar 17 12:35:52 2010 +0100
    45.2 +++ b/lemon/karp_mmc.h	Sat Mar 06 14:35:12 2010 +0000
    45.3 @@ -1,8 +1,8 @@
    45.4 -/* -*- C++ -*-
    45.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    45.6   *
    45.7 - * This file is a part of LEMON, a generic C++ optimization library
    45.8 + * This file is a part of LEMON, a generic C++ optimization library.
    45.9   *
   45.10 - * Copyright (C) 2003-2008
   45.11 + * Copyright (C) 2003-2010
   45.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   45.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   45.14   *
   45.15 @@ -191,7 +191,7 @@
   45.16      std::vector<Node> _process;
   45.17  
   45.18      Tolerance _tolerance;
   45.19 -    
   45.20 +
   45.21      // Infinite constant
   45.22      const LargeCost INF;
   45.23  
   45.24 @@ -339,7 +339,7 @@
   45.25        // Initialization and find strongly connected components
   45.26        init();
   45.27        findComponents();
   45.28 -      
   45.29 +
   45.30        // Find the minimum cycle mean in the components
   45.31        for (int comp = 0; comp < _comp_num; ++comp) {
   45.32          if (!initComponent(comp)) continue;
   45.33 @@ -489,7 +489,7 @@
   45.34        int n = _nodes->size();
   45.35        if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
   45.36          return false;
   45.37 -      }      
   45.38 +      }
   45.39        for (int i = 0; i < n; ++i) {
   45.40          _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
   45.41        }
    46.1 --- a/lemon/lgf_reader.h	Wed Mar 17 12:35:52 2010 +0100
    46.2 +++ b/lemon/lgf_reader.h	Sat Mar 06 14:35:12 2010 +0000
    46.3 @@ -2,7 +2,7 @@
    46.4   *
    46.5   * This file is a part of LEMON, a generic C++ optimization library.
    46.6   *
    46.7 - * Copyright (C) 2003-2009
    46.8 + * Copyright (C) 2003-2010
    46.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   46.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   46.11   *
   46.12 @@ -562,7 +562,7 @@
   46.13      template <typename TDGR>
   46.14      friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
   46.15      template <typename TDGR>
   46.16 -    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, 
   46.17 +    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
   46.18                                               const std::string& fn);
   46.19      template <typename TDGR>
   46.20      friend DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn);
   46.21 @@ -1187,14 +1187,14 @@
   46.22      /// @}
   46.23  
   46.24    };
   46.25 -  
   46.26 +
   46.27    /// \ingroup lemon_io
   46.28    ///
   46.29    /// \brief Return a \ref DigraphReader class
   46.30    ///
   46.31    /// This function just returns a \ref DigraphReader class.
   46.32    ///
   46.33 -  /// With this function a digraph can be read from an 
   46.34 +  /// With this function a digraph can be read from an
   46.35    /// \ref lgf-format "LGF" file or input stream with several maps and
   46.36    /// attributes. For example, there is network flow problem on a
   46.37    /// digraph, i.e. a digraph with a \e capacity map on the arcs and
   46.38 @@ -1249,7 +1249,7 @@
   46.39  
   46.40    template <typename GR>
   46.41    class GraphReader;
   46.42 - 
   46.43 +
   46.44    template <typename TGR>
   46.45    GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
   46.46    template <typename TGR>
   46.47 @@ -1386,7 +1386,7 @@
   46.48      template <typename TGR>
   46.49      friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
   46.50      template <typename TGR>
   46.51 -    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 
   46.52 +    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
   46.53      template <typename TGR>
   46.54      friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
   46.55  
   46.56 @@ -2063,9 +2063,9 @@
   46.57    ///
   46.58    /// \brief Return a \ref GraphReader class
   46.59    ///
   46.60 -  /// This function just returns a \ref GraphReader class. 
   46.61 +  /// This function just returns a \ref GraphReader class.
   46.62    ///
   46.63 -  /// With this function a graph can be read from an 
   46.64 +  /// With this function a graph can be read from an
   46.65    /// \ref lgf-format "LGF" file or input stream with several maps and
   46.66    /// attributes. For example, there is weighted matching problem on a
   46.67    /// graph, i.e. a graph with a \e weight map on the edges. This
    47.1 --- a/lemon/lgf_writer.h	Wed Mar 17 12:35:52 2010 +0100
    47.2 +++ b/lemon/lgf_writer.h	Sat Mar 06 14:35:12 2010 +0000
    47.3 @@ -2,7 +2,7 @@
    47.4   *
    47.5   * This file is a part of LEMON, a generic C++ optimization library.
    47.6   *
    47.7 - * Copyright (C) 2003-2009
    47.8 + * Copyright (C) 2003-2010
    47.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   47.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   47.11   *
   47.12 @@ -351,7 +351,7 @@
   47.13    class DigraphWriter;
   47.14  
   47.15    template <typename TDGR>
   47.16 -  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
   47.17 +  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   47.18                                     std::ostream& os = std::cout);
   47.19    template <typename TDGR>
   47.20    DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const std::string& fn);
   47.21 @@ -504,7 +504,7 @@
   47.22    private:
   47.23  
   47.24      template <typename TDGR>
   47.25 -    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
   47.26 +    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   47.27                                               std::ostream& os);
   47.28      template <typename TDGR>
   47.29      friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   47.30 @@ -917,7 +917,7 @@
   47.31    ///
   47.32    /// \brief Return a \ref DigraphWriter class
   47.33    ///
   47.34 -  /// This function just returns a \ref DigraphWriter class. 
   47.35 +  /// This function just returns a \ref DigraphWriter class.
   47.36    ///
   47.37    /// With this function a digraph can be write to a file or output
   47.38    /// stream in \ref lgf-format "LGF" format with several maps and
   47.39 @@ -957,7 +957,7 @@
   47.40    /// \relates DigraphWriter
   47.41    /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   47.42    template <typename TDGR>
   47.43 -  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
   47.44 +  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   47.45                                      const std::string& fn) {
   47.46      DigraphWriter<TDGR> tmp(digraph, fn);
   47.47      return tmp;
   47.48 @@ -1101,11 +1101,11 @@
   47.49      template <typename TGR>
   47.50      friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
   47.51      template <typename TGR>
   47.52 -    friend GraphWriter<TGR> graphWriter(const TGR& graph, 
   47.53 +    friend GraphWriter<TGR> graphWriter(const TGR& graph,
   47.54                                          const std::string& fn);
   47.55      template <typename TGR>
   47.56      friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
   47.57 -    
   47.58 +
   47.59      GraphWriter(GraphWriter& other)
   47.60        : _os(other._os), local_os(other.local_os), _graph(other._graph),
   47.61          _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
   47.62 @@ -1556,7 +1556,7 @@
   47.63    ///
   47.64    /// \brief Return a \ref GraphWriter class
   47.65    ///
   47.66 -  /// This function just returns a \ref GraphWriter class. 
   47.67 +  /// This function just returns a \ref GraphWriter class.
   47.68    ///
   47.69    /// With this function a graph can be write to a file or output
   47.70    /// stream in \ref lgf-format "LGF" format with several maps and
    48.1 --- a/lemon/list_graph.h	Wed Mar 17 12:35:52 2010 +0100
    48.2 +++ b/lemon/list_graph.h	Sat Mar 06 14:35:12 2010 +0000
    48.3 @@ -2,7 +2,7 @@
    48.4   *
    48.5   * This file is a part of LEMON, a generic C++ optimization library.
    48.6   *
    48.7 - * Copyright (C) 2003-2009
    48.8 + * Copyright (C) 2003-2010
    48.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   48.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   48.11   *
   48.12 @@ -446,7 +446,7 @@
   48.13      ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
   48.14      ///invalidated for the outgoing arcs of node \c v and \c InArcIt
   48.15      ///iterators are invalidated for the incomming arcs of \c v.
   48.16 -    ///Moreover all iterators referencing node \c v or the removed 
   48.17 +    ///Moreover all iterators referencing node \c v or the removed
   48.18      ///loops are also invalidated. Other iterators remain valid.
   48.19      ///
   48.20      ///\warning This functionality cannot be used together with the Snapshot
   48.21 @@ -552,7 +552,7 @@
   48.22      /// The newly added nodes and arcs can be removed using the
   48.23      /// restore() function.
   48.24      ///
   48.25 -    /// \note After a state is restored, you cannot restore a later state, 
   48.26 +    /// \note After a state is restored, you cannot restore a later state,
   48.27      /// i.e. you cannot add the removed nodes and arcs again using
   48.28      /// another Snapshot instance.
   48.29      ///
   48.30 @@ -1307,7 +1307,7 @@
   48.31      /// \note The moved edges are joined to node \c a using changeU()
   48.32      /// or changeV(), thus all edge and arc iterators whose base node is
   48.33      /// \c b are invalidated.
   48.34 -    /// Moreover all iterators referencing node \c b or the removed 
   48.35 +    /// Moreover all iterators referencing node \c b or the removed
   48.36      /// loops are also invalidated. Other iterators remain valid.
   48.37      ///
   48.38      ///\warning This functionality cannot be used together with the
   48.39 @@ -1364,7 +1364,7 @@
   48.40      /// The newly added nodes and edges can be removed
   48.41      /// using the restore() function.
   48.42      ///
   48.43 -    /// \note After a state is restored, you cannot restore a later state, 
   48.44 +    /// \note After a state is restored, you cannot restore a later state,
   48.45      /// i.e. you cannot add the removed nodes and edges again using
   48.46      /// another Snapshot instance.
   48.47      ///
    49.1 --- a/lemon/lp.h	Wed Mar 17 12:35:52 2010 +0100
    49.2 +++ b/lemon/lp.h	Sat Mar 06 14:35:12 2010 +0000
    49.3 @@ -2,7 +2,7 @@
    49.4   *
    49.5   * This file is a part of LEMON, a generic C++ optimization library.
    49.6   *
    49.7 - * Copyright (C) 2003-2008
    49.8 + * Copyright (C) 2003-2010
    49.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   49.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   49.11   *
   49.12 @@ -84,7 +84,7 @@
   49.13    typedef SoplexLp Lp;
   49.14  #elif LEMON_HAVE_CLP
   49.15  # define DEFAULT_LP CLP
   49.16 -  typedef ClpLp Lp;  
   49.17 +  typedef ClpLp Lp;
   49.18  #endif
   49.19  #endif
   49.20  
    50.1 --- a/lemon/lp_base.cc	Wed Mar 17 12:35:52 2010 +0100
    50.2 +++ b/lemon/lp_base.cc	Sat Mar 06 14:35:12 2010 +0000
    50.3 @@ -2,7 +2,7 @@
    50.4   *
    50.5   * This file is a part of LEMON, a generic C++ optimization library.
    50.6   *
    50.7 - * Copyright (C) 2003-2008
    50.8 + * Copyright (C) 2003-2010
    50.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   50.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   50.11   *
    51.1 --- a/lemon/lp_base.h	Wed Mar 17 12:35:52 2010 +0100
    51.2 +++ b/lemon/lp_base.h	Sat Mar 06 14:35:12 2010 +0000
    51.3 @@ -2,7 +2,7 @@
    51.4   *
    51.5   * This file is a part of LEMON, a generic C++ optimization library.
    51.6   *
    51.7 - * Copyright (C) 2003-2008
    51.8 + * Copyright (C) 2003-2010
    51.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   51.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   51.11   *
   51.12 @@ -82,7 +82,7 @@
   51.13        /// Verbose output.
   51.14        MESSAGE_VERBOSE
   51.15      };
   51.16 -    
   51.17 +
   51.18  
   51.19      ///The floating point type used by the solver
   51.20      typedef double Value;
   51.21 @@ -114,14 +114,14 @@
   51.22        typedef Value ExprValue;
   51.23        typedef True LpCol;
   51.24        /// Default constructor
   51.25 -      
   51.26 +
   51.27        /// \warning The default constructor sets the Col to an
   51.28        /// undefined value.
   51.29        Col() {}
   51.30        /// Invalid constructor \& conversion.
   51.31 -      
   51.32 +
   51.33        /// This constructor initializes the Col to be invalid.
   51.34 -      /// \sa Invalid for more details.      
   51.35 +      /// \sa Invalid for more details.
   51.36        Col(const Invalid&) : _id(-1) {}
   51.37        /// Equality operator
   51.38  
   51.39 @@ -156,12 +156,12 @@
   51.40        const LpBase *_solver;
   51.41      public:
   51.42        /// Default constructor
   51.43 -      
   51.44 +
   51.45        /// \warning The default constructor sets the iterator
   51.46        /// to an undefined value.
   51.47        ColIt() {}
   51.48        /// Sets the iterator to the first Col
   51.49 -      
   51.50 +
   51.51        /// Sets the iterator to the first Col.
   51.52        ///
   51.53        ColIt(const LpBase &solver) : _solver(&solver)
   51.54 @@ -169,12 +169,12 @@
   51.55          _solver->cols.firstItem(_id);
   51.56        }
   51.57        /// Invalid constructor \& conversion
   51.58 -      
   51.59 +
   51.60        /// Initialize the iterator to be invalid.
   51.61        /// \sa Invalid for more details.
   51.62        ColIt(const Invalid&) : Col(INVALID) {}
   51.63        /// Next column
   51.64 -      
   51.65 +
   51.66        /// Assign the iterator to the next column.
   51.67        ///
   51.68        ColIt &operator++()
   51.69 @@ -209,14 +209,14 @@
   51.70        typedef Value ExprValue;
   51.71        typedef True LpRow;
   51.72        /// Default constructor
   51.73 -      
   51.74 +
   51.75        /// \warning The default constructor sets the Row to an
   51.76        /// undefined value.
   51.77        Row() {}
   51.78        /// Invalid constructor \& conversion.
   51.79 -      
   51.80 +
   51.81        /// This constructor initializes the Row to be invalid.
   51.82 -      /// \sa Invalid for more details.      
   51.83 +      /// \sa Invalid for more details.
   51.84        Row(const Invalid&) : _id(-1) {}
   51.85        /// Equality operator
   51.86  
   51.87 @@ -224,7 +224,7 @@
   51.88        /// the same LP row or both are invalid.
   51.89        bool operator==(Row r) const  {return _id == r._id;}
   51.90        /// Inequality operator
   51.91 -      
   51.92 +
   51.93        /// \sa operator==(Row r)
   51.94        ///
   51.95        bool operator!=(Row r) const  {return _id != r._id;}
   51.96 @@ -251,12 +251,12 @@
   51.97        const LpBase *_solver;
   51.98      public:
   51.99        /// Default constructor
  51.100 -      
  51.101 +
  51.102        /// \warning The default constructor sets the iterator
  51.103        /// to an undefined value.
  51.104        RowIt() {}
  51.105        /// Sets the iterator to the first Row
  51.106 -      
  51.107 +
  51.108        /// Sets the iterator to the first Row.
  51.109        ///
  51.110        RowIt(const LpBase &solver) : _solver(&solver)
  51.111 @@ -264,12 +264,12 @@
  51.112          _solver->rows.firstItem(_id);
  51.113        }
  51.114        /// Invalid constructor \& conversion
  51.115 -      
  51.116 +
  51.117        /// Initialize the iterator to be invalid.
  51.118        /// \sa Invalid for more details.
  51.119        RowIt(const Invalid&) : Row(INVALID) {}
  51.120        /// Next row
  51.121 -      
  51.122 +
  51.123        /// Assign the iterator to the next row.
  51.124        ///
  51.125        RowIt &operator++()
  51.126 @@ -347,7 +347,7 @@
  51.127      public:
  51.128        typedef True SolverExpr;
  51.129        /// Default constructor
  51.130 -      
  51.131 +
  51.132        /// Construct an empty expression, the coefficients and
  51.133        /// the constant component are initialized to zero.
  51.134        Expr() : const_comp(0) {}
  51.135 @@ -448,9 +448,9 @@
  51.136        }
  51.137  
  51.138        ///Iterator over the expression
  51.139 -      
  51.140 -      ///The iterator iterates over the terms of the expression. 
  51.141 -      /// 
  51.142 +
  51.143 +      ///The iterator iterates over the terms of the expression.
  51.144 +      ///
  51.145        ///\code
  51.146        ///double s=0;
  51.147        ///for(LpBase::Expr::CoeffIt i(e);i!=INVALID;++i)
  51.148 @@ -464,7 +464,7 @@
  51.149        public:
  51.150  
  51.151          /// Sets the iterator to the first term
  51.152 -        
  51.153 +
  51.154          /// Sets the iterator to the first term of the expression.
  51.155          ///
  51.156          CoeffIt(Expr& e)
  51.157 @@ -481,7 +481,7 @@
  51.158          /// Returns the coefficient of the term
  51.159          const Value& operator*() const { return _it->second; }
  51.160          /// Next term
  51.161 -        
  51.162 +
  51.163          /// Assign the iterator to the next term.
  51.164          ///
  51.165          CoeffIt& operator++() { ++_it; return *this; }
  51.166 @@ -493,9 +493,9 @@
  51.167        };
  51.168  
  51.169        /// Const iterator over the expression
  51.170 -      
  51.171 -      ///The iterator iterates over the terms of the expression. 
  51.172 -      /// 
  51.173 +
  51.174 +      ///The iterator iterates over the terms of the expression.
  51.175 +      ///
  51.176        ///\code
  51.177        ///double s=0;
  51.178        ///for(LpBase::Expr::ConstCoeffIt i(e);i!=INVALID;++i)
  51.179 @@ -509,7 +509,7 @@
  51.180        public:
  51.181  
  51.182          /// Sets the iterator to the first term
  51.183 -        
  51.184 +
  51.185          /// Sets the iterator to the first term of the expression.
  51.186          ///
  51.187          ConstCoeffIt(const Expr& e)
  51.188 @@ -524,7 +524,7 @@
  51.189          const Value& operator*() const { return _it->second; }
  51.190  
  51.191          /// Next term
  51.192 -        
  51.193 +
  51.194          /// Assign the iterator to the next term.
  51.195          ///
  51.196          ConstCoeffIt& operator++() { ++_it; return *this; }
  51.197 @@ -673,7 +673,7 @@
  51.198      public:
  51.199        typedef True SolverExpr;
  51.200        /// Default constructor
  51.201 -      
  51.202 +
  51.203        /// Construct an empty expression, the coefficients are
  51.204        /// initialized to zero.
  51.205        DualExpr() {}
  51.206 @@ -708,7 +708,7 @@
  51.207          }
  51.208        }
  51.209        /// \brief Removes the coefficients which's absolute value does
  51.210 -      /// not exceed \c epsilon. 
  51.211 +      /// not exceed \c epsilon.
  51.212        void simplify(Value epsilon = 0.0) {
  51.213          std::map<int, Value>::iterator it=comps.begin();
  51.214          while (it != comps.end()) {
  51.215 @@ -757,9 +757,9 @@
  51.216        }
  51.217  
  51.218        ///Iterator over the expression
  51.219 -      
  51.220 -      ///The iterator iterates over the terms of the expression. 
  51.221 -      /// 
  51.222 +
  51.223 +      ///The iterator iterates over the terms of the expression.
  51.224 +      ///
  51.225        ///\code
  51.226        ///double s=0;
  51.227        ///for(LpBase::DualExpr::CoeffIt i(e);i!=INVALID;++i)
  51.228 @@ -773,7 +773,7 @@
  51.229        public:
  51.230  
  51.231          /// Sets the iterator to the first term
  51.232 -        
  51.233 +
  51.234          /// Sets the iterator to the first term of the expression.
  51.235          ///
  51.236          CoeffIt(DualExpr& e)
  51.237 @@ -791,7 +791,7 @@
  51.238          const Value& operator*() const { return _it->second; }
  51.239  
  51.240          /// Next term
  51.241 -        
  51.242 +
  51.243          /// Assign the iterator to the next term.
  51.244          ///
  51.245          CoeffIt& operator++() { ++_it; return *this; }
  51.246 @@ -803,9 +803,9 @@
  51.247        };
  51.248  
  51.249        ///Iterator over the expression
  51.250 -      
  51.251 -      ///The iterator iterates over the terms of the expression. 
  51.252 -      /// 
  51.253 +
  51.254 +      ///The iterator iterates over the terms of the expression.
  51.255 +      ///
  51.256        ///\code
  51.257        ///double s=0;
  51.258        ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)
  51.259 @@ -819,7 +819,7 @@
  51.260        public:
  51.261  
  51.262          /// Sets the iterator to the first term
  51.263 -        
  51.264 +
  51.265          /// Sets the iterator to the first term of the expression.
  51.266          ///
  51.267          ConstCoeffIt(const DualExpr& e)
  51.268 @@ -834,7 +834,7 @@
  51.269          const Value& operator*() const { return _it->second; }
  51.270  
  51.271          /// Next term
  51.272 -        
  51.273 +
  51.274          /// Assign the iterator to the next term.
  51.275          ///
  51.276          ConstCoeffIt& operator++() { ++_it; return *this; }
  51.277 @@ -1229,7 +1229,7 @@
  51.278      Row addRow(const Constr &c) {
  51.279        Row r;
  51.280        c.expr().simplify();
  51.281 -      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF, 
  51.282 +      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
  51.283                                  ExprIterator(c.expr().comps.begin(), cols),
  51.284                                  ExprIterator(c.expr().comps.end(), cols),
  51.285                                  c.upperBounded()?c.upperBound()-*c.expr():INF));
  51.286 @@ -1817,10 +1817,10 @@
  51.287      ///The basis status of variables
  51.288      enum VarStatus {
  51.289        /// The variable is in the basis
  51.290 -      BASIC, 
  51.291 +      BASIC,
  51.292        /// The variable is free, but not basic
  51.293        FREE,
  51.294 -      /// The variable has active lower bound 
  51.295 +      /// The variable has active lower bound
  51.296        LOWER,
  51.297        /// The variable has active upper bound
  51.298        UPPER,
  51.299 @@ -1899,7 +1899,7 @@
  51.300        return res;
  51.301      }
  51.302      /// Returns a component of the primal ray
  51.303 -    
  51.304 +
  51.305      /// The primal ray is solution of the modified primal problem,
  51.306      /// where we change each finite bound to 0, and we looking for a
  51.307      /// negative objective value in case of minimization, and positive
  51.308 @@ -1933,7 +1933,7 @@
  51.309      }
  51.310  
  51.311      /// Returns a component of the dual ray
  51.312 -    
  51.313 +
  51.314      /// The dual ray is solution of the modified primal problem, where
  51.315      /// we change each finite bound to 0 (i.e. the objective function
  51.316      /// coefficients in the primal problem), and we looking for a
  51.317 @@ -2075,7 +2075,7 @@
  51.318        return res;
  51.319      }
  51.320      ///The value of the objective function
  51.321 -    
  51.322 +
  51.323      ///\return
  51.324      ///- \ref INF or -\ref INF means either infeasibility or unboundedness
  51.325      /// of the problem, depending on whether we minimize or maximize.
    52.1 --- a/lemon/lp_skeleton.cc	Wed Mar 17 12:35:52 2010 +0100
    52.2 +++ b/lemon/lp_skeleton.cc	Sat Mar 06 14:35:12 2010 +0000
    52.3 @@ -2,7 +2,7 @@
    52.4   *
    52.5   * This file is a part of LEMON, a generic C++ optimization library.
    52.6   *
    52.7 - * Copyright (C) 2003-2008
    52.8 + * Copyright (C) 2003-2010
    52.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   52.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   52.11   *
    53.1 --- a/lemon/lp_skeleton.h	Wed Mar 17 12:35:52 2010 +0100
    53.2 +++ b/lemon/lp_skeleton.h	Sat Mar 06 14:35:12 2010 +0000
    53.3 @@ -2,7 +2,7 @@
    53.4   *
    53.5   * This file is a part of LEMON, a generic C++ optimization library.
    53.6   *
    53.7 - * Copyright (C) 2003-2008
    53.8 + * Copyright (C) 2003-2010
    53.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   53.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   53.11   *
   53.12 @@ -23,13 +23,13 @@
   53.13  
   53.14  ///\file
   53.15  ///\brief Skeleton file to implement LP/MIP solver interfaces
   53.16 -///  
   53.17 +///
   53.18  ///The classes in this file do nothing, but they can serve as skeletons when
   53.19  ///implementing an interface to new solvers.
   53.20  namespace lemon {
   53.21  
   53.22    ///A skeleton class to implement LP/MIP solver base interface
   53.23 -  
   53.24 +
   53.25    ///This class does nothing, but it can serve as a skeleton when
   53.26    ///implementing an interface to new solvers.
   53.27    class SkeletonSolverBase : public virtual LpBase {
    54.1 --- a/lemon/maps.h	Wed Mar 17 12:35:52 2010 +0100
    54.2 +++ b/lemon/maps.h	Sat Mar 06 14:35:12 2010 +0000
    54.3 @@ -2,7 +2,7 @@
    54.4   *
    54.5   * This file is a part of LEMON, a generic C++ optimization library.
    54.6   *
    54.7 - * Copyright (C) 2003-2009
    54.8 + * Copyright (C) 2003-2010
    54.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   54.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   54.11   *
   54.12 @@ -233,7 +233,7 @@
   54.13    /// It can be used together with some data structures, e.g.
   54.14    /// heap types and \c UnionFind, when the used items are small
   54.15    /// integers. This map conforms to the \ref concepts::ReferenceMap
   54.16 -  /// "ReferenceMap" concept. 
   54.17 +  /// "ReferenceMap" concept.
   54.18    ///
   54.19    /// The simplest way of using this map is through the rangeMap()
   54.20    /// function.
   54.21 @@ -1916,11 +1916,11 @@
   54.22    /// The graph items can be accessed by their values either using
   54.23    /// \c InverseMap or \c operator()(), and the values of the map can be
   54.24    /// accessed with an STL compatible forward iterator (\c ValueIt).
   54.25 -  /// 
   54.26 +  ///
   54.27    /// This map is intended to be used when all associated values are
   54.28    /// different (the map is actually invertable) or there are only a few
   54.29    /// items with the same value.
   54.30 -  /// Otherwise consider to use \c IterableValueMap, which is more 
   54.31 +  /// Otherwise consider to use \c IterableValueMap, which is more
   54.32    /// suitable and more efficient for such cases. It provides iterators
   54.33    /// to traverse the items with the same associated value, but
   54.34    /// it does not have \c InverseMap.
   54.35 @@ -2002,7 +2002,7 @@
   54.36      private:
   54.37        typename Container::const_iterator it;
   54.38      };
   54.39 -    
   54.40 +
   54.41      /// Alias for \c ValueIt
   54.42      typedef ValueIt ValueIterator;
   54.43  
   54.44 @@ -2061,7 +2061,7 @@
   54.45        typename Container::const_iterator it = _inv_map.find(val);
   54.46        return it != _inv_map.end() ? it->second : INVALID;
   54.47      }
   54.48 -    
   54.49 +
   54.50      /// \brief Returns the number of items with the given value.
   54.51      ///
   54.52      /// This function returns the number of items with the given value
   54.53 @@ -2378,7 +2378,7 @@
   54.54    inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {
   54.55      return RangeIdMap<GR, K>(graph);
   54.56    }
   54.57 -  
   54.58 +
   54.59    /// \brief Dynamic iterable \c bool map.
   54.60    ///
   54.61    /// This class provides a special graph map type which can store a
   54.62 @@ -2638,7 +2638,7 @@
   54.63        /// \param map The IterableBoolMap.
   54.64        /// \param value The value.
   54.65        ItemIt(const IterableBoolMap& map, bool value)
   54.66 -        : Parent(value ? 
   54.67 +        : Parent(value ?
   54.68                   (map._sep > 0 ?
   54.69                    map._array[map._sep - 1] : INVALID) :
   54.70                   (map._sep < int(map._array.size()) ?
   54.71 @@ -3786,7 +3786,7 @@
   54.72    void mapCopy(const GR& gr, const From& from, To& to) {
   54.73      typedef typename To::Key Item;
   54.74      typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
   54.75 -    
   54.76 +
   54.77      for (ItemIt it(gr); it != INVALID; ++it) {
   54.78        to.set(it, from[it]);
   54.79      }
   54.80 @@ -3794,7 +3794,7 @@
   54.81  
   54.82    /// \brief Compare two graph maps.
   54.83    ///
   54.84 -  /// This function compares the values of two graph maps. It returns 
   54.85 +  /// This function compares the values of two graph maps. It returns
   54.86    /// \c true if the maps assign the same value for all items in the graph.
   54.87    /// The \c Key type of the maps (\c Node, \c Arc or \c Edge) must be equal
   54.88    /// and their \c Value types must be comparable using \c %operator==().
   54.89 @@ -3806,7 +3806,7 @@
   54.90    bool mapCompare(const GR& gr, const Map1& map1, const Map2& map2) {
   54.91      typedef typename Map2::Key Item;
   54.92      typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
   54.93 -    
   54.94 +
   54.95      for (ItemIt it(gr); it != INVALID; ++it) {
   54.96        if (!(map1[it] == map2[it])) return false;
   54.97      }
    55.1 --- a/lemon/matching.h	Wed Mar 17 12:35:52 2010 +0100
    55.2 +++ b/lemon/matching.h	Sat Mar 06 14:35:12 2010 +0000
    55.3 @@ -2,7 +2,7 @@
    55.4   *
    55.5   * This file is a part of LEMON, a generic C++ optimization library.
    55.6   *
    55.7 - * Copyright (C) 2003-2009
    55.8 + * Copyright (C) 2003-2010
    55.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   55.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   55.11   *
   55.12 @@ -1623,7 +1623,7 @@
   55.13          (*_delta2_index)[i] = _delta2->PRE_HEAP;
   55.14          (*_delta4_index)[i] = _delta4->PRE_HEAP;
   55.15        }
   55.16 -      
   55.17 +
   55.18        _unmatched = _node_num;
   55.19  
   55.20        _delta1->clear();
   55.21 @@ -1678,7 +1678,7 @@
   55.22  
   55.23        _blossom_node_list.clear();
   55.24        _blossom_potential.clear();
   55.25 -      
   55.26 +
   55.27        if (_fractional == 0) {
   55.28          _fractional = new FractionalMatching(_graph, _weight, false);
   55.29        }
   55.30 @@ -1750,17 +1750,17 @@
   55.31            while (n != v) {
   55.32              subblossoms[--num] = _blossom_set->find(v);
   55.33              _delta1->push(v, _fractional->nodeValue(v));
   55.34 -            v = _graph.target(_fractional->matching(v));            
   55.35 +            v = _graph.target(_fractional->matching(v));
   55.36            }
   55.37 -          
   55.38 -          int surface = 
   55.39 +
   55.40 +          int surface =
   55.41              _blossom_set->join(subblossoms.begin(), subblossoms.end());
   55.42            (*_blossom_data)[surface].status = EVEN;
   55.43            (*_blossom_data)[surface].pred = INVALID;
   55.44            (*_blossom_data)[surface].next = INVALID;
   55.45            (*_blossom_data)[surface].pot = 0;
   55.46            (*_blossom_data)[surface].offset = 0;
   55.47 -          
   55.48 +
   55.49            _tree_set->insert(surface);
   55.50            ++_unmatched;
   55.51          }
   55.52 @@ -1810,7 +1810,7 @@
   55.53              }
   55.54            }
   55.55          }
   55.56 -            
   55.57 +
   55.58          if (!(*_node_data)[ni].heap.empty()) {
   55.59            _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
   55.60            _delta2->push(nb, _blossom_set->classPrio(nb));
   55.61 @@ -2269,7 +2269,7 @@
   55.62      Value _delta_sum;
   55.63      int _unmatched;
   55.64  
   55.65 -    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap> 
   55.66 +    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
   55.67      FractionalMatching;
   55.68      FractionalMatching *_fractional;
   55.69  
   55.70 @@ -3095,7 +3095,7 @@
   55.71  
   55.72        _blossom_node_list.clear();
   55.73        _blossom_potential.clear();
   55.74 -      
   55.75 +
   55.76        if (_fractional == 0) {
   55.77          _fractional = new FractionalMatching(_graph, _weight, false);
   55.78        }
   55.79 @@ -3161,17 +3161,17 @@
   55.80            v = _graph.target(_fractional->matching(n));
   55.81            while (n != v) {
   55.82              subblossoms[--num] = _blossom_set->find(v);
   55.83 -            v = _graph.target(_fractional->matching(v));            
   55.84 +            v = _graph.target(_fractional->matching(v));
   55.85            }
   55.86 -          
   55.87 -          int surface = 
   55.88 +
   55.89 +          int surface =
   55.90              _blossom_set->join(subblossoms.begin(), subblossoms.end());
   55.91            (*_blossom_data)[surface].status = EVEN;
   55.92            (*_blossom_data)[surface].pred = INVALID;
   55.93            (*_blossom_data)[surface].next = INVALID;
   55.94            (*_blossom_data)[surface].pot = 0;
   55.95            (*_blossom_data)[surface].offset = 0;
   55.96 -          
   55.97 +
   55.98            _tree_set->insert(surface);
   55.99            ++_unmatched;
  55.100          }
  55.101 @@ -3221,7 +3221,7 @@
  55.102              }
  55.103            }
  55.104          }
  55.105 -            
  55.106 +
  55.107          if (!(*_node_data)[ni].heap.empty()) {
  55.108            _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
  55.109            _delta2->push(nb, _blossom_set->classPrio(nb));
    56.1 --- a/lemon/math.h	Wed Mar 17 12:35:52 2010 +0100
    56.2 +++ b/lemon/math.h	Sat Mar 06 14:35:12 2010 +0000
    56.3 @@ -2,7 +2,7 @@
    56.4   *
    56.5   * This file is a part of LEMON, a generic C++ optimization library.
    56.6   *
    56.7 - * Copyright (C) 2003-2009
    56.8 + * Copyright (C) 2003-2010
    56.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   56.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   56.11   *
   56.12 @@ -56,7 +56,7 @@
   56.13    const long double SQRT1_2 = 0.7071067811865475244008443621048490L;
   56.14  
   56.15    ///Check whether the parameter is NaN or not
   56.16 -  
   56.17 +
   56.18    ///This function checks whether the parameter is NaN or not.
   56.19    ///Is should be equivalent with std::isnan(), but it is not
   56.20    ///provided by all compilers.
    57.1 --- a/lemon/min_cost_arborescence.h	Wed Mar 17 12:35:52 2010 +0100
    57.2 +++ b/lemon/min_cost_arborescence.h	Sat Mar 06 14:35:12 2010 +0000
    57.3 @@ -2,7 +2,7 @@
    57.4   *
    57.5   * This file is a part of LEMON, a generic C++ optimization library.
    57.6   *
    57.7 - * Copyright (C) 2003-2008
    57.8 + * Copyright (C) 2003-2010
    57.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   57.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   57.11   *
   57.12 @@ -128,8 +128,8 @@
   57.13    class MinCostArborescence {
   57.14    public:
   57.15  
   57.16 -    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" 
   57.17 -    /// of the algorithm. 
   57.18 +    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
   57.19 +    /// of the algorithm.
   57.20      typedef TR Traits;
   57.21      /// The type of the underlying digraph.
   57.22      typedef typename Traits::Digraph Digraph;
   57.23 @@ -436,7 +436,7 @@
   57.24      ///
   57.25      /// \ref named-templ-param "Named parameter" for setting
   57.26      /// \c PredMap type.
   57.27 -    /// It must meet the \ref concepts::WriteMap "WriteMap" concept, 
   57.28 +    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
   57.29      /// and its value type must be the \c Arc type of the digraph.
   57.30      template <class T>
   57.31      struct SetPredMap
    58.1 --- a/lemon/network_simplex.h	Wed Mar 17 12:35:52 2010 +0100
    58.2 +++ b/lemon/network_simplex.h	Sat Mar 06 14:35:12 2010 +0000
    58.3 @@ -2,7 +2,7 @@
    58.4   *
    58.5   * This file is a part of LEMON, a generic C++ optimization library.
    58.6   *
    58.7 - * Copyright (C) 2003-2009
    58.8 + * Copyright (C) 2003-2010
    58.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   58.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   58.11   *
   58.12 @@ -97,7 +97,7 @@
   58.13        /// infinite upper bound.
   58.14        UNBOUNDED
   58.15      };
   58.16 -    
   58.17 +
   58.18      /// \brief Constants for selecting the type of the supply constraints.
   58.19      ///
   58.20      /// Enum type containing constants for selecting the supply type,
   58.21 @@ -115,7 +115,7 @@
   58.22        /// supply/demand constraints in the definition of the problem.
   58.23        LEQ
   58.24      };
   58.25 -    
   58.26 +
   58.27      /// \brief Constants for selecting the pivot rule.
   58.28      ///
   58.29      /// Enum type containing constants for selecting the pivot rule for
   58.30 @@ -158,7 +158,7 @@
   58.31        /// candidate list and extends this list in every iteration.
   58.32        ALTERING_LIST
   58.33      };
   58.34 -    
   58.35 +
   58.36    private:
   58.37  
   58.38      TEMPLATE_DIGRAPH_TYPEDEFS(GR);
   58.39 @@ -227,11 +227,11 @@
   58.40      int first, second, right, last;
   58.41      int stem, par_stem, new_stem;
   58.42      Value delta;
   58.43 -    
   58.44 +
   58.45      const Value MAX;
   58.46  
   58.47    public:
   58.48 -  
   58.49 +
   58.50      /// \brief Constant for infinite upper bounds (capacities).
   58.51      ///
   58.52      /// Constant for infinite upper bounds (capacities).
   58.53 @@ -498,8 +498,8 @@
   58.54            }
   58.55          }
   58.56          if (_curr_length == 0) return false;
   58.57 -      
   58.58 -      search_end:        
   58.59 +
   58.60 +      search_end:
   58.61          _minor_count = 1;
   58.62          _next_arc = e;
   58.63          return true;
   58.64 @@ -608,7 +608,7 @@
   58.65            }
   58.66          }
   58.67          if (_curr_length == 0) return false;
   58.68 -        
   58.69 +
   58.70        search_end:
   58.71  
   58.72          // Make heap of the candidate list (approximating a partial sort)
   58.73 @@ -634,7 +634,7 @@
   58.74      ///
   58.75      /// \param graph The digraph the algorithm runs on.
   58.76      /// \param arc_mixing Indicate if the arcs have to be stored in a
   58.77 -    /// mixed order in the internal data structure. 
   58.78 +    /// mixed order in the internal data structure.
   58.79      /// In special cases, it could lead to better overall performance,
   58.80      /// but it is usually slower. Therefore it is disabled by default.
   58.81      NetworkSimplex(const GR& graph, bool arc_mixing = false) :
   58.82 @@ -649,7 +649,7 @@
   58.83          "The flow type of NetworkSimplex must be signed");
   58.84        LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
   58.85          "The cost type of NetworkSimplex must be signed");
   58.86 -        
   58.87 +
   58.88        // Reset data structures
   58.89        reset();
   58.90      }
   58.91 @@ -763,7 +763,7 @@
   58.92        _supply[_node_id[t]] = -k;
   58.93        return *this;
   58.94      }
   58.95 -    
   58.96 +
   58.97      /// \brief Set the type of the supply constraints.
   58.98      ///
   58.99      /// This function sets the type of the supply/demand constraints.
  58.100 @@ -789,7 +789,7 @@
  58.101      ///
  58.102      /// This function runs the algorithm.
  58.103      /// The paramters can be specified using functions \ref lowerMap(),
  58.104 -    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), 
  58.105 +    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
  58.106      /// \ref supplyType().
  58.107      /// For example,
  58.108      /// \code
  58.109 @@ -944,12 +944,12 @@
  58.110            _target[i] = _node_id[_graph.target(a)];
  58.111          }
  58.112        }
  58.113 -      
  58.114 +
  58.115        // Reset parameters
  58.116        resetParams();
  58.117        return *this;
  58.118      }
  58.119 -    
  58.120 +
  58.121      /// @}
  58.122  
  58.123      /// \name Query Functions
  58.124 @@ -1089,7 +1089,7 @@
  58.125          _flow[i] = 0;
  58.126          _state[i] = STATE_LOWER;
  58.127        }
  58.128 -      
  58.129 +
  58.130        // Set data for the artificial root node
  58.131        _root = _node_num;
  58.132        _parent[_root] = -1;
  58.133 @@ -1263,7 +1263,7 @@
  58.134        // Search the cycle along the path form the second node to the root
  58.135        for (int u = second; u != join; u = _parent[u]) {
  58.136          e = _pred[u];
  58.137 -        d = _forward[u] ? 
  58.138 +        d = _forward[u] ?
  58.139            (_cap[e] >= MAX ? INF : _cap[e] - _flow[e]) : _flow[e];
  58.140          if (d <= delta) {
  58.141            delta = d;
  58.142 @@ -1567,7 +1567,7 @@
  58.143            updatePotential();
  58.144          }
  58.145        }
  58.146 -      
  58.147 +
  58.148        // Check feasibility
  58.149        for (int e = _search_arc_num; e != _all_arc_num; ++e) {
  58.150          if (_flow[e] != 0) return INFEASIBLE;
  58.151 @@ -1584,7 +1584,7 @@
  58.152            }
  58.153          }
  58.154        }
  58.155 -      
  58.156 +
  58.157        // Shift potentials to meet the requirements of the GEQ/LEQ type
  58.158        // optimality conditions
  58.159        if (_sum_supply == 0) {
    59.1 --- a/lemon/path.h	Wed Mar 17 12:35:52 2010 +0100
    59.2 +++ b/lemon/path.h	Sat Mar 06 14:35:12 2010 +0000
    59.3 @@ -2,7 +2,7 @@
    59.4   *
    59.5   * This file is a part of LEMON, a generic C++ optimization library.
    59.6   *
    59.7 - * Copyright (C) 2003-2009
    59.8 + * Copyright (C) 2003-2010
    59.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   59.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   59.11   *
   59.12 @@ -966,20 +966,20 @@
   59.13        }
   59.14      };
   59.15  
   59.16 -    
   59.17 +
   59.18      template <typename From, typename To,
   59.19                bool revEnable = RevPathTagIndicator<From>::value>
   59.20      struct PathCopySelector {
   59.21        static void copy(const From& from, To& to) {
   59.22          PathCopySelectorForward<From, To>::copy(from, to);
   59.23 -      }      
   59.24 +      }
   59.25      };
   59.26  
   59.27      template <typename From, typename To>
   59.28      struct PathCopySelector<From, To, true> {
   59.29        static void copy(const From& from, To& to) {
   59.30          PathCopySelectorBackward<From, To>::copy(from, to);
   59.31 -      }      
   59.32 +      }
   59.33      };
   59.34  
   59.35    }
    60.1 --- a/lemon/planarity.h	Wed Mar 17 12:35:52 2010 +0100
    60.2 +++ b/lemon/planarity.h	Sat Mar 06 14:35:12 2010 +0000
    60.3 @@ -2,7 +2,7 @@
    60.4   *
    60.5   * This file is a part of LEMON, a generic C++ optimization library.
    60.6   *
    60.7 - * Copyright (C) 2003-2009
    60.8 + * Copyright (C) 2003-2010
    60.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   60.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   60.11   *
   60.12 @@ -140,17 +140,17 @@
   60.13      template <typename Graph>
   60.14      class PlanarityChecking {
   60.15      private:
   60.16 -      
   60.17 +
   60.18        TEMPLATE_GRAPH_TYPEDEFS(Graph);
   60.19  
   60.20        const Graph& _graph;
   60.21  
   60.22      private:
   60.23 -      
   60.24 +
   60.25        typedef typename Graph::template NodeMap<Arc> PredMap;
   60.26 -      
   60.27 +
   60.28        typedef typename Graph::template EdgeMap<bool> TreeMap;
   60.29 -      
   60.30 +
   60.31        typedef typename Graph::template NodeMap<int> OrderMap;
   60.32        typedef std::vector<Node> OrderList;
   60.33  
   60.34 @@ -221,7 +221,7 @@
   60.35            }
   60.36  
   60.37            for (typename MergeRoots::Value::iterator it =
   60.38 -                 merge_roots[node].begin(); 
   60.39 +                 merge_roots[node].begin();
   60.40                 it != merge_roots[node].end(); ++it) {
   60.41              int rn = *it;
   60.42              walkDown(rn, i, node_data, order_list, child_lists,
   60.43 @@ -432,7 +432,7 @@
   60.44                Node ynode = order_list[yn];
   60.45  
   60.46                bool rd;
   60.47 -              if (!external(xnode, rorder, child_lists, 
   60.48 +              if (!external(xnode, rorder, child_lists,
   60.49                              ancestor_map, low_map)) {
   60.50                  rd = true;
   60.51                } else if (!external(ynode, rorder, child_lists,
    61.1 --- a/lemon/preflow.h	Wed Mar 17 12:35:52 2010 +0100
    61.2 +++ b/lemon/preflow.h	Sat Mar 06 14:35:12 2010 +0000
    61.3 @@ -2,7 +2,7 @@
    61.4   *
    61.5   * This file is a part of LEMON, a generic C++ optimization library.
    61.6   *
    61.7 - * Copyright (C) 2003-2009
    61.8 + * Copyright (C) 2003-2010
    61.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   61.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   61.11   *
    62.1 --- a/lemon/smart_graph.h	Wed Mar 17 12:35:52 2010 +0100
    62.2 +++ b/lemon/smart_graph.h	Sat Mar 06 14:35:12 2010 +0000
    62.3 @@ -2,7 +2,7 @@
    62.4   *
    62.5   * This file is a part of LEMON, a generic C++ optimization library.
    62.6   *
    62.7 - * Copyright (C) 2003-2009
    62.8 + * Copyright (C) 2003-2010
    62.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   62.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   62.11   *
   62.12 @@ -186,7 +186,7 @@
   62.13    ///
   62.14    ///\ref SmartDigraph is a simple and fast digraph implementation.
   62.15    ///It is also quite memory efficient but at the price
   62.16 -  ///that it does not support node and arc deletion 
   62.17 +  ///that it does not support node and arc deletion
   62.18    ///(except for the Snapshot feature).
   62.19    ///
   62.20    ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
   62.21 @@ -335,7 +335,7 @@
   62.22      ///restore() function. This is the only way for deleting nodes and/or
   62.23      ///arcs from a SmartDigraph structure.
   62.24      ///
   62.25 -    ///\note After a state is restored, you cannot restore a later state, 
   62.26 +    ///\note After a state is restored, you cannot restore a later state,
   62.27      ///i.e. you cannot add the removed nodes and arcs again using
   62.28      ///another Snapshot instance.
   62.29      ///
   62.30 @@ -614,7 +614,7 @@
   62.31    ///
   62.32    /// \ref SmartGraph is a simple and fast graph implementation.
   62.33    /// It is also quite memory efficient but at the price
   62.34 -  /// that it does not support node and edge deletion 
   62.35 +  /// that it does not support node and edge deletion
   62.36    /// (except for the Snapshot feature).
   62.37    ///
   62.38    /// This type fully conforms to the \ref concepts::Graph "Graph concept"
   62.39 @@ -761,7 +761,7 @@
   62.40      ///restore() function. This is the only way for deleting nodes and/or
   62.41      ///edges from a SmartGraph structure.
   62.42      ///
   62.43 -    ///\note After a state is restored, you cannot restore a later state, 
   62.44 +    ///\note After a state is restored, you cannot restore a later state,
   62.45      ///i.e. you cannot add the removed nodes and edges again using
   62.46      ///another Snapshot instance.
   62.47      ///
    63.1 --- a/lemon/soplex.cc	Wed Mar 17 12:35:52 2010 +0100
    63.2 +++ b/lemon/soplex.cc	Sat Mar 06 14:35:12 2010 +0000
    63.3 @@ -2,7 +2,7 @@
    63.4   *
    63.5   * This file is a part of LEMON, a generic C++ optimization library.
    63.6   *
    63.7 - * Copyright (C) 2003-2008
    63.8 + * Copyright (C) 2003-2010
    63.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   63.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   63.11   *
   63.12 @@ -287,7 +287,7 @@
   63.13    SoplexLp::SolveExitStatus SoplexLp::_solve() {
   63.14  
   63.15      _clear_temporals();
   63.16 -    
   63.17 +
   63.18      _applyMessageLevel();
   63.19  
   63.20      soplex::SPxSolver::Status status = soplex->solve();
    64.1 --- a/lemon/soplex.h	Wed Mar 17 12:35:52 2010 +0100
    64.2 +++ b/lemon/soplex.h	Sat Mar 06 14:35:12 2010 +0000
    64.3 @@ -2,7 +2,7 @@
    64.4   *
    64.5   * This file is a part of LEMON, a generic C++ optimization library.
    64.6   *
    64.7 - * Copyright (C) 2003-2008
    64.8 + * Copyright (C) 2003-2010
    64.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   64.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   64.11   *
    65.1 --- a/lemon/static_graph.h	Wed Mar 17 12:35:52 2010 +0100
    65.2 +++ b/lemon/static_graph.h	Sat Mar 06 14:35:12 2010 +0000
    65.3 @@ -1,8 +1,8 @@
    65.4 -/* -*- C++ -*-
    65.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    65.6   *
    65.7 - * This file is a part of LEMON, a generic C++ optimization library
    65.8 + * This file is a part of LEMON, a generic C++ optimization library.
    65.9   *
   65.10 - * Copyright (C) 2003-2008
   65.11 + * Copyright (C) 2003-2010
   65.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   65.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   65.14   *
   65.15 @@ -31,12 +31,12 @@
   65.16    class StaticDigraphBase {
   65.17    public:
   65.18  
   65.19 -    StaticDigraphBase() 
   65.20 -      : built(false), node_num(0), arc_num(0), 
   65.21 +    StaticDigraphBase()
   65.22 +      : built(false), node_num(0), arc_num(0),
   65.23          node_first_out(NULL), node_first_in(NULL),
   65.24 -        arc_source(NULL), arc_target(NULL), 
   65.25 +        arc_source(NULL), arc_target(NULL),
   65.26          arc_next_in(NULL), arc_next_out(NULL) {}
   65.27 -    
   65.28 +
   65.29      ~StaticDigraphBase() {
   65.30        if (built) {
   65.31          delete[] node_first_out;
   65.32 @@ -62,7 +62,7 @@
   65.33      };
   65.34  
   65.35      class Arc {
   65.36 -      friend class StaticDigraphBase;      
   65.37 +      friend class StaticDigraphBase;
   65.38      protected:
   65.39        int id;
   65.40        Arc(int _id) : id(_id) {}
   65.41 @@ -83,8 +83,8 @@
   65.42      void first(Arc& e) const { e.id = arc_num - 1; }
   65.43      static void next(Arc& e) { --e.id; }
   65.44  
   65.45 -    void firstOut(Arc& e, const Node& n) const { 
   65.46 -      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ? 
   65.47 +    void firstOut(Arc& e, const Node& n) const {
   65.48 +      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
   65.49          node_first_out[n.id] : -1;
   65.50      }
   65.51      void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; }
   65.52 @@ -113,21 +113,21 @@
   65.53      public:
   65.54        typedef typename Digraph::Arc Arc;
   65.55  
   65.56 -      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef) 
   65.57 +      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
   65.58          : digraph(_graph), nodeRef(_nodeRef) {}
   65.59 -      
   65.60 +
   65.61        bool operator()(const Arc& left, const Arc& right) const {
   65.62 -	return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
   65.63 +        return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
   65.64        }
   65.65      private:
   65.66        const Digraph& digraph;
   65.67        const NodeRefMap& nodeRef;
   65.68      };
   65.69 -    
   65.70 +
   65.71    public:
   65.72  
   65.73      typedef True BuildTag;
   65.74 -    
   65.75 +
   65.76      void clear() {
   65.77        if (built) {
   65.78          delete[] node_first_out;
   65.79 @@ -141,7 +141,7 @@
   65.80        node_num = 0;
   65.81        arc_num = 0;
   65.82      }
   65.83 -    
   65.84 +
   65.85      template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
   65.86      void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
   65.87        typedef typename Digraph::Node GNode;
   65.88 @@ -183,7 +183,7 @@
   65.89                 it != arcs.end(); ++it) {
   65.90              int target = nodeRef[digraph.target(*it)].id;
   65.91              arcRef[*it] = Arc(arc_index);
   65.92 -            arc_source[arc_index] = source; 
   65.93 +            arc_source[arc_index] = source;
   65.94              arc_target[arc_index] = target;
   65.95              arc_next_in[arc_index] = node_first_in[target];
   65.96              node_first_in[target] = arc_index;
   65.97 @@ -197,7 +197,7 @@
   65.98        }
   65.99        node_first_out[node_num] = arc_num;
  65.100      }
  65.101 -    
  65.102 +
  65.103      template <typename ArcListIterator>
  65.104      void build(int n, ArcListIterator first, ArcListIterator last) {
  65.105        built = true;
  65.106 @@ -212,11 +212,11 @@
  65.107        arc_target = new int[arc_num];
  65.108        arc_next_out = new int[arc_num];
  65.109        arc_next_in = new int[arc_num];
  65.110 -      
  65.111 +
  65.112        for (int i = 0; i != node_num; ++i) {
  65.113          node_first_in[i] = -1;
  65.114 -      }      
  65.115 -      
  65.116 +      }
  65.117 +
  65.118        int arc_index = 0;
  65.119        for (int i = 0; i != node_num; ++i) {
  65.120          node_first_out[i] = arc_index;
  65.121 @@ -282,7 +282,7 @@
  65.122    ///
  65.123    /// Since this digraph structure is completely static, its nodes and arcs
  65.124    /// can be indexed with integers from the ranges <tt>[0..nodeNum()-1]</tt>
  65.125 -  /// and <tt>[0..arcNum()-1]</tt>, respectively. 
  65.126 +  /// and <tt>[0..arcNum()-1]</tt>, respectively.
  65.127    /// The index of an item is the same as its ID, it can be obtained
  65.128    /// using the corresponding \ref index() or \ref concepts::Digraph::id()
  65.129    /// "id()" function. A node or arc with a certain index can be obtained
  65.130 @@ -299,9 +299,9 @@
  65.131    public:
  65.132  
  65.133      typedef ExtendedStaticDigraphBase Parent;
  65.134 -  
  65.135 +
  65.136    public:
  65.137 -  
  65.138 +
  65.139      /// \brief Constructor
  65.140      ///
  65.141      /// Default constructor.
  65.142 @@ -349,7 +349,7 @@
  65.143      ///
  65.144      /// This method also makes possible to copy a digraph to a StaticDigraph
  65.145      /// structure using \ref DigraphCopy.
  65.146 -    /// 
  65.147 +    ///
  65.148      /// \param digraph An existing digraph to be copied.
  65.149      /// \param nodeRef The node references will be copied into this map.
  65.150      /// Its key type must be \c Digraph::Node and its value type must be
  65.151 @@ -370,7 +370,7 @@
  65.152        if (built) Parent::clear();
  65.153        Parent::build(digraph, nodeRef, arcRef);
  65.154      }
  65.155 -  
  65.156 +
  65.157      /// \brief Build the digraph from an arc list.
  65.158      ///
  65.159      /// This function builds the digraph from the given arc list.
  65.160 @@ -421,7 +421,7 @@
  65.161      using Parent::fastFirstOut;
  65.162      using Parent::fastNextOut;
  65.163      using Parent::fastLastOut;
  65.164 -    
  65.165 +
  65.166    public:
  65.167  
  65.168      class OutArcIt : public Arc {
  65.169 @@ -432,8 +432,8 @@
  65.170        OutArcIt(Invalid i) : Arc(i) { }
  65.171  
  65.172        OutArcIt(const StaticDigraph& digraph, const Node& node) {
  65.173 -	digraph.fastFirstOut(*this, node);
  65.174 -	digraph.fastLastOut(last, node);
  65.175 +        digraph.fastFirstOut(*this, node);
  65.176 +        digraph.fastLastOut(last, node);
  65.177          if (last == *this) *this = INVALID;
  65.178        }
  65.179  
  65.180 @@ -443,10 +443,10 @@
  65.181          }
  65.182        }
  65.183  
  65.184 -      OutArcIt& operator++() { 
  65.185 +      OutArcIt& operator++() {
  65.186          StaticDigraph::fastNextOut(*this);
  65.187          if (last == *this) *this = INVALID;
  65.188 -        return *this; 
  65.189 +        return *this;
  65.190        }
  65.191  
  65.192      private:
    66.1 --- a/lemon/suurballe.h	Wed Mar 17 12:35:52 2010 +0100
    66.2 +++ b/lemon/suurballe.h	Sat Mar 06 14:35:12 2010 +0000
    66.3 @@ -2,7 +2,7 @@
    66.4   *
    66.5   * This file is a part of LEMON, a generic C++ optimization library.
    66.6   *
    66.7 - * Copyright (C) 2003-2009
    66.8 + * Copyright (C) 2003-2010
    66.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   66.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   66.11   *
   66.12 @@ -65,7 +65,7 @@
   66.13      /// It must conform to the \ref lemon::concepts::Path "Path" concept
   66.14      /// and it must have an \c addBack() function.
   66.15      typedef lemon::Path<Digraph> Path;
   66.16 -    
   66.17 +
   66.18      /// The cross reference type used for the heap.
   66.19      typedef typename GR::template NodeMap<int> HeapCrossRef;
   66.20  
   66.21 @@ -158,7 +158,7 @@
   66.22        PredMap &_pred;
   66.23        Node _s;
   66.24        Node _t;
   66.25 -      
   66.26 +
   66.27        PotentialMap _dist;
   66.28        std::vector<Node> _proc_nodes;
   66.29  
   66.30 @@ -167,9 +167,9 @@
   66.31        // Constructor
   66.32        ResidualDijkstra(Suurballe &srb) :
   66.33          _graph(srb._graph), _length(srb._length),
   66.34 -        _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred), 
   66.35 +        _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred),
   66.36          _s(srb._s), _t(srb._t), _dist(_graph) {}
   66.37 -        
   66.38 +
   66.39        // Run the algorithm and return true if a path is found
   66.40        // from the source node to the target node.
   66.41        bool run(int cnt) {
   66.42 @@ -177,7 +177,7 @@
   66.43        }
   66.44  
   66.45      private:
   66.46 -    
   66.47 +
   66.48        // Execute the algorithm for the first time (the flow and potential
   66.49        // functions have to be identically zero).
   66.50        bool startFirst() {
   66.51 @@ -348,7 +348,7 @@
   66.52        : public Suurballe<GR, LEN, SetPathTraits<T> > {
   66.53        typedef Suurballe<GR, LEN, SetPathTraits<T> > Create;
   66.54      };
   66.55 -    
   66.56 +
   66.57      template <typename H, typename CR>
   66.58      struct SetHeapTraits : public Traits {
   66.59        typedef H Heap;
   66.60 @@ -359,7 +359,7 @@
   66.61      /// \c Heap and \c HeapCrossRef types.
   66.62      ///
   66.63      /// \ref named-templ-param "Named parameter" for setting \c Heap
   66.64 -    /// and \c HeapCrossRef types with automatic allocation. 
   66.65 +    /// and \c HeapCrossRef types with automatic allocation.
   66.66      /// They will be used for internal Dijkstra computations.
   66.67      /// The heap type must conform to the \ref lemon::concepts::Heap "Heap"
   66.68      /// concept and its priority type must be \c Length.
   66.69 @@ -397,7 +397,7 @@
   66.70  
   66.71      // The pred arc map
   66.72      PredMap _pred;
   66.73 -    
   66.74 +
   66.75      // Data for full init
   66.76      PotentialMap *_init_dist;
   66.77      PredMap *_init_pred;
   66.78 @@ -555,7 +555,7 @@
   66.79          ::Create dijk(_graph, _length);
   66.80        dijk.distMap(*_init_dist).predMap(*_init_pred);
   66.81        dijk.run(s);
   66.82 -      
   66.83 +
   66.84        _full_init = true;
   66.85      }
   66.86  
   66.87 @@ -599,7 +599,7 @@
   66.88      int findFlow(const Node& t, int k = 2) {
   66.89        _t = t;
   66.90        ResidualDijkstra dijkstra(*this);
   66.91 -      
   66.92 +
   66.93        // Initialization
   66.94        for (ArcIt e(_graph); e != INVALID; ++e) {
   66.95          (*_flow)[e] = 0;
   66.96 @@ -613,7 +613,7 @@
   66.97          while ((e = (*_init_pred)[u]) != INVALID) {
   66.98            (*_flow)[e] = 1;
   66.99            u = _graph.source(e);
  66.100 -        }        
  66.101 +        }
  66.102          _path_num = 1;
  66.103        } else {
  66.104          for (NodeIt n(_graph); n != INVALID; ++n) {
    67.1 --- a/lemon/unionfind.h	Wed Mar 17 12:35:52 2010 +0100
    67.2 +++ b/lemon/unionfind.h	Sat Mar 06 14:35:12 2010 +0000
    67.3 @@ -2,7 +2,7 @@
    67.4   *
    67.5   * This file is a part of LEMON, a generic C++ optimization library.
    67.6   *
    67.7 - * Copyright (C) 2003-2009
    67.8 + * Copyright (C) 2003-2010
    67.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   67.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   67.11   *
    68.1 --- a/test/bellman_ford_test.cc	Wed Mar 17 12:35:52 2010 +0100
    68.2 +++ b/test/bellman_ford_test.cc	Sat Mar 06 14:35:12 2010 +0000
    68.3 @@ -2,7 +2,7 @@
    68.4   *
    68.5   * This file is a part of LEMON, a generic C++ optimization library.
    68.6   *
    68.7 - * Copyright (C) 2003-2009
    68.8 + * Copyright (C) 2003-2010
    68.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   68.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   68.11   *
   68.12 @@ -97,7 +97,7 @@
   68.13      p  = const_bf_test.predMap();
   68.14      pp = const_bf_test.path(t);
   68.15      pp = const_bf_test.negativeCycle();
   68.16 -    
   68.17 +
   68.18      for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
   68.19    }
   68.20    {
   68.21 @@ -110,7 +110,7 @@
   68.22      LengthMap length_map;
   68.23      concepts::ReadWriteMap<Node,Arc> pred_map;
   68.24      concepts::ReadWriteMap<Node,Value> dist_map;
   68.25 -    
   68.26 +
   68.27      bf_test
   68.28        .lengthMap(length_map)
   68.29        .predMap(pred_map)
   68.30 @@ -189,7 +189,7 @@
   68.31    check(checkPath(gr, p), "path() found a wrong path.");
   68.32    check(pathSource(gr, p) == s, "path() found a wrong path.");
   68.33    check(pathTarget(gr, p) == t, "path() found a wrong path.");
   68.34 -  
   68.35 +
   68.36    ListPath<Digraph> path;
   68.37    Value dist;
   68.38    bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
   68.39 @@ -228,18 +228,18 @@
   68.40  
   68.41    SmartDigraph gr;
   68.42    IntArcMap length(gr);
   68.43 -  
   68.44 +
   68.45    Node n1 = gr.addNode();
   68.46    Node n2 = gr.addNode();
   68.47    Node n3 = gr.addNode();
   68.48    Node n4 = gr.addNode();
   68.49 -  
   68.50 +
   68.51    Arc a1 = gr.addArc(n1, n2);
   68.52    Arc a2 = gr.addArc(n2, n2);
   68.53 -  
   68.54 +
   68.55    length[a1] = 2;
   68.56    length[a2] = -1;
   68.57 -  
   68.58 +
   68.59    {
   68.60      BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
   68.61      bf.run(n1);
   68.62 @@ -247,21 +247,21 @@
   68.63      check(p.length() == 1 && p.front() == p.back() && p.front() == a2,
   68.64            "Wrong negative cycle.");
   68.65    }
   68.66 - 
   68.67 +
   68.68    length[a2] = 0;
   68.69 -  
   68.70 +
   68.71    {
   68.72      BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
   68.73      bf.run(n1);
   68.74      check(bf.negativeCycle().empty(),
   68.75            "Negative cycle should not be found.");
   68.76    }
   68.77 -  
   68.78 +
   68.79    length[gr.addArc(n1, n3)] = 5;
   68.80    length[gr.addArc(n4, n3)] = 1;
   68.81    length[gr.addArc(n2, n4)] = 2;
   68.82    length[gr.addArc(n3, n2)] = -4;
   68.83 -  
   68.84 +
   68.85    {
   68.86      BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
   68.87      bf.init();
    69.1 --- a/test/bfs_test.cc	Wed Mar 17 12:35:52 2010 +0100
    69.2 +++ b/test/bfs_test.cc	Sat Mar 06 14:35:12 2010 +0000
    69.3 @@ -2,7 +2,7 @@
    69.4   *
    69.5   * This file is a part of LEMON, a generic C++ optimization library.
    69.6   *
    69.7 - * Copyright (C) 2003-2009
    69.8 + * Copyright (C) 2003-2010
    69.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   69.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   69.11   *
   69.12 @@ -83,7 +83,7 @@
   69.13      n = const_bfs_test.nextNode();
   69.14      b = const_bfs_test.emptyQueue();
   69.15      i = const_bfs_test.queueSize();
   69.16 -    
   69.17 +
   69.18      bfs_test.start();
   69.19      bfs_test.start(t);
   69.20      bfs_test.start(nm);
   69.21 @@ -104,12 +104,12 @@
   69.22        ::SetStandardProcessedMap
   69.23        ::SetProcessedMap<concepts::WriteMap<Node,bool> >
   69.24        ::Create bfs_test(G);
   69.25 -      
   69.26 +
   69.27      concepts::ReadWriteMap<Node,Arc> pred_map;
   69.28      concepts::ReadWriteMap<Node,int> dist_map;
   69.29      concepts::ReadWriteMap<Node,bool> reached_map;
   69.30      concepts::WriteMap<Node,bool> processed_map;
   69.31 -    
   69.32 +
   69.33      bfs_test
   69.34        .predMap(pred_map)
   69.35        .distMap(dist_map)
   69.36 @@ -119,7 +119,7 @@
   69.37      bfs_test.run(s);
   69.38      bfs_test.run(s,t);
   69.39      bfs_test.run();
   69.40 -    
   69.41 +
   69.42      bfs_test.init();
   69.43      bfs_test.addSource(s);
   69.44      n = bfs_test.processNextNode();
   69.45 @@ -128,7 +128,7 @@
   69.46      n = bfs_test.nextNode();
   69.47      b = bfs_test.emptyQueue();
   69.48      i = bfs_test.queueSize();
   69.49 -    
   69.50 +
   69.51      bfs_test.start();
   69.52      bfs_test.start(t);
   69.53      bfs_test.start(nm);
    70.1 --- a/test/circulation_test.cc	Wed Mar 17 12:35:52 2010 +0100
    70.2 +++ b/test/circulation_test.cc	Sat Mar 06 14:35:12 2010 +0000
    70.3 @@ -2,7 +2,7 @@
    70.4   *
    70.5   * This file is a part of LEMON, a generic C++ optimization library.
    70.6   *
    70.7 - * Copyright (C) 2003-2009
    70.8 + * Copyright (C) 2003-2010
    70.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   70.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   70.11   *
   70.12 @@ -81,13 +81,13 @@
   70.13              ::Create CirculationType;
   70.14    CirculationType circ_test(g, lcap, ucap, supply);
   70.15    const CirculationType& const_circ_test = circ_test;
   70.16 -   
   70.17 +
   70.18    circ_test
   70.19      .lowerMap(lcap)
   70.20      .upperMap(ucap)
   70.21      .supplyMap(supply)
   70.22      .flowMap(flow);
   70.23 -  
   70.24 +
   70.25    const CirculationType::Elevator& elev = const_circ_test.elevator();
   70.26    circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
   70.27    CirculationType::Tolerance tol = const_circ_test.tolerance();
   70.28 @@ -102,7 +102,7 @@
   70.29    const FlowMap& fm = const_circ_test.flowMap();
   70.30    b = const_circ_test.barrier(n);
   70.31    const_circ_test.barrierMap(bar);
   70.32 -  
   70.33 +
   70.34    ignore_unused_variable_warning(fm);
   70.35  }
   70.36  
    71.1 --- a/test/connectivity_test.cc	Wed Mar 17 12:35:52 2010 +0100
    71.2 +++ b/test/connectivity_test.cc	Sat Mar 06 14:35:12 2010 +0000
    71.3 @@ -2,7 +2,7 @@
    71.4   *
    71.5   * This file is a part of LEMON, a generic C++ optimization library.
    71.6   *
    71.7 - * Copyright (C) 2003-2009
    71.8 + * Copyright (C) 2003-2010
    71.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   71.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   71.11   *
   71.12 @@ -29,12 +29,12 @@
   71.13  {
   71.14    typedef ListDigraph Digraph;
   71.15    typedef Undirector<Digraph> Graph;
   71.16 -  
   71.17 +
   71.18    {
   71.19      Digraph d;
   71.20      Digraph::NodeMap<int> order(d);
   71.21      Graph g(d);
   71.22 -    
   71.23 +
   71.24      check(stronglyConnected(d), "The empty digraph is strongly connected");
   71.25      check(countStronglyConnectedComponents(d) == 0,
   71.26            "The empty digraph has 0 strongly connected component");
   71.27 @@ -48,7 +48,7 @@
   71.28      check(biEdgeConnected(g), "The empty graph is bi-edge-connected");
   71.29      check(countBiEdgeConnectedComponents(g) == 0,
   71.30            "The empty graph has 0 bi-edge-connected component");
   71.31 -          
   71.32 +
   71.33      check(dag(d), "The empty digraph is DAG.");
   71.34      check(checkedTopologicalSort(d, order), "The empty digraph is DAG.");
   71.35      check(loopFree(d), "The empty digraph is loop-free.");
   71.36 @@ -82,7 +82,7 @@
   71.37      check(biEdgeConnected(g), "This graph is bi-edge-connected");
   71.38      check(countBiEdgeConnectedComponents(g) == 1,
   71.39            "This graph has 1 bi-edge-connected component");
   71.40 -          
   71.41 +
   71.42      check(dag(d), "This digraph is DAG.");
   71.43      check(checkedTopologicalSort(d, order), "This digraph is DAG.");
   71.44      check(loopFree(d), "This digraph is loop-free.");
   71.45 @@ -101,14 +101,14 @@
   71.46      Digraph d;
   71.47      Digraph::NodeMap<int> order(d);
   71.48      Graph g(d);
   71.49 -    
   71.50 +
   71.51      Digraph::Node n1 = d.addNode();
   71.52      Digraph::Node n2 = d.addNode();
   71.53      Digraph::Node n3 = d.addNode();
   71.54      Digraph::Node n4 = d.addNode();
   71.55      Digraph::Node n5 = d.addNode();
   71.56      Digraph::Node n6 = d.addNode();
   71.57 -    
   71.58 +
   71.59      d.addArc(n1, n3);
   71.60      d.addArc(n3, n2);
   71.61      d.addArc(n2, n1);
   71.62 @@ -136,23 +136,23 @@
   71.63      check(loopFree(g), "This graph is loop-free.");
   71.64      check(!parallelFree(g), "This graph is not parallel-free.");
   71.65      check(!simpleGraph(g), "This graph is not simple.");
   71.66 -    
   71.67 +
   71.68      d.addArc(n3, n3);
   71.69 -    
   71.70 +
   71.71      check(!loopFree(d), "This digraph is not loop-free.");
   71.72      check(!loopFree(g), "This graph is not loop-free.");
   71.73      check(!simpleGraph(d), "This digraph is not simple.");
   71.74 -    
   71.75 +
   71.76      d.addArc(n3, n2);
   71.77 -    
   71.78 +
   71.79      check(!parallelFree(d), "This digraph is not parallel-free.");
   71.80    }
   71.81 -  
   71.82 +
   71.83    {
   71.84      Digraph d;
   71.85      Digraph::ArcMap<bool> cutarcs(d, false);
   71.86      Graph g(d);
   71.87 -    
   71.88 +
   71.89      Digraph::Node n1 = d.addNode();
   71.90      Digraph::Node n2 = d.addNode();
   71.91      Digraph::Node n3 = d.addNode();
   71.92 @@ -172,7 +172,7 @@
   71.93      d.addArc(n1, n8);
   71.94      d.addArc(n6, n7);
   71.95      d.addArc(n7, n6);
   71.96 -   
   71.97 +
   71.98      check(!stronglyConnected(d), "This digraph is not strongly connected");
   71.99      check(countStronglyConnectedComponents(d) == 3,
  71.100            "This digraph has 3 strongly connected components");
  71.101 @@ -235,7 +235,7 @@
  71.102      // (T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein)
  71.103      Digraph d;
  71.104      Digraph::NodeMap<int> order(d);
  71.105 -    
  71.106 +
  71.107      Digraph::Node belt = d.addNode();
  71.108      Digraph::Node trousers = d.addNode();
  71.109      Digraph::Node necktie = d.addNode();
  71.110 @@ -255,7 +255,7 @@
  71.111      d.addArc(shirt, belt);
  71.112      d.addArc(shirt, necktie);
  71.113      d.addArc(necktie, coat);
  71.114 -    
  71.115 +
  71.116      check(dag(d), "This digraph is DAG.");
  71.117      topologicalSort(d, order);
  71.118      for (Digraph::ArcIt a(d); a != INVALID; ++a) {
  71.119 @@ -267,7 +267,7 @@
  71.120    {
  71.121      ListGraph g;
  71.122      ListGraph::NodeMap<bool> map(g);
  71.123 -    
  71.124 +
  71.125      ListGraph::Node n1 = g.addNode();
  71.126      ListGraph::Node n2 = g.addNode();
  71.127      ListGraph::Node n3 = g.addNode();
  71.128 @@ -283,10 +283,10 @@
  71.129      g.addEdge(n4, n6);
  71.130      g.addEdge(n4, n7);
  71.131      g.addEdge(n5, n7);
  71.132 -   
  71.133 +
  71.134      check(bipartite(g), "This graph is bipartite");
  71.135      check(bipartitePartitions(g, map), "This graph is bipartite");
  71.136 -    
  71.137 +
  71.138      check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7],
  71.139            "Wrong bipartitePartitions()");
  71.140      check(map[n3] == map[n4] && map[n3] == map[n5],
    72.1 --- a/test/dfs_test.cc	Wed Mar 17 12:35:52 2010 +0100
    72.2 +++ b/test/dfs_test.cc	Sat Mar 06 14:35:12 2010 +0000
    72.3 @@ -2,7 +2,7 @@
    72.4   *
    72.5   * This file is a part of LEMON, a generic C++ optimization library.
    72.6   *
    72.7 - * Copyright (C) 2003-2009
    72.8 + * Copyright (C) 2003-2010
    72.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   72.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   72.11   *
   72.12 @@ -83,7 +83,7 @@
   72.13      e = const_dfs_test.nextArc();
   72.14      b = const_dfs_test.emptyQueue();
   72.15      i = const_dfs_test.queueSize();
   72.16 -    
   72.17 +
   72.18      dfs_test.start();
   72.19      dfs_test.start(t);
   72.20      dfs_test.start(am);
   72.21 @@ -109,7 +109,7 @@
   72.22      concepts::ReadWriteMap<Node,int> dist_map;
   72.23      concepts::ReadWriteMap<Node,bool> reached_map;
   72.24      concepts::WriteMap<Node,bool> processed_map;
   72.25 -    
   72.26 +
   72.27      dfs_test
   72.28        .predMap(pred_map)
   72.29        .distMap(dist_map)
   72.30 @@ -126,7 +126,7 @@
   72.31      e = dfs_test.nextArc();
   72.32      b = dfs_test.emptyQueue();
   72.33      i = dfs_test.queueSize();
   72.34 -    
   72.35 +
   72.36      dfs_test.start();
   72.37      dfs_test.start(t);
   72.38      dfs_test.start(am);
    73.1 --- a/test/digraph_test.cc	Wed Mar 17 12:35:52 2010 +0100
    73.2 +++ b/test/digraph_test.cc	Sat Mar 06 14:35:12 2010 +0000
    73.3 @@ -2,7 +2,7 @@
    73.4   *
    73.5   * This file is a part of LEMON, a generic C++ optimization library.
    73.6   *
    73.7 - * Copyright (C) 2003-2009
    73.8 + * Copyright (C) 2003-2010
    73.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   73.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   73.11   *
   73.12 @@ -392,9 +392,9 @@
   73.13    SmartDigraph g;
   73.14    SmartDigraph::NodeMap<StaticDigraph::Node> nref(g);
   73.15    SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g);
   73.16 -  
   73.17 +
   73.18    StaticDigraph G;
   73.19 -  
   73.20 +
   73.21    checkGraphNodeList(G, 0);
   73.22    checkGraphArcList(G, 0);
   73.23  
   73.24 @@ -464,7 +464,7 @@
   73.25    arcs.push_back(std::make_pair(4,1));
   73.26  
   73.27    G.build(6, arcs.begin(), arcs.end());
   73.28 -  
   73.29 +
   73.30    checkGraphNodeList(G, 6);
   73.31    checkGraphArcList(G, 9);
   73.32  
   73.33 @@ -488,7 +488,7 @@
   73.34    checkArcIds(G);
   73.35    checkGraphNodeMap(G);
   73.36    checkGraphArcMap(G);
   73.37 -  
   73.38 +
   73.39    int n = G.nodeNum();
   73.40    int m = G.arcNum();
   73.41    check(G.index(G.node(n-1)) == n-1, "Wrong index.");
    74.1 --- a/test/dijkstra_test.cc	Wed Mar 17 12:35:52 2010 +0100
    74.2 +++ b/test/dijkstra_test.cc	Sat Mar 06 14:35:12 2010 +0000
    74.3 @@ -2,7 +2,7 @@
    74.4   *
    74.5   * This file is a part of LEMON, a generic C++ optimization library.
    74.6   *
    74.7 - * Copyright (C) 2003-2009
    74.8 + * Copyright (C) 2003-2010
    74.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   74.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   74.11   *
   74.12 @@ -85,7 +85,7 @@
   74.13      n = const_dijkstra_test.nextNode();
   74.14      b = const_dijkstra_test.emptyQueue();
   74.15      i = const_dijkstra_test.queueSize();
   74.16 -    
   74.17 +
   74.18      dijkstra_test.start();
   74.19      dijkstra_test.start(t);
   74.20      dijkstra_test.start(nm);
   74.21 @@ -109,7 +109,7 @@
   74.22        ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
   74.23        ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
   74.24        ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
   74.25 -      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >, 
   74.26 +      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
   74.27                  concepts::ReadWriteMap<Node,int> >
   74.28        ::Create dijkstra_test(G,length);
   74.29  
   74.30 @@ -119,7 +119,7 @@
   74.31      concepts::WriteMap<Node,bool> processed_map;
   74.32      concepts::ReadWriteMap<Node,int> heap_cross_ref;
   74.33      BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
   74.34 -    
   74.35 +
   74.36      dijkstra_test
   74.37        .lengthMap(length_map)
   74.38        .predMap(pred_map)
   74.39 @@ -136,7 +136,7 @@
   74.40      n = dijkstra_test.nextNode();
   74.41      b = dijkstra_test.emptyQueue();
   74.42      i = dijkstra_test.queueSize();
   74.43 -    
   74.44 +
   74.45      dijkstra_test.start();
   74.46      dijkstra_test.start(t);
   74.47      dijkstra_test.start(nm);
    75.1 --- a/test/edge_set_test.cc	Wed Mar 17 12:35:52 2010 +0100
    75.2 +++ b/test/edge_set_test.cc	Sat Mar 06 14:35:12 2010 +0000
    75.3 @@ -2,7 +2,7 @@
    75.4   *
    75.5   * This file is a part of LEMON, a generic C++ optimization library.
    75.6   *
    75.7 - * Copyright (C) 2003-2008
    75.8 + * Copyright (C) 2003-2010
    75.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   75.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   75.11   *
    76.1 --- a/test/euler_test.cc	Wed Mar 17 12:35:52 2010 +0100
    76.2 +++ b/test/euler_test.cc	Sat Mar 06 14:35:12 2010 +0000
    76.3 @@ -2,7 +2,7 @@
    76.4   *
    76.5   * This file is a part of LEMON, a generic C++ optimization library.
    76.6   *
    76.7 - * Copyright (C) 2003-2009
    76.8 + * Copyright (C) 2003-2010
    76.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   76.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   76.11   *
   76.12 @@ -85,11 +85,11 @@
   76.13  {
   76.14    typedef ListDigraph Digraph;
   76.15    typedef Undirector<Digraph> Graph;
   76.16 -  
   76.17 +
   76.18    {
   76.19      Digraph d;
   76.20      Graph g(d);
   76.21 -    
   76.22 +
   76.23      checkDiEulerIt(d);
   76.24      checkDiEulerIt(g);
   76.25      checkEulerIt(g);
   76.26 @@ -128,7 +128,7 @@
   76.27      Digraph::Node n1 = d.addNode();
   76.28      Digraph::Node n2 = d.addNode();
   76.29      Digraph::Node n3 = d.addNode();
   76.30 -    
   76.31 +
   76.32      d.addArc(n1, n2);
   76.33      d.addArc(n2, n1);
   76.34      d.addArc(n2, n3);
   76.35 @@ -153,7 +153,7 @@
   76.36      Digraph::Node n4 = d.addNode();
   76.37      Digraph::Node n5 = d.addNode();
   76.38      Digraph::Node n6 = d.addNode();
   76.39 -    
   76.40 +
   76.41      d.addArc(n1, n2);
   76.42      d.addArc(n2, n4);
   76.43      d.addArc(n1, n3);
   76.44 @@ -189,7 +189,7 @@
   76.45      Digraph::Node n3 = d.addNode();
   76.46      Digraph::Node n4 = d.addNode();
   76.47      Digraph::Node n5 = d.addNode();
   76.48 -    
   76.49 +
   76.50      d.addArc(n1, n2);
   76.51      d.addArc(n2, n3);
   76.52      d.addArc(n3, n1);
   76.53 @@ -211,7 +211,7 @@
   76.54      Digraph::Node n1 = d.addNode();
   76.55      Digraph::Node n2 = d.addNode();
   76.56      Digraph::Node n3 = d.addNode();
   76.57 -    
   76.58 +
   76.59      d.addArc(n1, n2);
   76.60      d.addArc(n2, n3);
   76.61  
    77.1 --- a/test/fractional_matching_test.cc	Wed Mar 17 12:35:52 2010 +0100
    77.2 +++ b/test/fractional_matching_test.cc	Sat Mar 06 14:35:12 2010 +0000
    77.3 @@ -2,7 +2,7 @@
    77.4   *
    77.5   * This file is a part of LEMON, a generic C++ optimization library.
    77.6   *
    77.7 - * Copyright (C) 2003-2009
    77.8 + * Copyright (C) 2003-2010
    77.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   77.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   77.11   *
   77.12 @@ -238,7 +238,7 @@
   77.13  
   77.14    for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
   77.15      check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
   77.16 -          (e == mfm.matching(graph.v(e)) ? 1 : 0) == 
   77.17 +          (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
   77.18            mfm.matching(e), "Invalid matching");
   77.19    }
   77.20  
   77.21 @@ -292,7 +292,7 @@
   77.22      }
   77.23      for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
   77.24        check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
   77.25 -            (e == mfm.matching(graph.v(e)) ? 1 : 0) == 
   77.26 +            (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
   77.27              mfm.matching(e), "Invalid matching");
   77.28      }
   77.29    } else {
   77.30 @@ -350,7 +350,7 @@
   77.31  
   77.32    for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
   77.33      check((e == mwfm.matching(graph.u(e)) ? 1 : 0) +
   77.34 -          (e == mwfm.matching(graph.v(e)) ? 1 : 0) == 
   77.35 +          (e == mwfm.matching(graph.v(e)) ? 1 : 0) ==
   77.36            mwfm.matching(e), "Invalid matching");
   77.37    }
   77.38  
   77.39 @@ -410,7 +410,7 @@
   77.40  
   77.41    for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
   77.42      check((e == mwpfm.matching(graph.u(e)) ? 1 : 0) +
   77.43 -          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) == 
   77.44 +          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) ==
   77.45            mwpfm.matching(e), "Invalid matching");
   77.46    }
   77.47  
    78.1 --- a/test/gomory_hu_test.cc	Wed Mar 17 12:35:52 2010 +0100
    78.2 +++ b/test/gomory_hu_test.cc	Sat Mar 06 14:35:12 2010 +0000
    78.3 @@ -1,3 +1,21 @@
    78.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    78.5 + *
    78.6 + * This file is a part of LEMON, a generic C++ optimization library.
    78.7 + *
    78.8 + * Copyright (C) 2003-2010
    78.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   78.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
   78.11 + *
   78.12 + * Permission to use, modify and distribute this software is granted
   78.13 + * provided that this copyright notice appears in all copies. For
   78.14 + * precise terms see the accompanying LICENSE file.
   78.15 + *
   78.16 + * This software is provided "AS IS" with no warranty of any kind,
   78.17 + * express or implied, and with no claim as to its suitability for any
   78.18 + * purpose.
   78.19 + *
   78.20 + */
   78.21 +
   78.22  #include <iostream>
   78.23  
   78.24  #include "test_tools.h"
   78.25 @@ -33,7 +51,7 @@
   78.26    "@attributes\n"
   78.27    "source 0\n"
   78.28    "target 3\n";
   78.29 -  
   78.30 +
   78.31  void checkGomoryHuCompile()
   78.32  {
   78.33    typedef int Value;
   78.34 @@ -69,7 +87,7 @@
   78.35  typedef Graph::NodeMap<bool> BoolNodeMap;
   78.36  
   78.37  int cutValue(const Graph& graph, const BoolNodeMap& cut,
   78.38 -	     const IntEdgeMap& capacity) {
   78.39 +             const IntEdgeMap& capacity) {
   78.40  
   78.41    int sum = 0;
   78.42    for (EdgeIt e(graph); e != INVALID; ++e) {
   78.43 @@ -107,7 +125,7 @@
   78.44  
   78.45        int sum=0;
   78.46        for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
   78.47 -        sum+=capacity[a]; 
   78.48 +        sum+=capacity[a];
   78.49        check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
   78.50  
   78.51        sum=0;
   78.52 @@ -118,6 +136,6 @@
   78.53        check(sum == countNodes(graph), "Problem with MinCutNodeIt");
   78.54      }
   78.55    }
   78.56 -  
   78.57 +
   78.58    return 0;
   78.59  }
    79.1 --- a/test/graph_test.cc	Wed Mar 17 12:35:52 2010 +0100
    79.2 +++ b/test/graph_test.cc	Sat Mar 06 14:35:12 2010 +0000
    79.3 @@ -2,7 +2,7 @@
    79.4   *
    79.5   * This file is a part of LEMON, a generic C++ optimization library.
    79.6   *
    79.7 - * Copyright (C) 2003-2009
    79.8 + * Copyright (C) 2003-2010
    79.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   79.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   79.11   *
   79.12 @@ -264,7 +264,7 @@
   79.13    checkGraphNodeList(G, 4);
   79.14    checkGraphEdgeList(G, 3);
   79.15    checkGraphArcList(G, 6);
   79.16 -  
   79.17 +
   79.18    G.addEdge(G.addNode(), G.addNode());
   79.19  
   79.20    snapshot.restore();
   79.21 @@ -513,7 +513,7 @@
   79.22  
   79.23    G.resize(dim);
   79.24    check(G.dimension() == dim, "Wrong dimension");
   79.25 -  
   79.26 +
   79.27    checkGraphNodeList(G, 1 << dim);
   79.28    checkGraphEdgeList(G, dim * (1 << (dim-1)));
   79.29    checkGraphArcList(G, dim * (1 << dim));
    80.1 --- a/test/hao_orlin_test.cc	Wed Mar 17 12:35:52 2010 +0100
    80.2 +++ b/test/hao_orlin_test.cc	Sat Mar 06 14:35:12 2010 +0000
    80.3 @@ -2,7 +2,7 @@
    80.4   *
    80.5   * This file is a part of LEMON, a generic C++ optimization library.
    80.6   *
    80.7 - * Copyright (C) 2003-2009
    80.8 + * Copyright (C) 2003-2010
    80.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   80.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   80.11   *
   80.12 @@ -83,7 +83,7 @@
   80.13  }
   80.14  
   80.15  template <typename Graph, typename CapMap, typename CutMap>
   80.16 -typename CapMap::Value 
   80.17 +typename CapMap::Value
   80.18    cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
   80.19  {
   80.20    typename CapMap::Value sum = 0;
   80.21 @@ -110,7 +110,7 @@
   80.22      HaoOrlin<SmartDigraph> ho(graph, cap1);
   80.23      ho.run();
   80.24      ho.minCutMap(cut);
   80.25 -    
   80.26 +
   80.27      check(ho.minCutValue() == 1, "Wrong cut value");
   80.28      check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
   80.29    }
   80.30 @@ -126,19 +126,19 @@
   80.31      HaoOrlin<SmartDigraph> ho(graph, cap3);
   80.32      ho.run();
   80.33      ho.minCutMap(cut);
   80.34 -    
   80.35 +
   80.36      check(ho.minCutValue() == 1, "Wrong cut value");
   80.37      check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
   80.38    }
   80.39 -  
   80.40 +
   80.41    typedef Undirector<SmartDigraph> UGraph;
   80.42    UGraph ugraph(graph);
   80.43 -  
   80.44 +
   80.45    {
   80.46      HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap1);
   80.47      ho.run();
   80.48      ho.minCutMap(cut);
   80.49 -    
   80.50 +
   80.51      check(ho.minCutValue() == 2, "Wrong cut value");
   80.52      check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value");
   80.53    }
   80.54 @@ -146,7 +146,7 @@
   80.55      HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap2);
   80.56      ho.run();
   80.57      ho.minCutMap(cut);
   80.58 -    
   80.59 +
   80.60      check(ho.minCutValue() == 5, "Wrong cut value");
   80.61      check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
   80.62    }
   80.63 @@ -154,7 +154,7 @@
   80.64      HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap3);
   80.65      ho.run();
   80.66      ho.minCutMap(cut);
   80.67 -    
   80.68 +
   80.69      check(ho.minCutValue() == 5, "Wrong cut value");
   80.70      check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
   80.71    }
    81.1 --- a/test/maps_test.cc	Wed Mar 17 12:35:52 2010 +0100
    81.2 +++ b/test/maps_test.cc	Sat Mar 06 14:35:12 2010 +0000
    81.3 @@ -2,7 +2,7 @@
    81.4   *
    81.5   * This file is a part of LEMON, a generic C++ optimization library.
    81.6   *
    81.7 - * Copyright (C) 2003-2009
    81.8 + * Copyright (C) 2003-2010
    81.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   81.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   81.11   *
   81.12 @@ -225,7 +225,8 @@
   81.13      B b = functorToMap(F())[A()];
   81.14  
   81.15      checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
   81.16 -    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
   81.17 +    MapToFunctor<ReadMap<A,B> > map =
   81.18 +      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
   81.19  
   81.20      check(functorToMap(&func)[A()] == 3,
   81.21            "Something is wrong with FunctorToMap");
   81.22 @@ -377,7 +378,7 @@
   81.23      for ( LoggerBoolMap<vec::iterator>::Iterator it = map2.begin();
   81.24            it != map2.end(); ++it )
   81.25        check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
   81.26 -    
   81.27 +
   81.28      typedef ListDigraph Graph;
   81.29      DIGRAPH_TYPEDEFS(Graph);
   81.30      Graph gr;
   81.31 @@ -386,13 +387,13 @@
   81.32      Node n1 = gr.addNode();
   81.33      Node n2 = gr.addNode();
   81.34      Node n3 = gr.addNode();
   81.35 -    
   81.36 +
   81.37      gr.addArc(n3, n0);
   81.38      gr.addArc(n3, n2);
   81.39      gr.addArc(n0, n2);
   81.40      gr.addArc(n2, n1);
   81.41      gr.addArc(n0, n1);
   81.42 -    
   81.43 +
   81.44      {
   81.45        std::vector<Node> v;
   81.46        dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
   81.47 @@ -403,12 +404,12 @@
   81.48      {
   81.49        std::vector<Node> v(countNodes(gr));
   81.50        dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
   81.51 -      
   81.52 +
   81.53        check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
   81.54              "Something is wrong with LoggerBoolMap");
   81.55      }
   81.56    }
   81.57 -  
   81.58 +
   81.59    // IdMap, RangeIdMap
   81.60    {
   81.61      typedef ListDigraph Graph;
   81.62 @@ -418,22 +419,22 @@
   81.63      checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
   81.64      checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
   81.65      checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
   81.66 -    
   81.67 +
   81.68      Graph gr;
   81.69      IdMap<Graph, Node> nmap(gr);
   81.70      IdMap<Graph, Arc> amap(gr);
   81.71      RangeIdMap<Graph, Node> nrmap(gr);
   81.72      RangeIdMap<Graph, Arc> armap(gr);
   81.73 -    
   81.74 +
   81.75      Node n0 = gr.addNode();
   81.76      Node n1 = gr.addNode();
   81.77      Node n2 = gr.addNode();
   81.78 -    
   81.79 +
   81.80      Arc a0 = gr.addArc(n0, n1);
   81.81      Arc a1 = gr.addArc(n0, n2);
   81.82      Arc a2 = gr.addArc(n2, n1);
   81.83      Arc a3 = gr.addArc(n2, n0);
   81.84 -    
   81.85 +
   81.86      check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
   81.87      check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
   81.88      check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
   81.89 @@ -445,14 +446,14 @@
   81.90  
   81.91      check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
   81.92      check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
   81.93 -    
   81.94 +
   81.95      check(nrmap.size() == 3 && armap.size() == 4,
   81.96            "Wrong RangeIdMap::size()");
   81.97  
   81.98      check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
   81.99      check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
  81.100      check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
  81.101 -    
  81.102 +
  81.103      check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
  81.104      check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
  81.105      check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
  81.106 @@ -460,32 +461,32 @@
  81.107  
  81.108      check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
  81.109      check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
  81.110 -    
  81.111 +
  81.112      gr.erase(n1);
  81.113 -    
  81.114 +
  81.115      if (nrmap[n0] == 1) nrmap.swap(n0, n2);
  81.116      nrmap.swap(n2, n0);
  81.117      if (armap[a1] == 1) armap.swap(a1, a3);
  81.118      armap.swap(a3, a1);
  81.119 -    
  81.120 +
  81.121      check(nrmap.size() == 2 && armap.size() == 2,
  81.122            "Wrong RangeIdMap::size()");
  81.123  
  81.124      check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
  81.125      check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
  81.126 -    
  81.127 +
  81.128      check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
  81.129      check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
  81.130  
  81.131      check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
  81.132      check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
  81.133    }
  81.134 -  
  81.135 +
  81.136    // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
  81.137    {
  81.138      typedef ListGraph Graph;
  81.139      GRAPH_TYPEDEFS(Graph);
  81.140 -    
  81.141 +
  81.142      checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
  81.143      checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
  81.144      checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
  81.145 @@ -497,19 +498,19 @@
  81.146      Node n0 = gr.addNode();
  81.147      Node n1 = gr.addNode();
  81.148      Node n2 = gr.addNode();
  81.149 -    
  81.150 +
  81.151      gr.addEdge(n0,n1);
  81.152      gr.addEdge(n1,n2);
  81.153      gr.addEdge(n0,n2);
  81.154      gr.addEdge(n2,n1);
  81.155      gr.addEdge(n1,n2);
  81.156      gr.addEdge(n0,n1);
  81.157 -    
  81.158 +
  81.159      for (EdgeIt e(gr); e != INVALID; ++e) {
  81.160        check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
  81.161        check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
  81.162      }
  81.163 -    
  81.164 +
  81.165      check(mapCompare(gr,
  81.166            sourceMap(orienter(gr, constMap<Edge, bool>(true))),
  81.167            targetMap(orienter(gr, constMap<Edge, bool>(false)))),
  81.168 @@ -519,16 +520,16 @@
  81.169      Digraph dgr(gr, constMap<Edge, bool>(true));
  81.170      OutDegMap<Digraph> odm(dgr);
  81.171      InDegMap<Digraph> idm(dgr);
  81.172 -    
  81.173 +
  81.174      check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
  81.175      check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
  81.176 -   
  81.177 +
  81.178      gr.addEdge(n2, n0);
  81.179  
  81.180      check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
  81.181      check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
  81.182    }
  81.183 -  
  81.184 +
  81.185    // CrossRefMap
  81.186    {
  81.187      typedef ListDigraph Graph;
  81.188 @@ -540,19 +541,19 @@
  81.189                   CrossRefMap<Graph, Node, bool> >();
  81.190      checkConcept<ReadWriteMap<Node, double>,
  81.191                   CrossRefMap<Graph, Node, double> >();
  81.192 -    
  81.193 +
  81.194      Graph gr;
  81.195      typedef CrossRefMap<Graph, Node, char> CRMap;
  81.196      CRMap map(gr);
  81.197 -    
  81.198 +
  81.199      Node n0 = gr.addNode();
  81.200      Node n1 = gr.addNode();
  81.201      Node n2 = gr.addNode();
  81.202 -    
  81.203 +
  81.204      map.set(n0, 'A');
  81.205      map.set(n1, 'B');
  81.206      map.set(n2, 'C');
  81.207 -    
  81.208 +
  81.209      check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
  81.210            "Wrong CrossRefMap");
  81.211      check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
  81.212 @@ -561,11 +562,11 @@
  81.213            "Wrong CrossRefMap");
  81.214      check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
  81.215            "Wrong CrossRefMap::count()");
  81.216 -    
  81.217 +
  81.218      CRMap::ValueIt it = map.beginValue();
  81.219      check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
  81.220            it == map.endValue(), "Wrong value iterator");
  81.221 -    
  81.222 +
  81.223      map.set(n2, 'A');
  81.224  
  81.225      check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
  81.226 @@ -603,16 +604,16 @@
  81.227  
  81.228      checkConcept<ReadWriteMap<Node, int>,
  81.229                   CrossRefMap<Graph, Node, int> >();
  81.230 -    
  81.231 +
  81.232      Graph gr;
  81.233      typedef CrossRefMap<Graph, Node, char> CRMap;
  81.234      typedef CRMap::ValueIterator ValueIt;
  81.235      CRMap map(gr);
  81.236 -    
  81.237 +
  81.238      Node n0 = gr.addNode();
  81.239      Node n1 = gr.addNode();
  81.240      Node n2 = gr.addNode();
  81.241 -    
  81.242 +
  81.243      map.set(n0, 'A');
  81.244      map.set(n1, 'B');
  81.245      map.set(n2, 'C');
  81.246 @@ -629,7 +630,7 @@
  81.247      check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
  81.248            it == map.endValue(), "Wrong value iterator");
  81.249    }
  81.250 -  
  81.251 +
  81.252    // Iterable bool map
  81.253    {
  81.254      typedef SmartGraph Graph;
  81.255 @@ -817,7 +818,7 @@
  81.256      check(n == num, "Wrong number");
  81.257  
  81.258    }
  81.259 -  
  81.260 +
  81.261    // Graph map utilities:
  81.262    // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
  81.263    // mapFind(), mapFindIf(), mapCount(), mapCountIf()
  81.264 @@ -829,16 +830,16 @@
  81.265      Node n1 = g.addNode();
  81.266      Node n2 = g.addNode();
  81.267      Node n3 = g.addNode();
  81.268 -    
  81.269 +
  81.270      SmartDigraph::NodeMap<int> map1(g);
  81.271      SmartDigraph::ArcMap<char> map2(g);
  81.272      ConstMap<Node, A> cmap1 = A();
  81.273      ConstMap<Arc, C> cmap2 = C(0);
  81.274 -    
  81.275 +
  81.276      map1[n1] = 10;
  81.277      map1[n2] = 5;
  81.278      map1[n3] = 12;
  81.279 -    
  81.280 +
  81.281      // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
  81.282      check(mapMin(g, map1) == n2, "Wrong mapMin()");
  81.283      check(mapMax(g, map1) == n3, "Wrong mapMax()");
  81.284 @@ -857,7 +858,7 @@
  81.285      Arc a2 = g.addArc(n1, n3);
  81.286      Arc a3 = g.addArc(n2, n3);
  81.287      Arc a4 = g.addArc(n3, n1);
  81.288 -    
  81.289 +
  81.290      map2[a1] = 'b';
  81.291      map2[a2] = 'a';
  81.292      map2[a3] = 'b';
  81.293 @@ -924,7 +925,7 @@
  81.294            "Wrong mapCountIf()");
  81.295      check(mapCountIf(g, map2, Less<char>('a')) == 0,
  81.296            "Wrong mapCountIf()");
  81.297 -     
  81.298 +
  81.299      // MapIt, ConstMapIt
  81.300  /*
  81.301  These tests can be used after applying bugfix #330
  81.302 @@ -934,7 +935,7 @@
  81.303            "Wrong NodeMap<>::MapIt");
  81.304      check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12,
  81.305            "Wrong NodeMap<>::MapIt");
  81.306 -    
  81.307 +
  81.308      int sum = 0;
  81.309      std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum));
  81.310      check(sum == 27, "Wrong NodeMap<>::MapIt");
  81.311 @@ -951,41 +952,41 @@
  81.312  
  81.313      SmartDigraph::NodeMap<int> map3(g, 0);
  81.314      SmartDigraph::ArcMap<char> map4(g, 'a');
  81.315 -    
  81.316 +
  81.317      check(!mapCompare(g, map1, map3), "Wrong mapCompare()");
  81.318 -    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");    
  81.319 -    
  81.320 +    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
  81.321 +
  81.322      mapCopy(g, map1, map3);
  81.323      mapCopy(g, map2, map4);
  81.324  
  81.325      check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()");
  81.326 -    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");    
  81.327 -    
  81.328 +    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
  81.329 +
  81.330      Undirector<SmartDigraph> ug(g);
  81.331      Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x');
  81.332      Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14);
  81.333 -    
  81.334 +
  81.335      check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
  81.336      check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
  81.337      check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
  81.338      check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
  81.339 -    
  81.340 +
  81.341      mapCopy(g, map2, umap1);
  81.342  
  81.343      check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
  81.344      check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
  81.345      check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
  81.346      check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
  81.347 -    
  81.348 +
  81.349      mapCopy(g, map2, umap1);
  81.350      mapCopy(g, umap1, map2);
  81.351      mapCopy(ug, map2, umap1);
  81.352      mapCopy(ug, umap1, map2);
  81.353 -    
  81.354 +
  81.355      check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
  81.356      mapCopy(ug, umap1, umap2);
  81.357      check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
  81.358 -    
  81.359 +
  81.360      check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()");
  81.361      mapFill(g, map1, 2);
  81.362      check(mapCompare(g, constMap<Node>(2), map1), "Wrong mapFill()");
  81.363 @@ -994,6 +995,6 @@
  81.364      mapCopy(g, constMap<Arc>('z'), map2);
  81.365      check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()");
  81.366    }
  81.367 -  
  81.368 +
  81.369    return 0;
  81.370  }
    82.1 --- a/test/matching_test.cc	Wed Mar 17 12:35:52 2010 +0100
    82.2 +++ b/test/matching_test.cc	Sat Mar 06 14:35:12 2010 +0000
    82.3 @@ -2,7 +2,7 @@
    82.4   *
    82.5   * This file is a part of LEMON, a generic C++ optimization library.
    82.6   *
    82.7 - * Copyright (C) 2003-2009
    82.8 + * Copyright (C) 2003-2010
    82.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   82.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   82.11   *
   82.12 @@ -134,7 +134,7 @@
   82.13    mat_test.startSparse();
   82.14    mat_test.startDense();
   82.15    mat_test.run();
   82.16 -  
   82.17 +
   82.18    const_mat_test.matchingSize();
   82.19    const_mat_test.matching(e);
   82.20    const_mat_test.matching(n);
   82.21 @@ -143,7 +143,7 @@
   82.22    e = mmap[n];
   82.23    const_mat_test.mate(n);
   82.24  
   82.25 -  MaxMatching<Graph>::Status stat = 
   82.26 +  MaxMatching<Graph>::Status stat =
   82.27      const_mat_test.status(n);
   82.28    const MaxMatching<Graph>::StatusMap& smap =
   82.29      const_mat_test.statusMap();
   82.30 @@ -170,7 +170,7 @@
   82.31    mat_test.init();
   82.32    mat_test.start();
   82.33    mat_test.run();
   82.34 -  
   82.35 +
   82.36    const_mat_test.matchingWeight();
   82.37    const_mat_test.matchingSize();
   82.38    const_mat_test.matching(e);
   82.39 @@ -179,7 +179,7 @@
   82.40      const_mat_test.matchingMap();
   82.41    e = mmap[n];
   82.42    const_mat_test.mate(n);
   82.43 -  
   82.44 +
   82.45    int k = 0;
   82.46    const_mat_test.dualValue();
   82.47    const_mat_test.nodeValue(n);
   82.48 @@ -207,7 +207,7 @@
   82.49    mat_test.init();
   82.50    mat_test.start();
   82.51    mat_test.run();
   82.52 -  
   82.53 +
   82.54    const_mat_test.matchingWeight();
   82.55    const_mat_test.matching(e);
   82.56    const_mat_test.matching(n);
   82.57 @@ -215,7 +215,7 @@
   82.58      const_mat_test.matchingMap();
   82.59    e = mmap[n];
   82.60    const_mat_test.mate(n);
   82.61 -  
   82.62 +
   82.63    int k = 0;
   82.64    const_mat_test.dualValue();
   82.65    const_mat_test.nodeValue(n);
   82.66 @@ -425,7 +425,7 @@
   82.67      {
   82.68        MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
   82.69        bool result = mwpm.run();
   82.70 -      
   82.71 +
   82.72        check(result == perfect, "Perfect matching found");
   82.73        if (perfect) {
   82.74          checkWeightedPerfectMatching(graph, weight, mwpm);
   82.75 @@ -436,7 +436,7 @@
   82.76        MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
   82.77        mwpm.init();
   82.78        bool result = mwpm.start();
   82.79 -      
   82.80 +
   82.81        check(result == perfect, "Perfect matching found");
   82.82        if (perfect) {
   82.83          checkWeightedPerfectMatching(graph, weight, mwpm);
    83.1 --- a/test/min_cost_arborescence_test.cc	Wed Mar 17 12:35:52 2010 +0100
    83.2 +++ b/test/min_cost_arborescence_test.cc	Sat Mar 06 14:35:12 2010 +0000
    83.3 @@ -2,7 +2,7 @@
    83.4   *
    83.5   * This file is a part of LEMON, a generic C++ optimization library.
    83.6   *
    83.7 - * Copyright (C) 2003-2008
    83.8 + * Copyright (C) 2003-2010
    83.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   83.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   83.11   *
   83.12 @@ -110,7 +110,7 @@
   83.13    n = mcarb_test.processNextNode();
   83.14    b = const_mcarb_test.emptyQueue();
   83.15    i = const_mcarb_test.queueSize();
   83.16 -  
   83.17 +
   83.18    c = const_mcarb_test.arborescenceCost();
   83.19    b = const_mcarb_test.arborescence(e);
   83.20    e = const_mcarb_test.pred(n);
   83.21 @@ -120,12 +120,12 @@
   83.22      const_mcarb_test.predMap();
   83.23    b = const_mcarb_test.reached(n);
   83.24    b = const_mcarb_test.processed(n);
   83.25 -  
   83.26 +
   83.27    i = const_mcarb_test.dualNum();
   83.28    c = const_mcarb_test.dualValue();
   83.29    i = const_mcarb_test.dualSize(i);
   83.30    c = const_mcarb_test.dualValue(i);
   83.31 -  
   83.32 +
   83.33    ignore_unused_variable_warning(am);
   83.34    ignore_unused_variable_warning(pm);
   83.35  }
    84.1 --- a/test/min_cost_flow_test.cc	Wed Mar 17 12:35:52 2010 +0100
    84.2 +++ b/test/min_cost_flow_test.cc	Sat Mar 06 14:35:12 2010 +0000
    84.3 @@ -2,7 +2,7 @@
    84.4   *
    84.5   * This file is a part of LEMON, a generic C++ optimization library.
    84.6   *
    84.7 - * Copyright (C) 2003-2009
    84.8 + * Copyright (C) 2003-2010
    84.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   84.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   84.11   *
   84.12 @@ -52,7 +52,7 @@
   84.13    "   10    -2    0    0    0   -7   -2\n"
   84.14    "   11     0    0    0    0  -10    0\n"
   84.15    "   12   -20  -27    0  -30  -30  -20\n"
   84.16 -  "\n"                
   84.17 +  "\n"
   84.18    "@arcs\n"
   84.19    "       cost  cap low1 low2 low3\n"
   84.20    " 1  2    70   11    0    8    8\n"
   84.21 @@ -102,7 +102,7 @@
   84.22    "5 6     80      0   1000\n"
   84.23    "6 7     30      0  -1000\n"
   84.24    "7 5   -120      0      0\n";
   84.25 -  
   84.26 +
   84.27  char test_neg2_lgf[] =
   84.28    "@nodes\n"
   84.29    "label   sup\n"
   84.30 @@ -151,7 +151,7 @@
   84.31    struct Constraints {
   84.32      void constraints() {
   84.33        checkConcept<concepts::Digraph, GR>();
   84.34 -      
   84.35 +
   84.36        const Constraints& me = *this;
   84.37  
   84.38        MCF mcf(me.g);
   84.39 @@ -180,7 +180,7 @@
   84.40      typedef concepts::ReadMap<Arc, Cost> CAM;
   84.41      typedef concepts::WriteMap<Arc, Value> FlowMap;
   84.42      typedef concepts::WriteMap<Node, Cost> PotMap;
   84.43 -  
   84.44 +
   84.45      GR g;
   84.46      VAM lower;
   84.47      VAM upper;
   84.48 @@ -234,7 +234,7 @@
   84.49  template < typename GR, typename LM, typename UM,
   84.50             typename CM, typename SM, typename FM, typename PM >
   84.51  bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
   84.52 -                     const CM& cost, const SM& supply, const FM& flow, 
   84.53 +                     const CM& cost, const SM& supply, const FM& flow,
   84.54                       const PM& pi, SupplyType type )
   84.55  {
   84.56    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
   84.57 @@ -247,7 +247,7 @@
   84.58            (red_cost > 0 && flow[e] == lower[e]) ||
   84.59            (red_cost < 0 && flow[e] == upper[e]);
   84.60    }
   84.61 -  
   84.62 +
   84.63    for (NodeIt n(gr); opt && n != INVALID; ++n) {
   84.64      typename SM::Value sum = 0;
   84.65      for (OutArcIt e(gr, n); e != INVALID; ++e)
   84.66 @@ -260,7 +260,7 @@
   84.67        opt = (pi[n] >= 0) && (sum == supply[n] || pi[n] == 0);
   84.68      }
   84.69    }
   84.70 -  
   84.71 +
   84.72    return opt;
   84.73  }
   84.74  
   84.75 @@ -285,7 +285,7 @@
   84.76        red_supply[gr.target(a)] += lower[a];
   84.77      }
   84.78    }
   84.79 -  
   84.80 +
   84.81    for (NodeIt n(gr); n != INVALID; ++n) {
   84.82      dual_cost -= red_supply[n] * pi[n];
   84.83    }
   84.84 @@ -294,7 +294,7 @@
   84.85        cost[a] + pi[gr.source(a)] - pi[gr.target(a)];
   84.86      dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
   84.87    }
   84.88 -  
   84.89 +
   84.90    return dual_cost == total;
   84.91  }
   84.92  
   84.93 @@ -332,7 +332,7 @@
   84.94                       bool full_neg_cost_support = false )
   84.95  {
   84.96    MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr);
   84.97 -  
   84.98 +
   84.99    // Basic tests
  84.100    mcf1.upperMap(u).costMap(c).supplyMap(s1);
  84.101    checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s1,
  84.102 @@ -435,7 +435,7 @@
  84.103      .node("source", v)
  84.104      .node("target", w)
  84.105      .run();
  84.106 -  
  84.107 +
  84.108    std::istringstream neg_inp1(test_neg1_lgf);
  84.109    DigraphReader<Digraph>(neg1_gr, neg_inp1)
  84.110      .arcMap("cost", neg1_c)
  84.111 @@ -443,13 +443,13 @@
  84.112      .arcMap("low2", neg1_l2)
  84.113      .nodeMap("sup", neg1_s)
  84.114      .run();
  84.115 -  
  84.116 +
  84.117    std::istringstream neg_inp2(test_neg2_lgf);
  84.118    DigraphReader<Digraph>(neg2_gr, neg_inp2)
  84.119      .arcMap("cost", neg2_c)
  84.120      .nodeMap("sup", neg2_s)
  84.121      .run();
  84.122 -  
  84.123 +
  84.124    // Check the interface of NetworkSimplex
  84.125    {
  84.126      typedef concepts::Digraph GR;
  84.127 @@ -501,7 +501,7 @@
  84.128    }
  84.129  
  84.130    // Test NetworkSimplex
  84.131 -  { 
  84.132 +  {
  84.133      typedef NetworkSimplex<Digraph> MCF;
  84.134      runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);
  84.135      runMcfLeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE");
  84.136 @@ -514,7 +514,7 @@
  84.137      runMcfGeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL", true);
  84.138      runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");
  84.139    }
  84.140 -  
  84.141 +
  84.142    // Test CapacityScaling
  84.143    {
  84.144      typedef CapacityScaling<Digraph> MCF;
    85.1 --- a/test/min_mean_cycle_test.cc	Wed Mar 17 12:35:52 2010 +0100
    85.2 +++ b/test/min_mean_cycle_test.cc	Sat Mar 06 14:35:12 2010 +0000
    85.3 @@ -2,7 +2,7 @@
    85.4   *
    85.5   * This file is a part of LEMON, a generic C++ optimization library.
    85.6   *
    85.7 - * Copyright (C) 2003-2009
    85.8 + * Copyright (C) 2003-2010
    85.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   85.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   85.11   *
   85.12 @@ -61,7 +61,7 @@
   85.13    "6 7    1    1    1    1   0  0  0  0\n"
   85.14    "7 7    4    4    4   -1   0  0  0  1\n";
   85.15  
   85.16 -                        
   85.17 +
   85.18  // Check the interface of an MMC algorithm
   85.19  template <typename GR, typename Cost>
   85.20  struct MmcClassConcept
   85.21 @@ -77,10 +77,10 @@
   85.22          ::Create MmcAlg;
   85.23        MmcAlg mmc(me.g, me.cost);
   85.24        const MmcAlg& const_mmc = mmc;
   85.25 -      
   85.26 +
   85.27        typename MmcAlg::Tolerance tol = const_mmc.tolerance();
   85.28        mmc.tolerance(tol);
   85.29 -      
   85.30 +
   85.31        b = mmc.cycle(p).run();
   85.32        b = mmc.findCycleMean();
   85.33        b = mmc.findCycle();
   85.34 @@ -92,7 +92,7 @@
   85.35      }
   85.36  
   85.37      typedef concepts::ReadMap<typename GR::Arc, Cost> CM;
   85.38 -  
   85.39 +
   85.40      GR g;
   85.41      CM cost;
   85.42      ListPath<GR> p;
   85.43 @@ -153,13 +153,13 @@
   85.44                    KarpMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
   85.45      checkConcept< MmcClassConcept<GR, float>,
   85.46                    KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
   85.47 -    
   85.48 +
   85.49      // HartmannOrlinMmc
   85.50      checkConcept< MmcClassConcept<GR, int>,
   85.51                    HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
   85.52      checkConcept< MmcClassConcept<GR, float>,
   85.53                    HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
   85.54 -    
   85.55 +
   85.56      // HowardMmc
   85.57      checkConcept< MmcClassConcept<GR, int>,
   85.58                    HowardMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
   85.59 @@ -176,11 +176,11 @@
   85.60    {
   85.61      typedef SmartDigraph GR;
   85.62      DIGRAPH_TYPEDEFS(GR);
   85.63 -    
   85.64 +
   85.65      GR gr;
   85.66      IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);
   85.67      IntArcMap c1(gr), c2(gr), c3(gr), c4(gr);
   85.68 -    
   85.69 +
   85.70      std::istringstream input(test_lgf);
   85.71      digraphReader(gr, input).
   85.72        arcMap("len1", l1).
    86.1 --- a/test/preflow_test.cc	Wed Mar 17 12:35:52 2010 +0100
    86.2 +++ b/test/preflow_test.cc	Sat Mar 06 14:35:12 2010 +0000
    86.3 @@ -2,7 +2,7 @@
    86.4   *
    86.5   * This file is a part of LEMON, a generic C++ optimization library.
    86.6   *
    86.7 - * Copyright (C) 2003-2009
    86.8 + * Copyright (C) 2003-2010
    86.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   86.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   86.11   *
   86.12 @@ -94,7 +94,7 @@
   86.13              ::Create PreflowType;
   86.14    PreflowType preflow_test(g, cap, n, n);
   86.15    const PreflowType& const_preflow_test = preflow_test;
   86.16 -  
   86.17 +
   86.18    const PreflowType::Elevator& elev = const_preflow_test.elevator();
   86.19    preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
   86.20    PreflowType::Tolerance tol = const_preflow_test.tolerance();
   86.21 @@ -118,7 +118,7 @@
   86.22    const FlowMap& fm = const_preflow_test.flowMap();
   86.23    b = const_preflow_test.minCut(n);
   86.24    const_preflow_test.minCutMap(cut);
   86.25 -  
   86.26 +
   86.27    ignore_unused_variable_warning(fm);
   86.28  }
   86.29  
    87.1 --- a/test/suurballe_test.cc	Wed Mar 17 12:35:52 2010 +0100
    87.2 +++ b/test/suurballe_test.cc	Sat Mar 06 14:35:12 2010 +0000
    87.3 @@ -2,7 +2,7 @@
    87.4   *
    87.5   * This file is a part of LEMON, a generic C++ optimization library.
    87.6   *
    87.7 - * Copyright (C) 2003-2009
    87.8 + * Copyright (C) 2003-2010
    87.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   87.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   87.11   *
   87.12 @@ -81,7 +81,7 @@
   87.13    typedef Digraph::Node Node;
   87.14    typedef Digraph::Arc Arc;
   87.15    typedef concepts::ReadMap<Arc, VType> LengthMap;
   87.16 -  
   87.17 +
   87.18    typedef Suurballe<Digraph, LengthMap> ST;
   87.19    typedef Suurballe<Digraph, LengthMap>
   87.20      ::SetFlowMap<ST::FlowMap>
   87.21 @@ -114,7 +114,7 @@
   87.22    k = suurb_test.findFlow(n);
   87.23    k = suurb_test.findFlow(n, k);
   87.24    suurb_test.findPaths();
   87.25 -  
   87.26 +
   87.27    int f;
   87.28    VType c;
   87.29    c = const_suurb_test.totalLength();
   87.30 @@ -126,7 +126,7 @@
   87.31      const_suurb_test.potentialMap();
   87.32    k = const_suurb_test.pathNum();
   87.33    Path<Digraph> p = const_suurb_test.path(k);
   87.34 -  
   87.35 +
   87.36    ignore_unused_variable_warning(fm);
   87.37    ignore_unused_variable_warning(pm);
   87.38  }
   87.39 @@ -208,7 +208,7 @@
   87.40    // Check run()
   87.41    {
   87.42      Suurballe<ListDigraph> suurballe(digraph, length);
   87.43 -    
   87.44 +
   87.45      // Find 2 paths
   87.46      check(suurballe.run(s, t) == 2, "Wrong number of paths");
   87.47      check(checkFlow(digraph, suurballe.flowMap(), s, t, 2),
   87.48 @@ -219,7 +219,7 @@
   87.49            "Wrong potentials");
   87.50      for (int i = 0; i < suurballe.pathNum(); ++i)
   87.51        check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
   87.52 -   
   87.53 +
   87.54      // Find 3 paths
   87.55      check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
   87.56      check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
   87.57 @@ -230,7 +230,7 @@
   87.58            "Wrong potentials");
   87.59      for (int i = 0; i < suurballe.pathNum(); ++i)
   87.60        check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
   87.61 -    
   87.62 +
   87.63      // Find 5 paths (only 3 can be found)
   87.64      check(suurballe.run(s, t, 5) == 3, "Wrong number of paths");
   87.65      check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
   87.66 @@ -242,12 +242,12 @@
   87.67      for (int i = 0; i < suurballe.pathNum(); ++i)
   87.68        check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
   87.69    }
   87.70 -  
   87.71 +
   87.72    // Check fullInit() + start()
   87.73    {
   87.74      Suurballe<ListDigraph> suurballe(digraph, length);
   87.75      suurballe.fullInit(s);
   87.76 -    
   87.77 +
   87.78      // Find 2 paths
   87.79      check(suurballe.start(t) == 2, "Wrong number of paths");
   87.80      check(suurballe.totalLength() == 510, "The flow is not optimal");
    88.1 --- a/test/test_tools.h	Wed Mar 17 12:35:52 2010 +0100
    88.2 +++ b/test/test_tools.h	Sat Mar 06 14:35:12 2010 +0000
    88.3 @@ -2,7 +2,7 @@
    88.4   *
    88.5   * This file is a part of LEMON, a generic C++ optimization library.
    88.6   *
    88.7 - * Copyright (C) 2003-2009
    88.8 + * Copyright (C) 2003-2010
    88.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   88.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   88.11   *
   88.12 @@ -45,6 +45,6 @@
   88.13        abort();                                                          \
   88.14      } else { }                                                          \
   88.15    }                                                                     \
   88.16 -    
   88.17 +
   88.18  
   88.19  #endif
    89.1 --- a/tools/dimacs-solver.cc	Wed Mar 17 12:35:52 2010 +0100
    89.2 +++ b/tools/dimacs-solver.cc	Sat Mar 06 14:35:12 2010 +0000
    89.3 @@ -2,7 +2,7 @@
    89.4   *
    89.5   * This file is a part of LEMON, a generic C++ optimization library.
    89.6   *
    89.7 - * Copyright (C) 2003-2009
    89.8 + * Copyright (C) 2003-2010
    89.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   89.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   89.11   *
   89.12 @@ -88,7 +88,7 @@
   89.13    ti.restart();
   89.14    pre.run();
   89.15    if(report) std::cerr << "Run Preflow: " << ti << '\n';
   89.16 -  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  
   89.17 +  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
   89.18  }
   89.19  
   89.20  template<class Value, class LargeValue>
   89.21 @@ -148,7 +148,7 @@
   89.22    mat.run();
   89.23    if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
   89.24    if(report) std::cerr << "\nCardinality of max matching: "
   89.25 -                       << mat.matchingSize() << '\n';  
   89.26 +                       << mat.matchingSize() << '\n';
   89.27  }
   89.28  
   89.29  
   89.30 @@ -166,7 +166,7 @@
   89.31                  << std::endl;
   89.32        exit(1);
   89.33      }
   89.34 -  
   89.35 +
   89.36    switch(desc.type)
   89.37      {
   89.38      case DimacsDescriptor::MIN:
   89.39 @@ -238,7 +238,7 @@
   89.40    std::ostream& os = (ap.files().size()<2 ? std::cout : output);
   89.41  
   89.42    DimacsDescriptor desc = dimacsType(is);
   89.43 -  
   89.44 +
   89.45    if(!ap.given("q"))
   89.46      {
   89.47        std::cout << "Problem type: ";
   89.48 @@ -263,7 +263,7 @@
   89.49        std::cout << "\nNum of arcs:  " << desc.edgeNum;
   89.50        std::cout << "\n\n";
   89.51      }
   89.52 -    
   89.53 +
   89.54    if(ap.given("double"))
   89.55      solve<double, double>(ap,is,os,desc);
   89.56    else if(ap.given("ldouble"))