Unify sources 1.1 r1.1.4
authorAlpar Juttner <alpar@cs.elte.hu>
Mon, 08 Aug 2011 12:36:16 +0200
branch1.1
changeset 761f1398882a928
parent 760 f22bc76370b2
child 762 54abdfda0076
Unify sources
doc/groups.dox
doc/lgf.dox
doc/min_cost_flow.dox
lemon/adaptors.h
lemon/bin_heap.h
lemon/bits/array_map.h
lemon/bits/default_map.h
lemon/bits/edge_set_extender.h
lemon/bits/graph_adaptor_extender.h
lemon/bits/map_extender.h
lemon/bits/path_dump.h
lemon/bits/solver_bits.h
lemon/bits/windows.cc
lemon/cbc.h
lemon/circulation.h
lemon/clp.cc
lemon/clp.h
lemon/concepts/digraph.h
lemon/concepts/graph_components.h
lemon/concepts/maps.h
lemon/connectivity.h
lemon/core.h
lemon/cplex.cc
lemon/dfs.h
lemon/dimacs.h
lemon/edge_set.h
lemon/euler.h
lemon/glpk.h
lemon/gomory_hu.h
lemon/graph_to_eps.h
lemon/hao_orlin.h
lemon/lgf_reader.h
lemon/lgf_writer.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/preflow.h
lemon/soplex.cc
lemon/soplex.h
lemon/suurballe.h
lemon/unionfind.h
test/bfs_test.cc
test/circulation_test.cc
test/connectivity_test.cc
test/dfs_test.cc
test/dijkstra_test.cc
test/edge_set_test.cc
test/euler_test.cc
test/gomory_hu_test.cc
test/graph_copy_test.cc
test/hao_orlin_test.cc
test/heap_test.cc
test/lgf_test.cc
test/maps_test.cc
test/matching_test.cc
test/min_cost_arborescence_test.cc
test/min_cost_flow_test.cc
test/preflow_test.cc
test/suurballe_test.cc
tools/dimacs-solver.cc
     1.1 --- a/doc/groups.dox	Fri Aug 05 09:33:42 2011 +0200
     1.2 +++ b/doc/groups.dox	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     1.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    1.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    1.11   *
    1.12 @@ -275,7 +275,7 @@
    1.13  
    1.14  This group contains the algorithms for finding shortest paths in digraphs.
    1.15  
    1.16 - - \ref Dijkstra Dijkstra's algorithm for finding shortest paths from a 
    1.17 + - \ref Dijkstra Dijkstra's algorithm for finding shortest paths from a
    1.18     source node when all arc lengths are non-negative.
    1.19   - \ref Suurballe A successive shortest path algorithm for finding
    1.20     arc-disjoint paths between two nodes having minimum total length.
    1.21 @@ -306,7 +306,7 @@
    1.22  minimum cut, which is the dual problem of maximum flow.
    1.23  
    1.24  
    1.25 -\ref Circulation is a preflow push-relabel algorithm implemented directly 
    1.26 +\ref Circulation is a preflow push-relabel algorithm implemented directly
    1.27  for finding feasible circulations, which is a somewhat different problem,
    1.28  but it is strongly related to maximum flow.
    1.29  For more information, see \ref Circulation.
     2.1 --- a/doc/lgf.dox	Fri Aug 05 09:33:42 2011 +0200
     2.2 +++ b/doc/lgf.dox	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     2.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    2.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    2.11   *
     3.1 --- a/doc/min_cost_flow.dox	Fri Aug 05 09:33:42 2011 +0200
     3.2 +++ b/doc/min_cost_flow.dox	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     3.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    3.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    3.11   *
    3.12 @@ -81,7 +81,7 @@
    3.13     - \f$\pi(u)<=0\f$;
    3.14     - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
    3.15       then \f$\pi(u)=0\f$.
    3.16 - 
    3.17 +
    3.18  Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc
    3.19  \f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e.
    3.20  \f[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f]
    3.21 @@ -119,7 +119,7 @@
    3.22      sup(u) \quad \forall u\in V \f]
    3.23  \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
    3.24  
    3.25 -It means that the total demand must be less or equal to the 
    3.26 +It means that the total demand must be less or equal to the
    3.27  total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
    3.28  positive) and all the demands have to be satisfied, but there
    3.29  could be supplies that are not carried out from the supply
     4.1 --- a/lemon/adaptors.h	Fri Aug 05 09:33:42 2011 +0200
     4.2 +++ b/lemon/adaptors.h	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     4.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    4.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    4.11   *
    4.12 @@ -418,7 +418,7 @@
    4.13      void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
    4.14        Parent::initialize(digraph);
    4.15        _node_filter = &node_filter;
    4.16 -      _arc_filter = &arc_filter;      
    4.17 +      _arc_filter = &arc_filter;
    4.18      }
    4.19  
    4.20    public:
    4.21 @@ -505,11 +505,11 @@
    4.22    public:
    4.23  
    4.24      template <typename V>
    4.25 -    class NodeMap 
    4.26 -      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, 
    4.27 -	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
    4.28 +    class NodeMap
    4.29 +      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    4.30 +              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
    4.31        typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    4.32 -	LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
    4.33 +        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
    4.34  
    4.35      public:
    4.36        typedef V Value;
    4.37 @@ -532,9 +532,9 @@
    4.38      };
    4.39  
    4.40      template <typename V>
    4.41 -    class ArcMap 
    4.42 +    class ArcMap
    4.43        : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    4.44 -	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
    4.45 +              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
    4.46        typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
    4.47          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
    4.48  
    4.49 @@ -579,7 +579,7 @@
    4.50      void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
    4.51        Parent::initialize(digraph);
    4.52        _node_filter = &node_filter;
    4.53 -      _arc_filter = &arc_filter;      
    4.54 +      _arc_filter = &arc_filter;
    4.55      }
    4.56  
    4.57    public:
    4.58 @@ -648,10 +648,10 @@
    4.59      }
    4.60  
    4.61      template <typename V>
    4.62 -    class NodeMap 
    4.63 +    class NodeMap
    4.64        : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    4.65            LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
    4.66 -      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, 
    4.67 +      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    4.68          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
    4.69  
    4.70      public:
    4.71 @@ -675,7 +675,7 @@
    4.72      };
    4.73  
    4.74      template <typename V>
    4.75 -    class ArcMap 
    4.76 +    class ArcMap
    4.77        : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    4.78            LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
    4.79        typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
    4.80 @@ -1016,10 +1016,10 @@
    4.81      }
    4.82  
    4.83      template <typename V>
    4.84 -    class NodeMap 
    4.85 +    class NodeMap
    4.86        : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
    4.87            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
    4.88 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
    4.89 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
    4.90          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
    4.91  
    4.92      public:
    4.93 @@ -1043,10 +1043,10 @@
    4.94      };
    4.95  
    4.96      template <typename V>
    4.97 -    class ArcMap 
    4.98 +    class ArcMap
    4.99        : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   4.100            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
   4.101 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
   4.102 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   4.103          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
   4.104  
   4.105      public:
   4.106 @@ -1070,10 +1070,10 @@
   4.107      };
   4.108  
   4.109      template <typename V>
   4.110 -    class EdgeMap 
   4.111 +    class EdgeMap
   4.112        : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   4.113          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
   4.114 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
   4.115 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
   4.116          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
   4.117  
   4.118      public:
   4.119 @@ -1112,8 +1112,8 @@
   4.120    protected:
   4.121      NF* _node_filter;
   4.122      EF* _edge_filter;
   4.123 -    SubGraphBase() 
   4.124 -	  : Parent(), _node_filter(0), _edge_filter(0) { }
   4.125 +    SubGraphBase()
   4.126 +          : Parent(), _node_filter(0), _edge_filter(0) { }
   4.127  
   4.128      void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
   4.129        Parent::initialize(graph);
   4.130 @@ -1214,10 +1214,10 @@
   4.131      }
   4.132  
   4.133      template <typename V>
   4.134 -    class NodeMap 
   4.135 +    class NodeMap
   4.136        : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   4.137            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
   4.138 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
   4.139 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   4.140          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
   4.141  
   4.142      public:
   4.143 @@ -1241,10 +1241,10 @@
   4.144      };
   4.145  
   4.146      template <typename V>
   4.147 -    class ArcMap 
   4.148 +    class ArcMap
   4.149        : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   4.150            LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
   4.151 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
   4.152 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   4.153          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
   4.154  
   4.155      public:
   4.156 @@ -1268,11 +1268,11 @@
   4.157      };
   4.158  
   4.159      template <typename V>
   4.160 -    class EdgeMap 
   4.161 +    class EdgeMap
   4.162        : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   4.163          LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
   4.164 -      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
   4.165 -	LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
   4.166 +      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
   4.167 +        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
   4.168  
   4.169      public:
   4.170        typedef V Value;
   4.171 @@ -1495,7 +1495,7 @@
   4.172                       true> > {
   4.173  #endif
   4.174      typedef DigraphAdaptorExtender<
   4.175 -      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, 
   4.176 +      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
   4.177                       true> > Parent;
   4.178  
   4.179    public:
   4.180 @@ -1516,7 +1516,7 @@
   4.181      ///
   4.182      /// Creates a subgraph for the given digraph or graph with the
   4.183      /// given node filter map.
   4.184 -    FilterNodes(GR& graph, NF& node_filter) 
   4.185 +    FilterNodes(GR& graph, NF& node_filter)
   4.186        : Parent(), const_true_map()
   4.187      {
   4.188        Parent::initialize(graph, node_filter, const_true_map);
   4.189 @@ -1554,11 +1554,11 @@
   4.190    class FilterNodes<GR, NF,
   4.191                      typename enable_if<UndirectedTagIndicator<GR> >::type> :
   4.192      public GraphAdaptorExtender<
   4.193 -      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
   4.194 +      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
   4.195                     true> > {
   4.196  
   4.197      typedef GraphAdaptorExtender<
   4.198 -      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
   4.199 +      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
   4.200                     true> > Parent;
   4.201  
   4.202    public:
   4.203 @@ -1642,7 +1642,7 @@
   4.204                       AF, false> > {
   4.205  #endif
   4.206      typedef DigraphAdaptorExtender<
   4.207 -      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, 
   4.208 +      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
   4.209                       AF, false> > Parent;
   4.210  
   4.211    public:
   4.212 @@ -1748,11 +1748,11 @@
   4.213             typename EF = typename GR::template EdgeMap<bool> >
   4.214    class FilterEdges :
   4.215      public GraphAdaptorExtender<
   4.216 -      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >, 
   4.217 +      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
   4.218                     EF, false> > {
   4.219  #endif
   4.220      typedef GraphAdaptorExtender<
   4.221 -      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >, 
   4.222 +      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
   4.223                     EF, false> > Parent;
   4.224  
   4.225    public:
   4.226 @@ -1777,7 +1777,7 @@
   4.227      ///
   4.228      /// Creates a subgraph for the given graph with the given edge
   4.229      /// filter map.
   4.230 -    FilterEdges(GR& graph, EF& edge_filter) 
   4.231 +    FilterEdges(GR& graph, EF& edge_filter)
   4.232        : Parent(), const_true_map() {
   4.233        Parent::initialize(graph, const_true_map, edge_filter);
   4.234      }
   4.235 @@ -1845,7 +1845,7 @@
   4.236        Edge _edge;
   4.237        bool _forward;
   4.238  
   4.239 -      Arc(const Edge& edge, bool forward) 
   4.240 +      Arc(const Edge& edge, bool forward)
   4.241          : _edge(edge), _forward(forward) {}
   4.242  
   4.243      public:
   4.244 @@ -2085,7 +2085,7 @@
   4.245          _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
   4.246  
   4.247        ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
   4.248 -        : _forward(*adaptor._digraph, value), 
   4.249 +        : _forward(*adaptor._digraph, value),
   4.250            _backward(*adaptor._digraph, value) {}
   4.251  
   4.252        void set(const Arc& a, const V& value) {
   4.253 @@ -2203,7 +2203,7 @@
   4.254  
   4.255      typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
   4.256      EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
   4.257 -    
   4.258 +
   4.259      typedef EdgeNotifier ArcNotifier;
   4.260      ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
   4.261  
   4.262 @@ -2707,7 +2707,7 @@
   4.263             typename CM = typename DGR::template ArcMap<int>,
   4.264             typename FM = CM,
   4.265             typename TL = Tolerance<typename CM::Value> >
   4.266 -  class ResidualDigraph 
   4.267 +  class ResidualDigraph
   4.268      : public SubDigraph<
   4.269          Undirector<const DGR>,
   4.270          ConstMap<typename DGR::Node, Const<bool, true> >,
   4.271 @@ -2764,7 +2764,7 @@
   4.272      /// digraph, the capacity map, the flow map, and a tolerance object.
   4.273      ResidualDigraph(const DGR& digraph, const CM& capacity,
   4.274                      FM& flow, const TL& tolerance = Tolerance())
   4.275 -      : Parent(), _capacity(&capacity), _flow(&flow), 
   4.276 +      : Parent(), _capacity(&capacity), _flow(&flow),
   4.277          _graph(digraph), _node_filter(),
   4.278          _forward_filter(capacity, flow, tolerance),
   4.279          _backward_filter(capacity, flow, tolerance),
   4.280 @@ -2846,7 +2846,7 @@
   4.281        typedef typename CapacityMap::Value Value;
   4.282  
   4.283        /// Constructor
   4.284 -      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor) 
   4.285 +      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
   4.286          : _adaptor(&adaptor) {}
   4.287  
   4.288        /// Returns the value associated with the given residual arc
   4.289 @@ -3423,7 +3423,7 @@
   4.290      /// This map adaptor class adapts two node maps of the original digraph
   4.291      /// to get a node map of the split digraph.
   4.292      /// Its value type is inherited from the first node map type (\c IN).
   4.293 -    /// \tparam IN The type of the node map for the in-nodes. 
   4.294 +    /// \tparam IN The type of the node map for the in-nodes.
   4.295      /// \tparam OUT The type of the node map for the out-nodes.
   4.296      template <typename IN, typename OUT>
   4.297      class CombinedNodeMap {
     5.1 --- a/lemon/bin_heap.h	Fri Aug 05 09:33:42 2011 +0200
     5.2 +++ b/lemon/bin_heap.h	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     5.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    5.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    5.11   *
     6.1 --- a/lemon/bits/array_map.h	Fri Aug 05 09:33:42 2011 +0200
     6.2 +++ b/lemon/bits/array_map.h	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     6.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    6.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    6.11   *
    6.12 @@ -70,7 +70,7 @@
    6.13      typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
    6.14  
    6.15    private:
    6.16 -  
    6.17 +
    6.18      // The MapBase of the Map which imlements the core regisitry function.
    6.19      typedef typename Notifier::ObserverBase Parent;
    6.20  
     7.1 --- a/lemon/bits/default_map.h	Fri Aug 05 09:33:42 2011 +0200
     7.2 +++ b/lemon/bits/default_map.h	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     7.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    7.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    7.11   *
    7.12 @@ -157,7 +157,7 @@
    7.13  
    7.14    public:
    7.15      typedef DefaultMap<_Graph, _Item, _Value> Map;
    7.16 -    
    7.17 +
    7.18      typedef typename Parent::GraphType GraphType;
    7.19      typedef typename Parent::Value Value;
    7.20  
     8.1 --- a/lemon/bits/edge_set_extender.h	Fri Aug 05 09:33:42 2011 +0200
     8.2 +++ b/lemon/bits/edge_set_extender.h	Mon Aug 08 12:36:16 2011 +0200
     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-2011
    8.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    8.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    8.14   *
    8.15 @@ -63,11 +63,11 @@
    8.16  
    8.17      Node oppositeNode(const Node &n, const Arc &e) const {
    8.18        if (n == Parent::source(e))
    8.19 -	return Parent::target(e);
    8.20 +        return Parent::target(e);
    8.21        else if(n==Parent::target(e))
    8.22 -	return Parent::source(e);
    8.23 +        return Parent::source(e);
    8.24        else
    8.25 -	return INVALID;
    8.26 +        return INVALID;
    8.27      }
    8.28  
    8.29  
    8.30 @@ -91,7 +91,7 @@
    8.31  
    8.32      // Iterable extensions
    8.33  
    8.34 -    class NodeIt : public Node { 
    8.35 +    class NodeIt : public Node {
    8.36        const Digraph* digraph;
    8.37      public:
    8.38  
    8.39 @@ -100,21 +100,21 @@
    8.40        NodeIt(Invalid i) : Node(i) { }
    8.41  
    8.42        explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
    8.43 -	_graph.first(static_cast<Node&>(*this));
    8.44 +        _graph.first(static_cast<Node&>(*this));
    8.45        }
    8.46  
    8.47 -      NodeIt(const Digraph& _graph, const Node& node) 
    8.48 -	: Node(node), digraph(&_graph) {}
    8.49 +      NodeIt(const Digraph& _graph, const Node& node)
    8.50 +        : Node(node), digraph(&_graph) {}
    8.51  
    8.52 -      NodeIt& operator++() { 
    8.53 -	digraph->next(*this);
    8.54 -	return *this; 
    8.55 +      NodeIt& operator++() {
    8.56 +        digraph->next(*this);
    8.57 +        return *this;
    8.58        }
    8.59  
    8.60      };
    8.61  
    8.62  
    8.63 -    class ArcIt : public Arc { 
    8.64 +    class ArcIt : public Arc {
    8.65        const Digraph* digraph;
    8.66      public:
    8.67  
    8.68 @@ -123,21 +123,21 @@
    8.69        ArcIt(Invalid i) : Arc(i) { }
    8.70  
    8.71        explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
    8.72 -	_graph.first(static_cast<Arc&>(*this));
    8.73 +        _graph.first(static_cast<Arc&>(*this));
    8.74        }
    8.75  
    8.76 -      ArcIt(const Digraph& _graph, const Arc& e) : 
    8.77 -	Arc(e), digraph(&_graph) { }
    8.78 +      ArcIt(const Digraph& _graph, const Arc& e) :
    8.79 +        Arc(e), digraph(&_graph) { }
    8.80  
    8.81 -      ArcIt& operator++() { 
    8.82 -	digraph->next(*this);
    8.83 -	return *this; 
    8.84 +      ArcIt& operator++() {
    8.85 +        digraph->next(*this);
    8.86 +        return *this;
    8.87        }
    8.88  
    8.89      };
    8.90  
    8.91  
    8.92 -    class OutArcIt : public Arc { 
    8.93 +    class OutArcIt : public Arc {
    8.94        const Digraph* digraph;
    8.95      public:
    8.96  
    8.97 @@ -145,23 +145,23 @@
    8.98  
    8.99        OutArcIt(Invalid i) : Arc(i) { }
   8.100  
   8.101 -      OutArcIt(const Digraph& _graph, const Node& node) 
   8.102 -	: digraph(&_graph) {
   8.103 -	_graph.firstOut(*this, node);
   8.104 +      OutArcIt(const Digraph& _graph, const Node& node)
   8.105 +        : digraph(&_graph) {
   8.106 +        _graph.firstOut(*this, node);
   8.107        }
   8.108  
   8.109 -      OutArcIt(const Digraph& _graph, const Arc& arc) 
   8.110 -	: Arc(arc), digraph(&_graph) {}
   8.111 +      OutArcIt(const Digraph& _graph, const Arc& arc)
   8.112 +        : Arc(arc), digraph(&_graph) {}
   8.113  
   8.114 -      OutArcIt& operator++() { 
   8.115 -	digraph->nextOut(*this);
   8.116 -	return *this; 
   8.117 +      OutArcIt& operator++() {
   8.118 +        digraph->nextOut(*this);
   8.119 +        return *this;
   8.120        }
   8.121  
   8.122      };
   8.123  
   8.124  
   8.125 -    class InArcIt : public Arc { 
   8.126 +    class InArcIt : public Arc {
   8.127        const Digraph* digraph;
   8.128      public:
   8.129  
   8.130 @@ -169,17 +169,17 @@
   8.131  
   8.132        InArcIt(Invalid i) : Arc(i) { }
   8.133  
   8.134 -      InArcIt(const Digraph& _graph, const Node& node) 
   8.135 -	: digraph(&_graph) {
   8.136 -	_graph.firstIn(*this, node);
   8.137 +      InArcIt(const Digraph& _graph, const Node& node)
   8.138 +        : digraph(&_graph) {
   8.139 +        _graph.firstIn(*this, node);
   8.140        }
   8.141  
   8.142 -      InArcIt(const Digraph& _graph, const Arc& arc) : 
   8.143 -	Arc(arc), digraph(&_graph) {}
   8.144 +      InArcIt(const Digraph& _graph, const Arc& arc) :
   8.145 +        Arc(arc), digraph(&_graph) {}
   8.146  
   8.147 -      InArcIt& operator++() { 
   8.148 -	digraph->nextIn(*this);
   8.149 -	return *this; 
   8.150 +      InArcIt& operator++() {
   8.151 +        digraph->nextIn(*this);
   8.152 +        return *this;
   8.153        }
   8.154  
   8.155      };
   8.156 @@ -215,26 +215,26 @@
   8.157      using Parent::first;
   8.158  
   8.159      // Mappable extension
   8.160 -    
   8.161 +
   8.162      template <typename _Value>
   8.163 -    class ArcMap 
   8.164 +    class ArcMap
   8.165        : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
   8.166        typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
   8.167  
   8.168      public:
   8.169 -      explicit ArcMap(const Digraph& _g) 
   8.170 -	: Parent(_g) {}
   8.171 -      ArcMap(const Digraph& _g, const _Value& _v) 
   8.172 -	: Parent(_g, _v) {}
   8.173 +      explicit ArcMap(const Digraph& _g)
   8.174 +        : Parent(_g) {}
   8.175 +      ArcMap(const Digraph& _g, const _Value& _v)
   8.176 +        : Parent(_g, _v) {}
   8.177  
   8.178        ArcMap& operator=(const ArcMap& cmap) {
   8.179 -	return operator=<ArcMap>(cmap);
   8.180 +        return operator=<ArcMap>(cmap);
   8.181        }
   8.182  
   8.183        template <typename CMap>
   8.184        ArcMap& operator=(const CMap& cmap) {
   8.185          Parent::operator=(cmap);
   8.186 -	return *this;
   8.187 +        return *this;
   8.188        }
   8.189  
   8.190      };
   8.191 @@ -247,7 +247,7 @@
   8.192        notifier(Arc()).add(arc);
   8.193        return arc;
   8.194      }
   8.195 -    
   8.196 +
   8.197      void clear() {
   8.198        notifier(Arc()).clear();
   8.199        Parent::clear();
   8.200 @@ -312,11 +312,11 @@
   8.201  
   8.202      Node oppositeNode(const Node &n, const Edge &e) const {
   8.203        if( n == Parent::u(e))
   8.204 -	return Parent::v(e);
   8.205 +        return Parent::v(e);
   8.206        else if( n == Parent::v(e))
   8.207 -	return Parent::u(e);
   8.208 +        return Parent::u(e);
   8.209        else
   8.210 -	return INVALID;
   8.211 +        return INVALID;
   8.212      }
   8.213  
   8.214      Arc oppositeArc(const Arc &e) const {
   8.215 @@ -340,7 +340,7 @@
   8.216    public:
   8.217  
   8.218      using Parent::notifier;
   8.219 -    
   8.220 +
   8.221      ArcNotifier& notifier(Arc) const {
   8.222        return arc_notifier;
   8.223      }
   8.224 @@ -350,7 +350,7 @@
   8.225      }
   8.226  
   8.227  
   8.228 -    class NodeIt : public Node { 
   8.229 +    class NodeIt : public Node {
   8.230        const Graph* graph;
   8.231      public:
   8.232  
   8.233 @@ -359,21 +359,21 @@
   8.234        NodeIt(Invalid i) : Node(i) { }
   8.235  
   8.236        explicit NodeIt(const Graph& _graph) : graph(&_graph) {
   8.237 -	_graph.first(static_cast<Node&>(*this));
   8.238 +        _graph.first(static_cast<Node&>(*this));
   8.239        }
   8.240  
   8.241 -      NodeIt(const Graph& _graph, const Node& node) 
   8.242 -	: Node(node), graph(&_graph) {}
   8.243 +      NodeIt(const Graph& _graph, const Node& node)
   8.244 +        : Node(node), graph(&_graph) {}
   8.245  
   8.246 -      NodeIt& operator++() { 
   8.247 -	graph->next(*this);
   8.248 -	return *this; 
   8.249 +      NodeIt& operator++() {
   8.250 +        graph->next(*this);
   8.251 +        return *this;
   8.252        }
   8.253  
   8.254      };
   8.255  
   8.256  
   8.257 -    class ArcIt : public Arc { 
   8.258 +    class ArcIt : public Arc {
   8.259        const Graph* graph;
   8.260      public:
   8.261  
   8.262 @@ -382,21 +382,21 @@
   8.263        ArcIt(Invalid i) : Arc(i) { }
   8.264  
   8.265        explicit ArcIt(const Graph& _graph) : graph(&_graph) {
   8.266 -	_graph.first(static_cast<Arc&>(*this));
   8.267 +        _graph.first(static_cast<Arc&>(*this));
   8.268        }
   8.269  
   8.270 -      ArcIt(const Graph& _graph, const Arc& e) : 
   8.271 -	Arc(e), graph(&_graph) { }
   8.272 +      ArcIt(const Graph& _graph, const Arc& e) :
   8.273 +        Arc(e), graph(&_graph) { }
   8.274  
   8.275 -      ArcIt& operator++() { 
   8.276 -	graph->next(*this);
   8.277 -	return *this; 
   8.278 +      ArcIt& operator++() {
   8.279 +        graph->next(*this);
   8.280 +        return *this;
   8.281        }
   8.282  
   8.283      };
   8.284  
   8.285  
   8.286 -    class OutArcIt : public Arc { 
   8.287 +    class OutArcIt : public Arc {
   8.288        const Graph* graph;
   8.289      public:
   8.290  
   8.291 @@ -404,23 +404,23 @@
   8.292  
   8.293        OutArcIt(Invalid i) : Arc(i) { }
   8.294  
   8.295 -      OutArcIt(const Graph& _graph, const Node& node) 
   8.296 -	: graph(&_graph) {
   8.297 -	_graph.firstOut(*this, node);
   8.298 +      OutArcIt(const Graph& _graph, const Node& node)
   8.299 +        : graph(&_graph) {
   8.300 +        _graph.firstOut(*this, node);
   8.301        }
   8.302  
   8.303 -      OutArcIt(const Graph& _graph, const Arc& arc) 
   8.304 -	: Arc(arc), graph(&_graph) {}
   8.305 +      OutArcIt(const Graph& _graph, const Arc& arc)
   8.306 +        : Arc(arc), graph(&_graph) {}
   8.307  
   8.308 -      OutArcIt& operator++() { 
   8.309 -	graph->nextOut(*this);
   8.310 -	return *this; 
   8.311 +      OutArcIt& operator++() {
   8.312 +        graph->nextOut(*this);
   8.313 +        return *this;
   8.314        }
   8.315  
   8.316      };
   8.317  
   8.318  
   8.319 -    class InArcIt : public Arc { 
   8.320 +    class InArcIt : public Arc {
   8.321        const Graph* graph;
   8.322      public:
   8.323  
   8.324 @@ -428,23 +428,23 @@
   8.325  
   8.326        InArcIt(Invalid i) : Arc(i) { }
   8.327  
   8.328 -      InArcIt(const Graph& _graph, const Node& node) 
   8.329 -	: graph(&_graph) {
   8.330 -	_graph.firstIn(*this, node);
   8.331 +      InArcIt(const Graph& _graph, const Node& node)
   8.332 +        : graph(&_graph) {
   8.333 +        _graph.firstIn(*this, node);
   8.334        }
   8.335  
   8.336 -      InArcIt(const Graph& _graph, const Arc& arc) : 
   8.337 -	Arc(arc), graph(&_graph) {}
   8.338 +      InArcIt(const Graph& _graph, const Arc& arc) :
   8.339 +        Arc(arc), graph(&_graph) {}
   8.340  
   8.341 -      InArcIt& operator++() { 
   8.342 -	graph->nextIn(*this);
   8.343 -	return *this; 
   8.344 +      InArcIt& operator++() {
   8.345 +        graph->nextIn(*this);
   8.346 +        return *this;
   8.347        }
   8.348  
   8.349      };
   8.350  
   8.351  
   8.352 -    class EdgeIt : public Parent::Edge { 
   8.353 +    class EdgeIt : public Parent::Edge {
   8.354        const Graph* graph;
   8.355      public:
   8.356  
   8.357 @@ -453,15 +453,15 @@
   8.358        EdgeIt(Invalid i) : Edge(i) { }
   8.359  
   8.360        explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
   8.361 -	_graph.first(static_cast<Edge&>(*this));
   8.362 +        _graph.first(static_cast<Edge&>(*this));
   8.363        }
   8.364  
   8.365 -      EdgeIt(const Graph& _graph, const Edge& e) : 
   8.366 -	Edge(e), graph(&_graph) { }
   8.367 +      EdgeIt(const Graph& _graph, const Edge& e) :
   8.368 +        Edge(e), graph(&_graph) { }
   8.369  
   8.370 -      EdgeIt& operator++() { 
   8.371 -	graph->next(*this);
   8.372 -	return *this; 
   8.373 +      EdgeIt& operator++() {
   8.374 +        graph->next(*this);
   8.375 +        return *this;
   8.376        }
   8.377  
   8.378      };
   8.379 @@ -477,17 +477,17 @@
   8.380        IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
   8.381  
   8.382        IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
   8.383 -	_graph.firstInc(*this, direction, n);
   8.384 +        _graph.firstInc(*this, direction, n);
   8.385        }
   8.386  
   8.387        IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
   8.388 -	: graph(&_graph), Edge(ue) {
   8.389 -	direction = (_graph.source(ue) == n);
   8.390 +        : graph(&_graph), Edge(ue) {
   8.391 +        direction = (_graph.source(ue) == n);
   8.392        }
   8.393  
   8.394        IncEdgeIt& operator++() {
   8.395 -	graph->nextInc(*this, direction);
   8.396 -	return *this; 
   8.397 +        graph->nextInc(*this, direction);
   8.398 +        return *this;
   8.399        }
   8.400      };
   8.401  
   8.402 @@ -534,49 +534,49 @@
   8.403  
   8.404  
   8.405      template <typename _Value>
   8.406 -    class ArcMap 
   8.407 +    class ArcMap
   8.408        : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
   8.409        typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
   8.410  
   8.411      public:
   8.412 -      explicit ArcMap(const Graph& _g) 
   8.413 -	: Parent(_g) {}
   8.414 -      ArcMap(const Graph& _g, const _Value& _v) 
   8.415 -	: Parent(_g, _v) {}
   8.416 +      explicit ArcMap(const Graph& _g)
   8.417 +        : Parent(_g) {}
   8.418 +      ArcMap(const Graph& _g, const _Value& _v)
   8.419 +        : Parent(_g, _v) {}
   8.420  
   8.421        ArcMap& operator=(const ArcMap& cmap) {
   8.422 -	return operator=<ArcMap>(cmap);
   8.423 +        return operator=<ArcMap>(cmap);
   8.424        }
   8.425  
   8.426        template <typename CMap>
   8.427        ArcMap& operator=(const CMap& cmap) {
   8.428          Parent::operator=(cmap);
   8.429 -	return *this;
   8.430 +        return *this;
   8.431        }
   8.432  
   8.433      };
   8.434  
   8.435  
   8.436      template <typename _Value>
   8.437 -    class EdgeMap 
   8.438 +    class EdgeMap
   8.439        : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
   8.440        typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
   8.441  
   8.442      public:
   8.443 -      explicit EdgeMap(const Graph& _g) 
   8.444 -	: Parent(_g) {}
   8.445 +      explicit EdgeMap(const Graph& _g)
   8.446 +        : Parent(_g) {}
   8.447  
   8.448 -      EdgeMap(const Graph& _g, const _Value& _v) 
   8.449 -	: Parent(_g, _v) {}
   8.450 +      EdgeMap(const Graph& _g, const _Value& _v)
   8.451 +        : Parent(_g, _v) {}
   8.452  
   8.453        EdgeMap& operator=(const EdgeMap& cmap) {
   8.454 -	return operator=<EdgeMap>(cmap);
   8.455 +        return operator=<EdgeMap>(cmap);
   8.456        }
   8.457  
   8.458        template <typename CMap>
   8.459        EdgeMap& operator=(const CMap& cmap) {
   8.460          Parent::operator=(cmap);
   8.461 -	return *this;
   8.462 +        return *this;
   8.463        }
   8.464  
   8.465      };
   8.466 @@ -593,7 +593,7 @@
   8.467        notifier(Arc()).add(arcs);
   8.468        return edge;
   8.469      }
   8.470 -    
   8.471 +
   8.472      void clear() {
   8.473        notifier(Arc()).clear();
   8.474        notifier(Edge()).clear();
   8.475 @@ -619,7 +619,7 @@
   8.476        edge_notifier.clear();
   8.477        arc_notifier.clear();
   8.478      }
   8.479 -    
   8.480 +
   8.481    };
   8.482  
   8.483  }
     9.1 --- a/lemon/bits/graph_adaptor_extender.h	Fri Aug 05 09:33:42 2011 +0200
     9.2 +++ b/lemon/bits/graph_adaptor_extender.h	Mon Aug 08 12:36:16 2011 +0200
     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-2011
     9.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
    9.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
    9.11   *
    10.1 --- a/lemon/bits/map_extender.h	Fri Aug 05 09:33:42 2011 +0200
    10.2 +++ b/lemon/bits/map_extender.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    10.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   10.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   10.11   *
    11.1 --- a/lemon/bits/path_dump.h	Fri Aug 05 09:33:42 2011 +0200
    11.2 +++ b/lemon/bits/path_dump.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    11.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   11.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   11.11   *
    12.1 --- a/lemon/bits/solver_bits.h	Fri Aug 05 09:33:42 2011 +0200
    12.2 +++ b/lemon/bits/solver_bits.h	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    12.8 + * Copyright (C) 2003-2011
    12.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   12.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   12.11   *
    13.1 --- a/lemon/bits/windows.cc	Fri Aug 05 09:33:42 2011 +0200
    13.2 +++ b/lemon/bits/windows.cc	Mon Aug 08 12:36:16 2011 +0200
    13.3 @@ -2,7 +2,7 @@
    13.4   *
    13.5   * This file is a part of LEMON, a generic C++ optimization library.
    13.6   *
    13.7 - * Copyright (C) 2003-2009
    13.8 + * Copyright (C) 2003-2011
    13.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   13.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   13.11   *
   13.12 @@ -98,7 +98,7 @@
   13.13        SYSTEMTIME time;
   13.14        GetSystemTime(&time);
   13.15        char buf1[11], buf2[9], buf3[5];
   13.16 -	  if (GetDateFormat(MY_LOCALE, 0, &time,
   13.17 +          if (GetDateFormat(MY_LOCALE, 0, &time,
   13.18                          ("ddd MMM dd"), buf1, 11) &&
   13.19            GetTimeFormat(MY_LOCALE, 0, &time,
   13.20                          ("HH':'mm':'ss"), buf2, 9) &&
    14.1 --- a/lemon/cbc.h	Fri Aug 05 09:33:42 2011 +0200
    14.2 +++ b/lemon/cbc.h	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    14.8 + * Copyright (C) 2003-2011
    14.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   14.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   14.11   *
   14.12 @@ -120,7 +120,7 @@
   14.13  
   14.14      int _message_level;
   14.15  
   14.16 -    
   14.17 +
   14.18  
   14.19    };
   14.20  
    15.1 --- a/lemon/circulation.h	Fri Aug 05 09:33:42 2011 +0200
    15.2 +++ b/lemon/circulation.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    15.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   15.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   15.11   *
   15.12 @@ -59,8 +59,8 @@
   15.13  
   15.14      /// \brief The type of supply map.
   15.15      ///
   15.16 -    /// The type of the map that stores the signed supply values of the 
   15.17 -    /// nodes. 
   15.18 +    /// The type of the map that stores the signed supply values of the
   15.19 +    /// nodes.
   15.20      /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
   15.21      typedef SM SupplyMap;
   15.22  
   15.23 @@ -134,7 +134,7 @@
   15.24       \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu)
   15.25       \geq sup(u) \quad \forall u\in V, \f]
   15.26       \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
   15.27 -     
   15.28 +
   15.29       The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
   15.30       zero or negative in order to have a feasible solution (since the sum
   15.31       of the expressions on the left-hand side of the inequalities is zero).
   15.32 @@ -144,7 +144,7 @@
   15.33       If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand
   15.34       constraints have to be satisfied with equality, i.e. all demands
   15.35       have to be satisfied and all supplies have to be used.
   15.36 -     
   15.37 +
   15.38       If you need the opposite inequalities in the supply/demand constraints
   15.39       (i.e. the total demand is less than the total supply and all the demands
   15.40       have to be satisfied while there could be supplies that are not used),
   15.41 @@ -325,7 +325,7 @@
   15.42      ///
   15.43      /// \param graph The digraph the algorithm runs on.
   15.44      /// \param lower The lower bounds for the flow values on the arcs.
   15.45 -    /// \param upper The upper bounds (capacities) for the flow values 
   15.46 +    /// \param upper The upper bounds (capacities) for the flow values
   15.47      /// on the arcs.
   15.48      /// \param supply The signed supply values of the nodes.
   15.49      Circulation(const Digraph &graph, const LowerMap &lower,
    16.1 --- a/lemon/clp.cc	Fri Aug 05 09:33:42 2011 +0200
    16.2 +++ b/lemon/clp.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    16.8 + * Copyright (C) 2003-2011
    16.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   16.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   16.11   *
    17.1 --- a/lemon/clp.h	Fri Aug 05 09:33:42 2011 +0200
    17.2 +++ b/lemon/clp.h	Mon Aug 08 12:36:16 2011 +0200
    17.3 @@ -2,7 +2,7 @@
    17.4   *
    17.5   * This file is a part of LEMON, a generic C++ optimization library.
    17.6   *
    17.7 - * Copyright (C) 2003-2008
    17.8 + * Copyright (C) 2003-2011
    17.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   17.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   17.11   *
   17.12 @@ -137,7 +137,7 @@
   17.13      virtual void _clear();
   17.14  
   17.15      virtual void _messageLevel(MessageLevel);
   17.16 -    
   17.17 +
   17.18    public:
   17.19  
   17.20      ///Solves LP with primal simplex method.
    18.1 --- a/lemon/concepts/digraph.h	Fri Aug 05 09:33:42 2011 +0200
    18.2 +++ b/lemon/concepts/digraph.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    18.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   18.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   18.11   *
   18.12 @@ -435,7 +435,7 @@
   18.13  
   18.14        private:
   18.15          ///Copy constructor
   18.16 -        NodeMap(const NodeMap& nm) : 
   18.17 +        NodeMap(const NodeMap& nm) :
   18.18            ReferenceMap<Node, T, T&, const T&>(nm) { }
   18.19          ///Assignment operator
   18.20          template <typename CMap>
    19.1 --- a/lemon/concepts/graph_components.h	Fri Aug 05 09:33:42 2011 +0200
    19.2 +++ b/lemon/concepts/graph_components.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    19.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   19.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   19.11   *
   19.12 @@ -38,7 +38,7 @@
   19.13      ///
   19.14      /// \note This class is a template class so that we can use it to
   19.15      /// create graph skeleton classes. The reason for this is that \c Node
   19.16 -    /// and \c Arc (or \c Edge) types should \e not derive from the same 
   19.17 +    /// and \c Arc (or \c Edge) types should \e not derive from the same
   19.18      /// base class. For \c Node you should instantiate it with character
   19.19      /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
   19.20  #ifndef DOXYGEN
   19.21 @@ -89,7 +89,7 @@
   19.22        /// \brief Ordering operator.
   19.23        ///
   19.24        /// This operator defines an ordering of the items.
   19.25 -      /// It makes possible to use graph item types as key types in 
   19.26 +      /// It makes possible to use graph item types as key types in
   19.27        /// associative containers (e.g. \c std::map).
   19.28        ///
   19.29        /// \note This operator only have to define some strict ordering of
   19.30 @@ -122,7 +122,7 @@
   19.31      ///
   19.32      /// This class describes the base interface of directed graph types.
   19.33      /// All digraph %concepts have to conform to this class.
   19.34 -    /// It just provides types for nodes and arcs and functions 
   19.35 +    /// It just provides types for nodes and arcs and functions
   19.36      /// to get the source and the target nodes of arcs.
   19.37      class BaseDigraphComponent {
   19.38      public:
   19.39 @@ -426,7 +426,7 @@
   19.40  
   19.41      /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
   19.42      ///
   19.43 -    /// This class describes the concept of \c NodeIt, \c ArcIt and 
   19.44 +    /// This class describes the concept of \c NodeIt, \c ArcIt and
   19.45      /// \c EdgeIt subtypes of digraph and graph types.
   19.46      template <typename GR, typename Item>
   19.47      class GraphItemIt : public Item {
   19.48 @@ -466,7 +466,7 @@
   19.49        /// This operator increments the iterator, i.e. assigns it to the
   19.50        /// next item.
   19.51        GraphItemIt& operator++() { return *this; }
   19.52 - 
   19.53 +
   19.54        /// \brief Equality operator
   19.55        ///
   19.56        /// Equality operator.
   19.57 @@ -501,15 +501,15 @@
   19.58        };
   19.59      };
   19.60  
   19.61 -    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
   19.62 +    /// \brief Concept class for \c InArcIt, \c OutArcIt and
   19.63      /// \c IncEdgeIt types.
   19.64      ///
   19.65 -    /// This class describes the concept of \c InArcIt, \c OutArcIt 
   19.66 +    /// This class describes the concept of \c InArcIt, \c OutArcIt
   19.67      /// and \c IncEdgeIt subtypes of digraph and graph types.
   19.68      ///
   19.69      /// \note Since these iterator classes do not inherit from the same
   19.70      /// base class, there is an additional template parameter (selector)
   19.71 -    /// \c sel. For \c InArcIt you should instantiate it with character 
   19.72 +    /// \c sel. For \c InArcIt you should instantiate it with character
   19.73      /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
   19.74      template <typename GR,
   19.75                typename Item = typename GR::Arc,
   19.76 @@ -530,10 +530,10 @@
   19.77        /// Copy constructor.
   19.78        GraphIncIt(const GraphIncIt& it) : Item(it) {}
   19.79  
   19.80 -      /// \brief Constructor that sets the iterator to the first 
   19.81 +      /// \brief Constructor that sets the iterator to the first
   19.82        /// incoming or outgoing arc.
   19.83        ///
   19.84 -      /// Constructor that sets the iterator to the first arc 
   19.85 +      /// Constructor that sets the iterator to the first arc
   19.86        /// incoming to or outgoing from the given node.
   19.87        explicit GraphIncIt(const GR&, const Base&) {}
   19.88  
   19.89 @@ -804,16 +804,16 @@
   19.90  
   19.91        /// \brief Return the first edge incident to the given node.
   19.92        ///
   19.93 -      /// This function gives back the first edge incident to the given 
   19.94 +      /// This function gives back the first edge incident to the given
   19.95        /// node. The bool parameter gives back the direction for which the
   19.96 -      /// source node of the directed arc representing the edge is the 
   19.97 +      /// source node of the directed arc representing the edge is the
   19.98        /// given node.
   19.99        void firstInc(Edge&, bool&, const Node&) const {}
  19.100  
  19.101        /// \brief Gives back the next of the edges from the
  19.102        /// given node.
  19.103        ///
  19.104 -      /// This function gives back the next edge incident to the given 
  19.105 +      /// This function gives back the next edge incident to the given
  19.106        /// node. The bool parameter should be used as \c firstInc() use it.
  19.107        void nextInc(Edge&, bool&) const {}
  19.108  
  19.109 @@ -990,7 +990,7 @@
  19.110      /// \brief Concept class for standard graph maps.
  19.111      ///
  19.112      /// This class describes the concept of standard graph maps, i.e.
  19.113 -    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
  19.114 +    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
  19.115      /// graph types, which can be used for associating data to graph items.
  19.116      /// The standard graph maps must conform to the ReferenceMap concept.
  19.117      template <typename GR, typename K, typename V>
  19.118 @@ -1045,7 +1045,7 @@
  19.119              <ReferenceMap<Key, Value, Value&, const Value&>, _Map>();
  19.120            _Map m1(g);
  19.121            _Map m2(g,t);
  19.122 -          
  19.123 +
  19.124            // Copy constructor
  19.125            // _Map m3(m);
  19.126  
  19.127 @@ -1068,7 +1068,7 @@
  19.128      /// \brief Skeleton class for mappable directed graphs.
  19.129      ///
  19.130      /// This class describes the interface of mappable directed graphs.
  19.131 -    /// It extends \ref BaseDigraphComponent with the standard digraph 
  19.132 +    /// It extends \ref BaseDigraphComponent with the standard digraph
  19.133      /// map classes, namely \c NodeMap and \c ArcMap.
  19.134      /// This concept is part of the Digraph concept.
  19.135      template <typename BAS = BaseDigraphComponent>
  19.136 @@ -1205,7 +1205,7 @@
  19.137      /// \brief Skeleton class for mappable undirected graphs.
  19.138      ///
  19.139      /// This class describes the interface of mappable undirected graphs.
  19.140 -    /// It extends \ref MappableDigraphComponent with the standard graph 
  19.141 +    /// It extends \ref MappableDigraphComponent with the standard graph
  19.142      /// map class for edges (\c EdgeMap).
  19.143      /// This concept is part of the Graph concept.
  19.144      template <typename BAS = BaseGraphComponent>
  19.145 @@ -1290,7 +1290,7 @@
  19.146      /// \brief Skeleton class for extendable directed graphs.
  19.147      ///
  19.148      /// This class describes the interface of extendable directed graphs.
  19.149 -    /// It extends \ref BaseDigraphComponent with functions for adding 
  19.150 +    /// It extends \ref BaseDigraphComponent with functions for adding
  19.151      /// nodes and arcs to the digraph.
  19.152      /// This concept requires \ref AlterableDigraphComponent.
  19.153      template <typename BAS = BaseDigraphComponent>
  19.154 @@ -1334,7 +1334,7 @@
  19.155      /// \brief Skeleton class for extendable undirected graphs.
  19.156      ///
  19.157      /// This class describes the interface of extendable undirected graphs.
  19.158 -    /// It extends \ref BaseGraphComponent with functions for adding 
  19.159 +    /// It extends \ref BaseGraphComponent with functions for adding
  19.160      /// nodes and edges to the graph.
  19.161      /// This concept requires \ref AlterableGraphComponent.
  19.162      template <typename BAS = BaseGraphComponent>
  19.163 @@ -1378,7 +1378,7 @@
  19.164      /// \brief Skeleton class for erasable directed graphs.
  19.165      ///
  19.166      /// This class describes the interface of erasable directed graphs.
  19.167 -    /// It extends \ref BaseDigraphComponent with functions for removing 
  19.168 +    /// It extends \ref BaseDigraphComponent with functions for removing
  19.169      /// nodes and arcs from the digraph.
  19.170      /// This concept requires \ref AlterableDigraphComponent.
  19.171      template <typename BAS = BaseDigraphComponent>
  19.172 @@ -1391,7 +1391,7 @@
  19.173  
  19.174        /// \brief Erase a node from the digraph.
  19.175        ///
  19.176 -      /// This function erases the given node from the digraph and all arcs 
  19.177 +      /// This function erases the given node from the digraph and all arcs
  19.178        /// connected to the node.
  19.179        void erase(const Node&) {}
  19.180  
  19.181 @@ -1417,7 +1417,7 @@
  19.182      /// \brief Skeleton class for erasable undirected graphs.
  19.183      ///
  19.184      /// This class describes the interface of erasable undirected graphs.
  19.185 -    /// It extends \ref BaseGraphComponent with functions for removing 
  19.186 +    /// It extends \ref BaseGraphComponent with functions for removing
  19.187      /// nodes and edges from the graph.
  19.188      /// This concept requires \ref AlterableGraphComponent.
  19.189      template <typename BAS = BaseGraphComponent>
    20.1 --- a/lemon/concepts/maps.h	Fri Aug 05 09:33:42 2011 +0200
    20.2 +++ b/lemon/concepts/maps.h	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    20.8 + * Copyright (C) 2003-2011
    20.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   20.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   20.11   *
    21.1 --- a/lemon/connectivity.h	Fri Aug 05 09:33:42 2011 +0200
    21.2 +++ b/lemon/connectivity.h	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    21.8 + * Copyright (C) 2003-2011
    21.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   21.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   21.11   *
   21.12 @@ -258,7 +258,7 @@
   21.13    ///
   21.14    /// \return \c true if the digraph is strongly connected.
   21.15    /// \note By definition, the empty digraph is strongly connected.
   21.16 -  /// 
   21.17 +  ///
   21.18    /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   21.19    /// \see connected()
   21.20    template <typename Digraph>
   21.21 @@ -310,7 +310,7 @@
   21.22  
   21.23    /// \ingroup graph_properties
   21.24    ///
   21.25 -  /// \brief Count the number of strongly connected components of a 
   21.26 +  /// \brief Count the number of strongly connected components of a
   21.27    /// directed graph
   21.28    ///
   21.29    /// This function counts the number of strongly connected components of
   21.30 @@ -744,7 +744,7 @@
   21.31    ///
   21.32    /// \brief Check whether an undirected graph is bi-node-connected.
   21.33    ///
   21.34 -  /// This function checks whether the given undirected graph is 
   21.35 +  /// This function checks whether the given undirected graph is
   21.36    /// bi-node-connected, i.e. any two edges are on same circle.
   21.37    ///
   21.38    /// \return \c true if the graph bi-node-connected.
   21.39 @@ -758,7 +758,7 @@
   21.40  
   21.41    /// \ingroup graph_properties
   21.42    ///
   21.43 -  /// \brief Count the number of bi-node-connected components of an 
   21.44 +  /// \brief Count the number of bi-node-connected components of an
   21.45    /// undirected graph.
   21.46    ///
   21.47    /// This function counts the number of bi-node-connected components of
   21.48 @@ -812,7 +812,7 @@
   21.49    /// \param graph The undirected graph.
   21.50    /// \retval compMap A writable edge map. The values will be set from 0
   21.51    /// to the number of the bi-node-connected components minus one. Each
   21.52 -  /// value of the map will be set exactly once, and the values of a 
   21.53 +  /// value of the map will be set exactly once, and the values of a
   21.54    /// certain component will be set continuously.
   21.55    /// \return The number of bi-node-connected components.
   21.56    ///
   21.57 @@ -858,7 +858,7 @@
   21.58    /// the components.
   21.59    ///
   21.60    /// \param graph The undirected graph.
   21.61 -  /// \retval cutMap A writable node map. The values will be set to 
   21.62 +  /// \retval cutMap A writable node map. The values will be set to
   21.63    /// \c true for the nodes that separate two or more components
   21.64    /// (exactly once for each cut node), and will not be changed for
   21.65    /// other nodes.
   21.66 @@ -1085,7 +1085,7 @@
   21.67    ///
   21.68    /// \brief Check whether an undirected graph is bi-edge-connected.
   21.69    ///
   21.70 -  /// This function checks whether the given undirected graph is 
   21.71 +  /// This function checks whether the given undirected graph is
   21.72    /// bi-edge-connected, i.e. any two nodes are connected with at least
   21.73    /// two edge-disjoint paths.
   21.74    ///
   21.75 @@ -1192,7 +1192,7 @@
   21.76    /// \brief Find the bi-edge-connected cut edges in an undirected graph.
   21.77    ///
   21.78    /// This function finds the bi-edge-connected cut edges in the given
   21.79 -  /// undirected graph. 
   21.80 +  /// undirected graph.
   21.81    ///
   21.82    /// The bi-edge-connected components are the classes of an equivalence
   21.83    /// relation on the nodes of an undirected graph. Two nodes are in the
   21.84 @@ -1349,7 +1349,7 @@
   21.85    ///
   21.86    /// \param digraph The digraph.
   21.87    /// \retval order A readable and writable node map. The values will be
   21.88 -  /// set from 0 to the number of the nodes in the digraph minus one. 
   21.89 +  /// set from 0 to the number of the nodes in the digraph minus one.
   21.90    /// Each value of the map will be set exactly once, and the values will
   21.91    /// be set descending order.
   21.92    /// \return \c false if the digraph is not DAG.
    22.1 --- a/lemon/core.h	Fri Aug 05 09:33:42 2011 +0200
    22.2 +++ b/lemon/core.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    22.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   22.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   22.11   *
   22.12 @@ -1241,7 +1241,8 @@
   22.13  
   22.14    protected:
   22.15  
   22.16 -    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
   22.17 +    class AutoNodeMap :
   22.18 +      public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
   22.19        typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
   22.20  
   22.21      public:
   22.22 @@ -1280,7 +1281,7 @@
   22.23        }
   22.24      };
   22.25  
   22.26 -  protected: 
   22.27 +  protected:
   22.28  
   22.29      const Digraph &_g;
   22.30      AutoNodeMap _head;
    23.1 --- a/lemon/cplex.cc	Fri Aug 05 09:33:42 2011 +0200
    23.2 +++ b/lemon/cplex.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    23.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   23.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   23.11   *
   23.12 @@ -456,7 +456,7 @@
   23.13    }
   23.14  
   23.15    void CplexBase::_applyMessageLevel() {
   23.16 -    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, 
   23.17 +    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
   23.18                     _message_enabled ? CPX_ON : CPX_OFF);
   23.19    }
   23.20  
    24.1 --- a/lemon/dfs.h	Fri Aug 05 09:33:42 2011 +0200
    24.2 +++ b/lemon/dfs.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    24.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   24.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   24.11   *
    25.1 --- a/lemon/dimacs.h	Fri Aug 05 09:33:42 2011 +0200
    25.2 +++ b/lemon/dimacs.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    25.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   25.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   25.11   *
   25.12 @@ -61,7 +61,7 @@
   25.13    ///Discover the type of a DIMACS file
   25.14  
   25.15    ///This function starts seeking the beginning of the given file for the
   25.16 -  ///problem type and size info. 
   25.17 +  ///problem type and size info.
   25.18    ///The found data is returned in a special struct that can be evaluated
   25.19    ///and passed to the appropriate reader function.
   25.20    DimacsDescriptor dimacsType(std::istream& is)
   25.21 @@ -212,7 +212,7 @@
   25.22        infty = std::numeric_limits<Capacity>::has_infinity ?
   25.23          std::numeric_limits<Capacity>::infinity() :
   25.24          std::numeric_limits<Capacity>::max();
   25.25 - 
   25.26 +
   25.27      while (is >> c) {
   25.28        switch (c) {
   25.29        case 'c': // comment line
   25.30 @@ -237,7 +237,7 @@
   25.31            getline(is, str);
   25.32            e = g.addArc(nodes[i], nodes[j]);
   25.33            capacity.set(e, _cap);
   25.34 -        } 
   25.35 +        }
   25.36          else if (desc.type==DimacsDescriptor::MAX) {
   25.37            is >> i >> j >> _cap;
   25.38            getline(is, str);
   25.39 @@ -362,11 +362,11 @@
   25.40    {
   25.41      g.addArc(s,t);
   25.42    }
   25.43 -  
   25.44 +
   25.45    /// \brief DIMACS plain (di)graph reader function.
   25.46    ///
   25.47    /// This function reads a plain (di)graph without any designated nodes
   25.48 -  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
   25.49 +  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
   25.50    /// DIMACS files having a line starting with
   25.51    /// \code
   25.52    ///   p mat
   25.53 @@ -392,7 +392,7 @@
   25.54      for (int k = 1; k <= desc.nodeNum; ++k) {
   25.55        nodes[k] = g.addNode();
   25.56      }
   25.57 -    
   25.58 +
   25.59      while (is >> c) {
   25.60        switch (c) {
   25.61        case 'c': // comment line
    26.1 --- a/lemon/edge_set.h	Fri Aug 05 09:33:42 2011 +0200
    26.2 +++ b/lemon/edge_set.h	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    26.8 + * Copyright (C) 2003-2011
    26.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   26.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   26.11   *
    27.1 --- a/lemon/euler.h	Fri Aug 05 09:33:42 2011 +0200
    27.2 +++ b/lemon/euler.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    27.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   27.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   27.11   *
   27.12 @@ -26,7 +26,7 @@
   27.13  
   27.14  /// \ingroup graph_properties
   27.15  /// \file
   27.16 -/// \brief Euler tour iterators and a function for checking the \e Eulerian 
   27.17 +/// \brief Euler tour iterators and a function for checking the \e Eulerian
   27.18  /// property.
   27.19  ///
   27.20  ///This file provides Euler tour iterators and a function to check
   27.21 @@ -41,7 +41,7 @@
   27.22    ///graph (if there exists) and it converts to the \c Arc type of the digraph.
   27.23    ///
   27.24    ///For example, if the given digraph has an Euler tour (i.e it has only one
   27.25 -  ///non-trivial component and the in-degree is equal to the out-degree 
   27.26 +  ///non-trivial component and the in-degree is equal to the out-degree
   27.27    ///for all nodes), then the following code will put the arcs of \c g
   27.28    ///to the vector \c et according to an Euler tour of \c g.
   27.29    ///\code
   27.30 @@ -138,7 +138,7 @@
   27.31    ///\e undirected graph (if there exists) and it converts to the \c Arc
   27.32    ///and \c Edge types of the graph.
   27.33    ///
   27.34 -  ///For example, if the given graph has an Euler tour (i.e it has only one 
   27.35 +  ///For example, if the given graph has an Euler tour (i.e it has only one
   27.36    ///non-trivial component and the degree of each node is even),
   27.37    ///the following code will print the arc IDs according to an
   27.38    ///Euler tour of \c g.
   27.39 @@ -147,7 +147,7 @@
   27.40    ///    std::cout << g.id(Edge(e)) << std::eol;
   27.41    ///  }
   27.42    ///\endcode
   27.43 -  ///Although this iterator is for undirected graphs, it still returns 
   27.44 +  ///Although this iterator is for undirected graphs, it still returns
   27.45    ///arcs in order to indicate the direction of the tour.
   27.46    ///(But arcs convert to edges, of course.)
   27.47    ///
   27.48 @@ -233,7 +233,7 @@
   27.49  
   27.50      /// Postfix incrementation.
   27.51      ///
   27.52 -    ///\warning This incrementation returns an \c Arc (which converts to 
   27.53 +    ///\warning This incrementation returns an \c Arc (which converts to
   27.54      ///an \c Edge), not an \ref EulerIt, as one may expect.
   27.55      Arc operator++(int)
   27.56      {
    28.1 --- a/lemon/glpk.h	Fri Aug 05 09:33:42 2011 +0200
    28.2 +++ b/lemon/glpk.h	Mon Aug 08 12:36:16 2011 +0200
    28.3 @@ -2,7 +2,7 @@
    28.4   *
    28.5   * This file is a part of LEMON, a generic C++ optimization library.
    28.6   *
    28.7 - * Copyright (C) 2003-2008
    28.8 + * Copyright (C) 2003-2011
    28.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   28.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   28.11   *
   28.12 @@ -30,7 +30,7 @@
   28.13    namespace _solver_bits {
   28.14      class VoidPtr {
   28.15      private:
   28.16 -      void *_ptr;      
   28.17 +      void *_ptr;
   28.18      public:
   28.19        VoidPtr() : _ptr(0) {}
   28.20  
   28.21 @@ -38,8 +38,8 @@
   28.22        VoidPtr(T* ptr) : _ptr(reinterpret_cast<void*>(ptr)) {}
   28.23  
   28.24        template <typename T>
   28.25 -      VoidPtr& operator=(T* ptr) { 
   28.26 -        _ptr = reinterpret_cast<void*>(ptr); 
   28.27 +      VoidPtr& operator=(T* ptr) {
   28.28 +        _ptr = reinterpret_cast<void*>(ptr);
   28.29          return *this;
   28.30        }
   28.31  
   28.32 @@ -123,13 +123,13 @@
   28.33          freeEnv();
   28.34        }
   28.35      };
   28.36 -    
   28.37 +
   28.38      static FreeEnvHelper freeEnvHelper;
   28.39  
   28.40    protected:
   28.41 -    
   28.42 +
   28.43      int _message_level;
   28.44 -    
   28.45 +
   28.46    public:
   28.47  
   28.48      ///Pointer to the underlying GLPK data structure.
    29.1 --- a/lemon/gomory_hu.h	Fri Aug 05 09:33:42 2011 +0200
    29.2 +++ b/lemon/gomory_hu.h	Mon Aug 08 12:36:16 2011 +0200
    29.3 @@ -1,8 +1,8 @@
    29.4 -/* -*- C++ -*-
    29.5 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    29.6   *
    29.7 - * This file is a part of LEMON, a generic C++ optimization library
    29.8 + * This file is a part of LEMON, a generic C++ optimization library.
    29.9   *
   29.10 - * Copyright (C) 2003-2008
   29.11 + * Copyright (C) 2003-2011
   29.12   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   29.13   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   29.14   *
   29.15 @@ -27,7 +27,7 @@
   29.16  #include <lemon/concepts/maps.h>
   29.17  
   29.18  /// \ingroup min_cut
   29.19 -/// \file 
   29.20 +/// \file
   29.21  /// \brief Gomory-Hu cut tree in graphs.
   29.22  
   29.23  namespace lemon {
   29.24 @@ -38,13 +38,13 @@
   29.25    ///
   29.26    /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   29.27    /// may contain edges which are not in the original graph. It has the
   29.28 -  /// property that the minimum capacity edge of the path between two nodes 
   29.29 +  /// property that the minimum capacity edge of the path between two nodes
   29.30    /// in this tree has the same weight as the minimum cut in the graph
   29.31    /// between these nodes. Moreover the components obtained by removing
   29.32    /// this edge from the tree determine the corresponding minimum cut.
   29.33    /// Therefore once this tree is computed, the minimum cut between any pair
   29.34    /// of nodes can easily be obtained.
   29.35 -  /// 
   29.36 +  ///
   29.37    /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
   29.38    /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
   29.39    /// time complexity. It calculates a rooted Gomory-Hu tree.
   29.40 @@ -60,10 +60,10 @@
   29.41    /// The default map type is \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
   29.42  #ifdef DOXYGEN
   29.43    template <typename GR,
   29.44 -	    typename CAP>
   29.45 +            typename CAP>
   29.46  #else
   29.47    template <typename GR,
   29.48 -	    typename CAP = typename GR::template EdgeMap<int> >
   29.49 +            typename CAP = typename GR::template EdgeMap<int> >
   29.50  #endif
   29.51    class GomoryHu {
   29.52    public:
   29.53 @@ -74,7 +74,7 @@
   29.54      typedef CAP Capacity;
   29.55      /// The value type of capacities
   29.56      typedef typename Capacity::Value Value;
   29.57 -    
   29.58 +
   29.59    private:
   29.60  
   29.61      TEMPLATE_GRAPH_TYPEDEFS(Graph);
   29.62 @@ -89,28 +89,28 @@
   29.63  
   29.64      void createStructures() {
   29.65        if (!_pred) {
   29.66 -	_pred = new typename Graph::template NodeMap<Node>(_graph);
   29.67 +        _pred = new typename Graph::template NodeMap<Node>(_graph);
   29.68        }
   29.69        if (!_weight) {
   29.70 -	_weight = new typename Graph::template NodeMap<Value>(_graph);
   29.71 +        _weight = new typename Graph::template NodeMap<Value>(_graph);
   29.72        }
   29.73        if (!_order) {
   29.74 -	_order = new typename Graph::template NodeMap<int>(_graph);
   29.75 +        _order = new typename Graph::template NodeMap<int>(_graph);
   29.76        }
   29.77      }
   29.78  
   29.79      void destroyStructures() {
   29.80        if (_pred) {
   29.81 -	delete _pred;
   29.82 +        delete _pred;
   29.83        }
   29.84        if (_weight) {
   29.85 -	delete _weight;
   29.86 +        delete _weight;
   29.87        }
   29.88        if (_order) {
   29.89 -	delete _order;
   29.90 +        delete _order;
   29.91        }
   29.92      }
   29.93 -  
   29.94 +
   29.95    public:
   29.96  
   29.97      /// \brief Constructor
   29.98 @@ -118,9 +118,9 @@
   29.99      /// Constructor.
  29.100      /// \param graph The undirected graph the algorithm runs on.
  29.101      /// \param capacity The edge capacity map.
  29.102 -    GomoryHu(const Graph& graph, const Capacity& capacity) 
  29.103 +    GomoryHu(const Graph& graph, const Capacity& capacity)
  29.104        : _graph(graph), _capacity(capacity),
  29.105 -	_pred(0), _weight(0), _order(0) 
  29.106 +        _pred(0), _weight(0), _order(0)
  29.107      {
  29.108        checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
  29.109      }
  29.110 @@ -134,7 +134,7 @@
  29.111      }
  29.112  
  29.113    private:
  29.114 -  
  29.115 +
  29.116      // Initialize the internal data structures
  29.117      void init() {
  29.118        createStructures();
  29.119 @@ -145,7 +145,7 @@
  29.120          (*_order)[n] = -1;
  29.121        }
  29.122        (*_pred)[_root] = INVALID;
  29.123 -      (*_weight)[_root] = std::numeric_limits<Value>::max(); 
  29.124 +      (*_weight)[_root] = std::numeric_limits<Value>::max();
  29.125      }
  29.126  
  29.127  
  29.128 @@ -154,50 +154,50 @@
  29.129        Preflow<Graph, Capacity> fa(_graph, _capacity, _root, INVALID);
  29.130  
  29.131        for (NodeIt n(_graph); n != INVALID; ++n) {
  29.132 -	if (n == _root) continue;
  29.133 +        if (n == _root) continue;
  29.134  
  29.135 -	Node pn = (*_pred)[n];
  29.136 -	fa.source(n);
  29.137 -	fa.target(pn);
  29.138 +        Node pn = (*_pred)[n];
  29.139 +        fa.source(n);
  29.140 +        fa.target(pn);
  29.141  
  29.142 -	fa.runMinCut();
  29.143 +        fa.runMinCut();
  29.144  
  29.145 -	(*_weight)[n] = fa.flowValue();
  29.146 +        (*_weight)[n] = fa.flowValue();
  29.147  
  29.148 -	for (NodeIt nn(_graph); nn != INVALID; ++nn) {
  29.149 -	  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
  29.150 -	    (*_pred)[nn] = n;
  29.151 -	  }
  29.152 -	}
  29.153 -	if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
  29.154 -	  (*_pred)[n] = (*_pred)[pn];
  29.155 -	  (*_pred)[pn] = n;
  29.156 -	  (*_weight)[n] = (*_weight)[pn];
  29.157 -	  (*_weight)[pn] = fa.flowValue();
  29.158 -	}
  29.159 +        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
  29.160 +          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
  29.161 +            (*_pred)[nn] = n;
  29.162 +          }
  29.163 +        }
  29.164 +        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
  29.165 +          (*_pred)[n] = (*_pred)[pn];
  29.166 +          (*_pred)[pn] = n;
  29.167 +          (*_weight)[n] = (*_weight)[pn];
  29.168 +          (*_weight)[pn] = fa.flowValue();
  29.169 +        }
  29.170        }
  29.171  
  29.172        (*_order)[_root] = 0;
  29.173        int index = 1;
  29.174  
  29.175        for (NodeIt n(_graph); n != INVALID; ++n) {
  29.176 -	std::vector<Node> st;
  29.177 -	Node nn = n;
  29.178 -	while ((*_order)[nn] == -1) {
  29.179 -	  st.push_back(nn);
  29.180 -	  nn = (*_pred)[nn];
  29.181 -	}
  29.182 -	while (!st.empty()) {
  29.183 -	  (*_order)[st.back()] = index++;
  29.184 -	  st.pop_back();
  29.185 -	}
  29.186 +        std::vector<Node> st;
  29.187 +        Node nn = n;
  29.188 +        while ((*_order)[nn] == -1) {
  29.189 +          st.push_back(nn);
  29.190 +          nn = (*_pred)[nn];
  29.191 +        }
  29.192 +        while (!st.empty()) {
  29.193 +          (*_order)[st.back()] = index++;
  29.194 +          st.pop_back();
  29.195 +        }
  29.196        }
  29.197      }
  29.198  
  29.199    public:
  29.200  
  29.201      ///\name Execution Control
  29.202 - 
  29.203 +
  29.204      ///@{
  29.205  
  29.206      /// \brief Run the Gomory-Hu algorithm.
  29.207 @@ -207,7 +207,7 @@
  29.208        init();
  29.209        start();
  29.210      }
  29.211 -    
  29.212 +
  29.213      /// @}
  29.214  
  29.215      ///\name Query Functions
  29.216 @@ -232,7 +232,7 @@
  29.217      /// \brief Return the weight of the predecessor edge in the
  29.218      /// Gomory-Hu tree.
  29.219      ///
  29.220 -    /// This function returns the weight of the predecessor edge of the 
  29.221 +    /// This function returns the weight of the predecessor edge of the
  29.222      /// given node in the Gomory-Hu tree.
  29.223      /// If \c node is the root of the tree, the result is undefined.
  29.224      ///
  29.225 @@ -254,7 +254,7 @@
  29.226      /// \brief Return the minimum cut value between two nodes
  29.227      ///
  29.228      /// This function returns the minimum cut value between the nodes
  29.229 -    /// \c s and \c t. 
  29.230 +    /// \c s and \c t.
  29.231      /// It finds the nearest common ancestor of the given nodes in the
  29.232      /// Gomory-Hu tree and calculates the minimum weight edge on the
  29.233      /// paths to the ancestor.
  29.234 @@ -263,15 +263,15 @@
  29.235      Value minCutValue(const Node& s, const Node& t) const {
  29.236        Node sn = s, tn = t;
  29.237        Value value = std::numeric_limits<Value>::max();
  29.238 -      
  29.239 +
  29.240        while (sn != tn) {
  29.241 -	if ((*_order)[sn] < (*_order)[tn]) {
  29.242 -	  if ((*_weight)[tn] <= value) value = (*_weight)[tn];
  29.243 -	  tn = (*_pred)[tn];
  29.244 -	} else {
  29.245 -	  if ((*_weight)[sn] <= value) value = (*_weight)[sn];
  29.246 -	  sn = (*_pred)[sn];
  29.247 -	}
  29.248 +        if ((*_order)[sn] < (*_order)[tn]) {
  29.249 +          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
  29.250 +          tn = (*_pred)[tn];
  29.251 +        } else {
  29.252 +          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
  29.253 +          sn = (*_pred)[sn];
  29.254 +        }
  29.255        }
  29.256        return value;
  29.257      }
  29.258 @@ -294,33 +294,33 @@
  29.259      ///
  29.260      /// \pre \ref run() must be called before using this function.
  29.261      template <typename CutMap>
  29.262 -    Value minCutMap(const Node& s, ///< 
  29.263 +    Value minCutMap(const Node& s, ///<
  29.264                      const Node& t,
  29.265 -                    ///< 
  29.266 +                    ///<
  29.267                      CutMap& cutMap
  29.268 -                    ///< 
  29.269 +                    ///<
  29.270                      ) const {
  29.271        Node sn = s, tn = t;
  29.272        bool s_root=false;
  29.273        Node rn = INVALID;
  29.274        Value value = std::numeric_limits<Value>::max();
  29.275 -      
  29.276 +
  29.277        while (sn != tn) {
  29.278 -	if ((*_order)[sn] < (*_order)[tn]) {
  29.279 -	  if ((*_weight)[tn] <= value) {
  29.280 -	    rn = tn;
  29.281 +        if ((*_order)[sn] < (*_order)[tn]) {
  29.282 +          if ((*_weight)[tn] <= value) {
  29.283 +            rn = tn;
  29.284              s_root = false;
  29.285 -	    value = (*_weight)[tn];
  29.286 -	  }
  29.287 -	  tn = (*_pred)[tn];
  29.288 -	} else {
  29.289 -	  if ((*_weight)[sn] <= value) {
  29.290 -	    rn = sn;
  29.291 +            value = (*_weight)[tn];
  29.292 +          }
  29.293 +          tn = (*_pred)[tn];
  29.294 +        } else {
  29.295 +          if ((*_weight)[sn] <= value) {
  29.296 +            rn = sn;
  29.297              s_root = true;
  29.298 -	    value = (*_weight)[sn];
  29.299 -	  }
  29.300 -	  sn = (*_pred)[sn];
  29.301 -	}
  29.302 +            value = (*_weight)[sn];
  29.303 +          }
  29.304 +          sn = (*_pred)[sn];
  29.305 +        }
  29.306        }
  29.307  
  29.308        typename Graph::template NodeMap<bool> reached(_graph, false);
  29.309 @@ -331,18 +331,18 @@
  29.310  
  29.311        std::vector<Node> st;
  29.312        for (NodeIt n(_graph); n != INVALID; ++n) {
  29.313 -	st.clear();
  29.314 +        st.clear();
  29.315          Node nn = n;
  29.316 -	while (!reached[nn]) {
  29.317 -	  st.push_back(nn);
  29.318 -	  nn = (*_pred)[nn];
  29.319 -	}
  29.320 -	while (!st.empty()) {
  29.321 -	  cutMap.set(st.back(), cutMap[nn]);
  29.322 -	  st.pop_back();
  29.323 -	}
  29.324 +        while (!reached[nn]) {
  29.325 +          st.push_back(nn);
  29.326 +          nn = (*_pred)[nn];
  29.327 +        }
  29.328 +        while (!st.empty()) {
  29.329 +          cutMap.set(st.back(), cutMap[nn]);
  29.330 +          st.pop_back();
  29.331 +        }
  29.332        }
  29.333 -      
  29.334 +
  29.335        return value;
  29.336      }
  29.337  
  29.338 @@ -351,7 +351,7 @@
  29.339      friend class MinCutNodeIt;
  29.340  
  29.341      /// Iterate on the nodes of a minimum cut
  29.342 -    
  29.343 +
  29.344      /// This iterator class lists the nodes of a minimum cut found by
  29.345      /// GomoryHu. Before using it, you must allocate a GomoryHu class
  29.346      /// and call its \ref GomoryHu::run() "run()" method.
  29.347 @@ -444,11 +444,11 @@
  29.348          return n;
  29.349        }
  29.350      };
  29.351 -    
  29.352 +
  29.353      friend class MinCutEdgeIt;
  29.354 -    
  29.355 +
  29.356      /// Iterate on the edges of a minimum cut
  29.357 -    
  29.358 +
  29.359      /// This iterator class lists the edges of a minimum cut found by
  29.360      /// GomoryHu. Before using it, you must allocate a GomoryHu class
  29.361      /// and call its \ref GomoryHu::run() "run()" method.
  29.362 @@ -481,7 +481,7 @@
  29.363                _arc_it=typename Graph::OutArcIt(_graph,_node_it);
  29.364            }
  29.365        }
  29.366 -      
  29.367 +
  29.368      public:
  29.369        /// Constructor
  29.370  
  29.371 @@ -550,7 +550,7 @@
  29.372          return *this;
  29.373        }
  29.374        /// Postfix incrementation
  29.375 -      
  29.376 +
  29.377        /// Postfix incrementation.
  29.378        ///
  29.379        /// \warning This incrementation
    30.1 --- a/lemon/graph_to_eps.h	Fri Aug 05 09:33:42 2011 +0200
    30.2 +++ b/lemon/graph_to_eps.h	Mon Aug 08 12:36:16 2011 +0200
    30.3 @@ -2,7 +2,7 @@
    30.4   *
    30.5   * This file is a part of LEMON, a generic C++ optimization library.
    30.6   *
    30.7 - * Copyright (C) 2003-2009
    30.8 + * Copyright (C) 2003-2011
    30.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   30.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   30.11   *
    31.1 --- a/lemon/hao_orlin.h	Fri Aug 05 09:33:42 2011 +0200
    31.2 +++ b/lemon/hao_orlin.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    31.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   31.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   31.11   *
   31.12 @@ -31,7 +31,7 @@
   31.13  /// \ingroup min_cut
   31.14  /// \brief Implementation of the Hao-Orlin algorithm.
   31.15  ///
   31.16 -/// Implementation of the Hao-Orlin algorithm for finding a minimum cut 
   31.17 +/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
   31.18  /// in a digraph.
   31.19  
   31.20  namespace lemon {
   31.21 @@ -41,7 +41,7 @@
   31.22    /// \brief Hao-Orlin algorithm for finding a minimum cut in a digraph.
   31.23    ///
   31.24    /// This class implements the Hao-Orlin algorithm for finding a minimum
   31.25 -  /// value cut in a directed graph \f$D=(V,A)\f$. 
   31.26 +  /// value cut in a directed graph \f$D=(V,A)\f$.
   31.27    /// It takes a fixed node \f$ source \in V \f$ and
   31.28    /// consists of two phases: in the first phase it determines a
   31.29    /// minimum cut with \f$ source \f$ on the source-side (i.e. a set
   31.30 @@ -58,7 +58,7 @@
   31.31    ///
   31.32    /// For an undirected graph you can run just the first phase of the
   31.33    /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
   31.34 -  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ 
   31.35 +  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
   31.36    /// time. It is implemented in the NagamochiIbaraki algorithm class.
   31.37    ///
   31.38    /// \tparam GR The type of the digraph the algorithm runs on.
   31.39 @@ -76,7 +76,7 @@
   31.40  #endif
   31.41    class HaoOrlin {
   31.42    public:
   31.43 -   
   31.44 +
   31.45      /// The digraph type of the algorithm
   31.46      typedef GR Digraph;
   31.47      /// The capacity map type of the algorithm
   31.48 @@ -847,7 +847,7 @@
   31.49      /// \brief Initialize the internal data structures.
   31.50      ///
   31.51      /// This function initializes the internal data structures. It creates
   31.52 -    /// the maps and some bucket structures for the algorithm. 
   31.53 +    /// the maps and some bucket structures for the algorithm.
   31.54      /// The given node is used as the source node for the push-relabel
   31.55      /// algorithm.
   31.56      void init(const Node& source) {
   31.57 @@ -927,7 +927,7 @@
   31.58  
   31.59      /// \brief Run the algorithm.
   31.60      ///
   31.61 -    /// This function runs the algorithm. It uses the given \c source node, 
   31.62 +    /// This function runs the algorithm. It uses the given \c source node,
   31.63      /// finds a proper \c target node and then calls the \ref init(),
   31.64      /// \ref calculateOut() and \ref calculateIn().
   31.65      void run(const Node& s) {
   31.66 @@ -941,7 +941,7 @@
   31.67      /// \name Query Functions
   31.68      /// The result of the %HaoOrlin algorithm
   31.69      /// can be obtained using these functions.\n
   31.70 -    /// \ref run(), \ref calculateOut() or \ref calculateIn() 
   31.71 +    /// \ref run(), \ref calculateOut() or \ref calculateIn()
   31.72      /// should be called before using them.
   31.73  
   31.74      /// @{
   31.75 @@ -950,7 +950,7 @@
   31.76      ///
   31.77      /// This function returns the value of the minimum cut.
   31.78      ///
   31.79 -    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
   31.80 +    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
   31.81      /// must be called before using this function.
   31.82      Value minCutValue() const {
   31.83        return _min_cut;
   31.84 @@ -969,7 +969,7 @@
   31.85      ///
   31.86      /// \return The value of the minimum cut.
   31.87      ///
   31.88 -    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
   31.89 +    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
   31.90      /// must be called before using this function.
   31.91      template <typename CutMap>
   31.92      Value minCutMap(CutMap& cutMap) const {
    32.1 --- a/lemon/lgf_reader.h	Fri Aug 05 09:33:42 2011 +0200
    32.2 +++ b/lemon/lgf_reader.h	Mon Aug 08 12:36:16 2011 +0200
    32.3 @@ -562,7 +562,7 @@
    32.4      template <typename TDGR>
    32.5      friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
    32.6      template <typename TDGR>
    32.7 -    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, 
    32.8 +    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
    32.9                                               const std::string& fn);
   32.10      template <typename TDGR>
   32.11      friend DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn);
   32.12 @@ -1194,14 +1194,14 @@
   32.13      /// @}
   32.14  
   32.15    };
   32.16 -  
   32.17 +
   32.18    /// \ingroup lemon_io
   32.19    ///
   32.20    /// \brief Return a \ref DigraphReader class
   32.21    ///
   32.22    /// This function just returns a \ref DigraphReader class.
   32.23    ///
   32.24 -  /// With this function a digraph can be read from an 
   32.25 +  /// With this function a digraph can be read from an
   32.26    /// \ref lgf-format "LGF" file or input stream with several maps and
   32.27    /// attributes. For example, there is network flow problem on a
   32.28    /// digraph, i.e. a digraph with a \e capacity map on the arcs and
   32.29 @@ -1256,7 +1256,7 @@
   32.30  
   32.31    template <typename GR>
   32.32    class GraphReader;
   32.33 - 
   32.34 +
   32.35    template <typename TGR>
   32.36    GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
   32.37    template <typename TGR>
   32.38 @@ -1393,7 +1393,7 @@
   32.39      template <typename TGR>
   32.40      friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
   32.41      template <typename TGR>
   32.42 -    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 
   32.43 +    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
   32.44      template <typename TGR>
   32.45      friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
   32.46  
   32.47 @@ -2077,9 +2077,9 @@
   32.48    ///
   32.49    /// \brief Return a \ref GraphReader class
   32.50    ///
   32.51 -  /// This function just returns a \ref GraphReader class. 
   32.52 +  /// This function just returns a \ref GraphReader class.
   32.53    ///
   32.54 -  /// With this function a graph can be read from an 
   32.55 +  /// With this function a graph can be read from an
   32.56    /// \ref lgf-format "LGF" file or input stream with several maps and
   32.57    /// attributes. For example, there is weighted matching problem on a
   32.58    /// graph, i.e. a graph with a \e weight map on the edges. This
    33.1 --- a/lemon/lgf_writer.h	Fri Aug 05 09:33:42 2011 +0200
    33.2 +++ b/lemon/lgf_writer.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    33.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   33.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   33.11   *
   33.12 @@ -351,7 +351,7 @@
   33.13    class DigraphWriter;
   33.14  
   33.15    template <typename TDGR>
   33.16 -  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
   33.17 +  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   33.18                                     std::ostream& os = std::cout);
   33.19    template <typename TDGR>
   33.20    DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const std::string& fn);
   33.21 @@ -504,7 +504,7 @@
   33.22    private:
   33.23  
   33.24      template <typename TDGR>
   33.25 -    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
   33.26 +    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   33.27                                               std::ostream& os);
   33.28      template <typename TDGR>
   33.29      friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   33.30 @@ -917,7 +917,7 @@
   33.31    ///
   33.32    /// \brief Return a \ref DigraphWriter class
   33.33    ///
   33.34 -  /// This function just returns a \ref DigraphWriter class. 
   33.35 +  /// This function just returns a \ref DigraphWriter class.
   33.36    ///
   33.37    /// With this function a digraph can be write to a file or output
   33.38    /// stream in \ref lgf-format "LGF" format with several maps and
   33.39 @@ -957,7 +957,7 @@
   33.40    /// \relates DigraphWriter
   33.41    /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   33.42    template <typename TDGR>
   33.43 -  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
   33.44 +  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
   33.45                                      const std::string& fn) {
   33.46      DigraphWriter<TDGR> tmp(digraph, fn);
   33.47      return tmp;
   33.48 @@ -1101,11 +1101,11 @@
   33.49      template <typename TGR>
   33.50      friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
   33.51      template <typename TGR>
   33.52 -    friend GraphWriter<TGR> graphWriter(const TGR& graph, 
   33.53 +    friend GraphWriter<TGR> graphWriter(const TGR& graph,
   33.54                                          const std::string& fn);
   33.55      template <typename TGR>
   33.56      friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
   33.57 -    
   33.58 +
   33.59      GraphWriter(GraphWriter& other)
   33.60        : _os(other._os), local_os(other.local_os), _graph(other._graph),
   33.61          _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
   33.62 @@ -1556,7 +1556,7 @@
   33.63    ///
   33.64    /// \brief Return a \ref GraphWriter class
   33.65    ///
   33.66 -  /// This function just returns a \ref GraphWriter class. 
   33.67 +  /// This function just returns a \ref GraphWriter class.
   33.68    ///
   33.69    /// With this function a graph can be write to a file or output
   33.70    /// stream in \ref lgf-format "LGF" format with several maps and
    34.1 --- a/lemon/lp.h	Fri Aug 05 09:33:42 2011 +0200
    34.2 +++ b/lemon/lp.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    34.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   34.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   34.11   *
   34.12 @@ -84,7 +84,7 @@
   34.13    typedef SoplexLp Lp;
   34.14  #elif LEMON_HAVE_CLP
   34.15  # define DEFAULT_LP CLP
   34.16 -  typedef ClpLp Lp;  
   34.17 +  typedef ClpLp Lp;
   34.18  #endif
   34.19  #endif
   34.20  
    35.1 --- a/lemon/lp_base.cc	Fri Aug 05 09:33:42 2011 +0200
    35.2 +++ b/lemon/lp_base.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    35.8 + * Copyright (C) 2003-2011
    35.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   35.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   35.11   *
    36.1 --- a/lemon/lp_base.h	Fri Aug 05 09:33:42 2011 +0200
    36.2 +++ b/lemon/lp_base.h	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    36.8 + * Copyright (C) 2003-2011
    36.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   36.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   36.11   *
   36.12 @@ -82,7 +82,7 @@
   36.13        /// Verbose output.
   36.14        MESSAGE_VERBOSE
   36.15      };
   36.16 -    
   36.17 +
   36.18  
   36.19      ///The floating point type used by the solver
   36.20      typedef double Value;
   36.21 @@ -114,14 +114,14 @@
   36.22        typedef Value ExprValue;
   36.23        typedef True LpCol;
   36.24        /// Default constructor
   36.25 -      
   36.26 +
   36.27        /// \warning The default constructor sets the Col to an
   36.28        /// undefined value.
   36.29        Col() {}
   36.30        /// Invalid constructor \& conversion.
   36.31 -      
   36.32 +
   36.33        /// This constructor initializes the Col to be invalid.
   36.34 -      /// \sa Invalid for more details.      
   36.35 +      /// \sa Invalid for more details.
   36.36        Col(const Invalid&) : _id(-1) {}
   36.37        /// Equality operator
   36.38  
   36.39 @@ -156,12 +156,12 @@
   36.40        const LpBase *_solver;
   36.41      public:
   36.42        /// Default constructor
   36.43 -      
   36.44 +
   36.45        /// \warning The default constructor sets the iterator
   36.46        /// to an undefined value.
   36.47        ColIt() {}
   36.48        /// Sets the iterator to the first Col
   36.49 -      
   36.50 +
   36.51        /// Sets the iterator to the first Col.
   36.52        ///
   36.53        ColIt(const LpBase &solver) : _solver(&solver)
   36.54 @@ -169,12 +169,12 @@
   36.55          _solver->cols.firstItem(_id);
   36.56        }
   36.57        /// Invalid constructor \& conversion
   36.58 -      
   36.59 +
   36.60        /// Initialize the iterator to be invalid.
   36.61        /// \sa Invalid for more details.
   36.62        ColIt(const Invalid&) : Col(INVALID) {}
   36.63        /// Next column
   36.64 -      
   36.65 +
   36.66        /// Assign the iterator to the next column.
   36.67        ///
   36.68        ColIt &operator++()
   36.69 @@ -209,14 +209,14 @@
   36.70        typedef Value ExprValue;
   36.71        typedef True LpRow;
   36.72        /// Default constructor
   36.73 -      
   36.74 +
   36.75        /// \warning The default constructor sets the Row to an
   36.76        /// undefined value.
   36.77        Row() {}
   36.78        /// Invalid constructor \& conversion.
   36.79 -      
   36.80 +
   36.81        /// This constructor initializes the Row to be invalid.
   36.82 -      /// \sa Invalid for more details.      
   36.83 +      /// \sa Invalid for more details.
   36.84        Row(const Invalid&) : _id(-1) {}
   36.85        /// Equality operator
   36.86  
   36.87 @@ -224,7 +224,7 @@
   36.88        /// the same LP row or both are invalid.
   36.89        bool operator==(Row r) const  {return _id == r._id;}
   36.90        /// Inequality operator
   36.91 -      
   36.92 +
   36.93        /// \sa operator==(Row r)
   36.94        ///
   36.95        bool operator!=(Row r) const  {return _id != r._id;}
   36.96 @@ -251,12 +251,12 @@
   36.97        const LpBase *_solver;
   36.98      public:
   36.99        /// Default constructor
  36.100 -      
  36.101 +
  36.102        /// \warning The default constructor sets the iterator
  36.103        /// to an undefined value.
  36.104        RowIt() {}
  36.105        /// Sets the iterator to the first Row
  36.106 -      
  36.107 +
  36.108        /// Sets the iterator to the first Row.
  36.109        ///
  36.110        RowIt(const LpBase &solver) : _solver(&solver)
  36.111 @@ -264,12 +264,12 @@
  36.112          _solver->rows.firstItem(_id);
  36.113        }
  36.114        /// Invalid constructor \& conversion
  36.115 -      
  36.116 +
  36.117        /// Initialize the iterator to be invalid.
  36.118        /// \sa Invalid for more details.
  36.119        RowIt(const Invalid&) : Row(INVALID) {}
  36.120        /// Next row
  36.121 -      
  36.122 +
  36.123        /// Assign the iterator to the next row.
  36.124        ///
  36.125        RowIt &operator++()
  36.126 @@ -347,7 +347,7 @@
  36.127      public:
  36.128        typedef True SolverExpr;
  36.129        /// Default constructor
  36.130 -      
  36.131 +
  36.132        /// Construct an empty expression, the coefficients and
  36.133        /// the constant component are initialized to zero.
  36.134        Expr() : const_comp(0) {}
  36.135 @@ -448,9 +448,9 @@
  36.136        }
  36.137  
  36.138        ///Iterator over the expression
  36.139 -      
  36.140 -      ///The iterator iterates over the terms of the expression. 
  36.141 -      /// 
  36.142 +
  36.143 +      ///The iterator iterates over the terms of the expression.
  36.144 +      ///
  36.145        ///\code
  36.146        ///double s=0;
  36.147        ///for(LpBase::Expr::CoeffIt i(e);i!=INVALID;++i)
  36.148 @@ -464,7 +464,7 @@
  36.149        public:
  36.150  
  36.151          /// Sets the iterator to the first term
  36.152 -        
  36.153 +
  36.154          /// Sets the iterator to the first term of the expression.
  36.155          ///
  36.156          CoeffIt(Expr& e)
  36.157 @@ -481,7 +481,7 @@
  36.158          /// Returns the coefficient of the term
  36.159          const Value& operator*() const { return _it->second; }
  36.160          /// Next term
  36.161 -        
  36.162 +
  36.163          /// Assign the iterator to the next term.
  36.164          ///
  36.165          CoeffIt& operator++() { ++_it; return *this; }
  36.166 @@ -493,9 +493,9 @@
  36.167        };
  36.168  
  36.169        /// Const iterator over the expression
  36.170 -      
  36.171 -      ///The iterator iterates over the terms of the expression. 
  36.172 -      /// 
  36.173 +
  36.174 +      ///The iterator iterates over the terms of the expression.
  36.175 +      ///
  36.176        ///\code
  36.177        ///double s=0;
  36.178        ///for(LpBase::Expr::ConstCoeffIt i(e);i!=INVALID;++i)
  36.179 @@ -509,7 +509,7 @@
  36.180        public:
  36.181  
  36.182          /// Sets the iterator to the first term
  36.183 -        
  36.184 +
  36.185          /// Sets the iterator to the first term of the expression.
  36.186          ///
  36.187          ConstCoeffIt(const Expr& e)
  36.188 @@ -524,7 +524,7 @@
  36.189          const Value& operator*() const { return _it->second; }
  36.190  
  36.191          /// Next term
  36.192 -        
  36.193 +
  36.194          /// Assign the iterator to the next term.
  36.195          ///
  36.196          ConstCoeffIt& operator++() { ++_it; return *this; }
  36.197 @@ -673,7 +673,7 @@
  36.198      public:
  36.199        typedef True SolverExpr;
  36.200        /// Default constructor
  36.201 -      
  36.202 +
  36.203        /// Construct an empty expression, the coefficients are
  36.204        /// initialized to zero.
  36.205        DualExpr() {}
  36.206 @@ -708,7 +708,7 @@
  36.207          }
  36.208        }
  36.209        /// \brief Removes the coefficients which's absolute value does
  36.210 -      /// not exceed \c epsilon. 
  36.211 +      /// not exceed \c epsilon.
  36.212        void simplify(Value epsilon = 0.0) {
  36.213          std::map<int, Value>::iterator it=comps.begin();
  36.214          while (it != comps.end()) {
  36.215 @@ -757,9 +757,9 @@
  36.216        }
  36.217  
  36.218        ///Iterator over the expression
  36.219 -      
  36.220 -      ///The iterator iterates over the terms of the expression. 
  36.221 -      /// 
  36.222 +
  36.223 +      ///The iterator iterates over the terms of the expression.
  36.224 +      ///
  36.225        ///\code
  36.226        ///double s=0;
  36.227        ///for(LpBase::DualExpr::CoeffIt i(e);i!=INVALID;++i)
  36.228 @@ -773,7 +773,7 @@
  36.229        public:
  36.230  
  36.231          /// Sets the iterator to the first term
  36.232 -        
  36.233 +
  36.234          /// Sets the iterator to the first term of the expression.
  36.235          ///
  36.236          CoeffIt(DualExpr& e)
  36.237 @@ -791,7 +791,7 @@
  36.238          const Value& operator*() const { return _it->second; }
  36.239  
  36.240          /// Next term
  36.241 -        
  36.242 +
  36.243          /// Assign the iterator to the next term.
  36.244          ///
  36.245          CoeffIt& operator++() { ++_it; return *this; }
  36.246 @@ -803,9 +803,9 @@
  36.247        };
  36.248  
  36.249        ///Iterator over the expression
  36.250 -      
  36.251 -      ///The iterator iterates over the terms of the expression. 
  36.252 -      /// 
  36.253 +
  36.254 +      ///The iterator iterates over the terms of the expression.
  36.255 +      ///
  36.256        ///\code
  36.257        ///double s=0;
  36.258        ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)
  36.259 @@ -819,7 +819,7 @@
  36.260        public:
  36.261  
  36.262          /// Sets the iterator to the first term
  36.263 -        
  36.264 +
  36.265          /// Sets the iterator to the first term of the expression.
  36.266          ///
  36.267          ConstCoeffIt(const DualExpr& e)
  36.268 @@ -834,7 +834,7 @@
  36.269          const Value& operator*() const { return _it->second; }
  36.270  
  36.271          /// Next term
  36.272 -        
  36.273 +
  36.274          /// Assign the iterator to the next term.
  36.275          ///
  36.276          ConstCoeffIt& operator++() { ++_it; return *this; }
  36.277 @@ -1803,10 +1803,10 @@
  36.278      ///The basis status of variables
  36.279      enum VarStatus {
  36.280        /// The variable is in the basis
  36.281 -      BASIC, 
  36.282 +      BASIC,
  36.283        /// The variable is free, but not basic
  36.284        FREE,
  36.285 -      /// The variable has active lower bound 
  36.286 +      /// The variable has active lower bound
  36.287        LOWER,
  36.288        /// The variable has active upper bound
  36.289        UPPER,
  36.290 @@ -1885,7 +1885,7 @@
  36.291        return res;
  36.292      }
  36.293      /// Returns a component of the primal ray
  36.294 -    
  36.295 +
  36.296      /// The primal ray is solution of the modified primal problem,
  36.297      /// where we change each finite bound to 0, and we looking for a
  36.298      /// negative objective value in case of minimization, and positive
  36.299 @@ -1919,7 +1919,7 @@
  36.300      }
  36.301  
  36.302      /// Returns a component of the dual ray
  36.303 -    
  36.304 +
  36.305      /// The dual ray is solution of the modified primal problem, where
  36.306      /// we change each finite bound to 0 (i.e. the objective function
  36.307      /// coefficients in the primal problem), and we looking for a
  36.308 @@ -2061,7 +2061,7 @@
  36.309        return res;
  36.310      }
  36.311      ///The value of the objective function
  36.312 -    
  36.313 +
  36.314      ///\return
  36.315      ///- \ref INF or -\ref INF means either infeasibility or unboundedness
  36.316      /// of the problem, depending on whether we minimize or maximize.
    37.1 --- a/lemon/lp_skeleton.cc	Fri Aug 05 09:33:42 2011 +0200
    37.2 +++ b/lemon/lp_skeleton.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    37.8 + * Copyright (C) 2003-2011
    37.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   37.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   37.11   *
    38.1 --- a/lemon/lp_skeleton.h	Fri Aug 05 09:33:42 2011 +0200
    38.2 +++ b/lemon/lp_skeleton.h	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    38.8 + * Copyright (C) 2003-2011
    38.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   38.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   38.11   *
   38.12 @@ -23,13 +23,13 @@
   38.13  
   38.14  ///\file
   38.15  ///\brief Skeleton file to implement LP/MIP solver interfaces
   38.16 -///  
   38.17 +///
   38.18  ///The classes in this file do nothing, but they can serve as skeletons when
   38.19  ///implementing an interface to new solvers.
   38.20  namespace lemon {
   38.21  
   38.22    ///A skeleton class to implement LP/MIP solver base interface
   38.23 -  
   38.24 +
   38.25    ///This class does nothing, but it can serve as a skeleton when
   38.26    ///implementing an interface to new solvers.
   38.27    class SkeletonSolverBase : public virtual LpBase {
    39.1 --- a/lemon/maps.h	Fri Aug 05 09:33:42 2011 +0200
    39.2 +++ b/lemon/maps.h	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    39.8 + * Copyright (C) 2003-2011
    39.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   39.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   39.11   *
   39.12 @@ -1818,7 +1818,7 @@
   39.13    /// \brief Provides an immutable and unique id for each item in a graph.
   39.14    ///
   39.15    /// IdMap provides a unique and immutable id for each item of the
   39.16 -  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 
   39.17 +  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
   39.18    ///  - \b unique: different items get different ids,
   39.19    ///  - \b immutable: the id of an item does not change (even if you
   39.20    ///    delete other nodes).
   39.21 @@ -2273,7 +2273,7 @@
   39.22      }
   39.23  
   39.24      /// \brief Gives back the item belonging to a \e RangeId
   39.25 -    /// 
   39.26 +    ///
   39.27      /// Gives back the item belonging to a \e RangeId.
   39.28      Item operator()(int id) const {
   39.29        return _inv_map[id];
   39.30 @@ -2499,7 +2499,7 @@
   39.31    /// in constant time. On the other hand, the values are updated automatically
   39.32    /// whenever the digraph changes.
   39.33    ///
   39.34 -  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   39.35 +  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
   39.36    /// may provide alternative ways to modify the digraph.
   39.37    /// The correct behavior of InDegMap is not guarantied if these additional
   39.38    /// features are used. For example the functions
   39.39 @@ -2515,7 +2515,7 @@
   39.40        ::ItemNotifier::ObserverBase {
   39.41  
   39.42    public:
   39.43 -    
   39.44 +
   39.45      /// The graph type of InDegMap
   39.46      typedef GR Graph;
   39.47      typedef GR Digraph;
   39.48 @@ -2629,7 +2629,7 @@
   39.49    /// in constant time. On the other hand, the values are updated automatically
   39.50    /// whenever the digraph changes.
   39.51    ///
   39.52 -  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   39.53 +  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
   39.54    /// may provide alternative ways to modify the digraph.
   39.55    /// The correct behavior of OutDegMap is not guarantied if these additional
   39.56    /// features are used. For example the functions
    40.1 --- a/lemon/matching.h	Fri Aug 05 09:33:42 2011 +0200
    40.2 +++ b/lemon/matching.h	Mon Aug 08 12:36:16 2011 +0200
    40.3 @@ -2,7 +2,7 @@
    40.4   *
    40.5   * This file is a part of LEMON, a generic C++ optimization library.
    40.6   *
    40.7 - * Copyright (C) 2003-2009
    40.8 + * Copyright (C) 2003-2011
    40.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   40.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   40.11   *
   40.12 @@ -41,7 +41,7 @@
   40.13    ///
   40.14    /// This class implements Edmonds' alternating forest matching algorithm
   40.15    /// for finding a maximum cardinality matching in a general undirected graph.
   40.16 -  /// It can be started from an arbitrary initial matching 
   40.17 +  /// It can be started from an arbitrary initial matching
   40.18    /// (the default is the empty one).
   40.19    ///
   40.20    /// The dual solution of the problem is a map of the nodes to
   40.21 @@ -69,11 +69,11 @@
   40.22  
   40.23      ///\brief Status constants for Gallai-Edmonds decomposition.
   40.24      ///
   40.25 -    ///These constants are used for indicating the Gallai-Edmonds 
   40.26 +    ///These constants are used for indicating the Gallai-Edmonds
   40.27      ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
   40.28      ///induce a subgraph with factor-critical components, the nodes with
   40.29      ///status \c ODD (or \c A) form the canonical barrier, and the nodes
   40.30 -    ///with status \c MATCHED (or \c C) induce a subgraph having a 
   40.31 +    ///with status \c MATCHED (or \c C) induce a subgraph having a
   40.32      ///perfect matching.
   40.33      enum Status {
   40.34        EVEN = 1,       ///< = 1. (\c D is an alias for \c EVEN.)
   40.35 @@ -512,7 +512,7 @@
   40.36        }
   40.37      }
   40.38  
   40.39 -    /// \brief Start Edmonds' algorithm with a heuristic improvement 
   40.40 +    /// \brief Start Edmonds' algorithm with a heuristic improvement
   40.41      /// for dense graphs
   40.42      ///
   40.43      /// This function runs Edmonds' algorithm with a heuristic of postponing
   40.44 @@ -534,8 +534,8 @@
   40.45  
   40.46      /// \brief Run Edmonds' algorithm
   40.47      ///
   40.48 -    /// This function runs Edmonds' algorithm. An additional heuristic of 
   40.49 -    /// postponing shrinks is used for relatively dense graphs 
   40.50 +    /// This function runs Edmonds' algorithm. An additional heuristic of
   40.51 +    /// postponing shrinks is used for relatively dense graphs
   40.52      /// (for which <tt>m>=2*n</tt> holds).
   40.53      void run() {
   40.54        if (countEdges(_graph) < 2 * countNodes(_graph)) {
   40.55 @@ -556,7 +556,7 @@
   40.56  
   40.57      /// \brief Return the size (cardinality) of the matching.
   40.58      ///
   40.59 -    /// This function returns the size (cardinality) of the current matching. 
   40.60 +    /// This function returns the size (cardinality) of the current matching.
   40.61      /// After run() it returns the size of the maximum matching in the graph.
   40.62      int matchingSize() const {
   40.63        int size = 0;
   40.64 @@ -570,7 +570,7 @@
   40.65  
   40.66      /// \brief Return \c true if the given edge is in the matching.
   40.67      ///
   40.68 -    /// This function returns \c true if the given edge is in the current 
   40.69 +    /// This function returns \c true if the given edge is in the current
   40.70      /// matching.
   40.71      bool matching(const Edge& edge) const {
   40.72        return edge == (*_matching)[_graph.u(edge)];
   40.73 @@ -579,7 +579,7 @@
   40.74      /// \brief Return the matching arc (or edge) incident to the given node.
   40.75      ///
   40.76      /// This function returns the matching arc (or edge) incident to the
   40.77 -    /// given node in the current matching or \c INVALID if the node is 
   40.78 +    /// given node in the current matching or \c INVALID if the node is
   40.79      /// not covered by the matching.
   40.80      Arc matching(const Node& n) const {
   40.81        return (*_matching)[n];
   40.82 @@ -595,7 +595,7 @@
   40.83  
   40.84      /// \brief Return the mate of the given node.
   40.85      ///
   40.86 -    /// This function returns the mate of the given node in the current 
   40.87 +    /// This function returns the mate of the given node in the current
   40.88      /// matching or \c INVALID if the node is not covered by the matching.
   40.89      Node mate(const Node& n) const {
   40.90        return (*_matching)[n] != INVALID ?
   40.91 @@ -605,7 +605,7 @@
   40.92      /// @}
   40.93  
   40.94      /// \name Dual Solution
   40.95 -    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
   40.96 +    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
   40.97      /// decomposition.
   40.98  
   40.99      /// @{
  40.100 @@ -648,8 +648,8 @@
  40.101    /// on extensive use of priority queues and provides
  40.102    /// \f$O(nm\log n)\f$ time complexity.
  40.103    ///
  40.104 -  /// The maximum weighted matching problem is to find a subset of the 
  40.105 -  /// edges in an undirected graph with maximum overall weight for which 
  40.106 +  /// The maximum weighted matching problem is to find a subset of the
  40.107 +  /// edges in an undirected graph with maximum overall weight for which
  40.108    /// each node has at most one incident edge.
  40.109    /// It can be formulated with the following linear program.
  40.110    /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
  40.111 @@ -673,16 +673,16 @@
  40.112    /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}}
  40.113        \frac{\vert B \vert - 1}{2}z_B\f] */
  40.114    ///
  40.115 -  /// The algorithm can be executed with the run() function. 
  40.116 +  /// The algorithm can be executed with the run() function.
  40.117    /// After it the matching (the primal solution) and the dual solution
  40.118 -  /// can be obtained using the query functions and the 
  40.119 -  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 
  40.120 -  /// which is able to iterate on the nodes of a blossom. 
  40.121 +  /// can be obtained using the query functions and the
  40.122 +  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
  40.123 +  /// which is able to iterate on the nodes of a blossom.
  40.124    /// If the value type is integer, then the dual solution is multiplied
  40.125    /// by \ref MaxWeightedMatching::dualScale "4".
  40.126    ///
  40.127    /// \tparam GR The undirected graph type the algorithm runs on.
  40.128 -  /// \tparam WM The type edge weight map. The default type is 
  40.129 +  /// \tparam WM The type edge weight map. The default type is
  40.130    /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
  40.131  #ifdef DOXYGEN
  40.132    template <typename GR, typename WM>
  40.133 @@ -1720,7 +1720,7 @@
  40.134          (*_delta2_index)[i] = _delta2->PRE_HEAP;
  40.135          (*_delta4_index)[i] = _delta4->PRE_HEAP;
  40.136        }
  40.137 -      
  40.138 +
  40.139        _delta1->clear();
  40.140        _delta2->clear();
  40.141        _delta3->clear();
  40.142 @@ -1868,7 +1868,7 @@
  40.143      /// @}
  40.144  
  40.145      /// \name Primal Solution
  40.146 -    /// Functions to get the primal solution, i.e. the maximum weighted 
  40.147 +    /// Functions to get the primal solution, i.e. the maximum weighted
  40.148      /// matching.\n
  40.149      /// Either \ref run() or \ref start() function should be called before
  40.150      /// using them.
  40.151 @@ -1907,7 +1907,7 @@
  40.152  
  40.153      /// \brief Return \c true if the given edge is in the matching.
  40.154      ///
  40.155 -    /// This function returns \c true if the given edge is in the found 
  40.156 +    /// This function returns \c true if the given edge is in the found
  40.157      /// matching.
  40.158      ///
  40.159      /// \pre Either run() or start() must be called before using this function.
  40.160 @@ -1918,7 +1918,7 @@
  40.161      /// \brief Return the matching arc (or edge) incident to the given node.
  40.162      ///
  40.163      /// This function returns the matching arc (or edge) incident to the
  40.164 -    /// given node in the found matching or \c INVALID if the node is 
  40.165 +    /// given node in the found matching or \c INVALID if the node is
  40.166      /// not covered by the matching.
  40.167      ///
  40.168      /// \pre Either run() or start() must be called before using this function.
  40.169 @@ -1936,7 +1936,7 @@
  40.170  
  40.171      /// \brief Return the mate of the given node.
  40.172      ///
  40.173 -    /// This function returns the mate of the given node in the found 
  40.174 +    /// This function returns the mate of the given node in the found
  40.175      /// matching or \c INVALID if the node is not covered by the matching.
  40.176      ///
  40.177      /// \pre Either run() or start() must be called before using this function.
  40.178 @@ -1956,8 +1956,8 @@
  40.179  
  40.180      /// \brief Return the value of the dual solution.
  40.181      ///
  40.182 -    /// This function returns the value of the dual solution. 
  40.183 -    /// It should be equal to the primal value scaled by \ref dualScale 
  40.184 +    /// This function returns the value of the dual solution.
  40.185 +    /// It should be equal to the primal value scaled by \ref dualScale
  40.186      /// "dual scale".
  40.187      ///
  40.188      /// \pre Either run() or start() must be called before using this function.
  40.189 @@ -2012,9 +2012,9 @@
  40.190  
  40.191      /// \brief Iterator for obtaining the nodes of a blossom.
  40.192      ///
  40.193 -    /// This class provides an iterator for obtaining the nodes of the 
  40.194 +    /// This class provides an iterator for obtaining the nodes of the
  40.195      /// given blossom. It lists a subset of the nodes.
  40.196 -    /// Before using this iterator, you must allocate a 
  40.197 +    /// Before using this iterator, you must allocate a
  40.198      /// MaxWeightedMatching class and execute it.
  40.199      class BlossomIt {
  40.200      public:
  40.201 @@ -2023,8 +2023,8 @@
  40.202        ///
  40.203        /// Constructor to get the nodes of the given variable.
  40.204        ///
  40.205 -      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 
  40.206 -      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 
  40.207 +      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
  40.208 +      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
  40.209        /// called before initializing this iterator.
  40.210        BlossomIt(const MaxWeightedMatching& algorithm, int variable)
  40.211          : _algorithm(&algorithm)
  40.212 @@ -2077,8 +2077,8 @@
  40.213    /// is based on extensive use of priority queues and provides
  40.214    /// \f$O(nm\log n)\f$ time complexity.
  40.215    ///
  40.216 -  /// The maximum weighted perfect matching problem is to find a subset of 
  40.217 -  /// the edges in an undirected graph with maximum overall weight for which 
  40.218 +  /// The maximum weighted perfect matching problem is to find a subset of
  40.219 +  /// the edges in an undirected graph with maximum overall weight for which
  40.220    /// each node has exactly one incident edge.
  40.221    /// It can be formulated with the following linear program.
  40.222    /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f]
  40.223 @@ -2101,16 +2101,16 @@
  40.224    /** \f[\min \sum_{u \in V}y_u + \sum_{B \in \mathcal{O}}
  40.225        \frac{\vert B \vert - 1}{2}z_B\f] */
  40.226    ///
  40.227 -  /// The algorithm can be executed with the run() function. 
  40.228 +  /// The algorithm can be executed with the run() function.
  40.229    /// After it the matching (the primal solution) and the dual solution
  40.230 -  /// can be obtained using the query functions and the 
  40.231 -  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 
  40.232 -  /// which is able to iterate on the nodes of a blossom. 
  40.233 +  /// can be obtained using the query functions and the
  40.234 +  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
  40.235 +  /// which is able to iterate on the nodes of a blossom.
  40.236    /// If the value type is integer, then the dual solution is multiplied
  40.237    /// by \ref MaxWeightedMatching::dualScale "4".
  40.238    ///
  40.239    /// \tparam GR The undirected graph type the algorithm runs on.
  40.240 -  /// \tparam WM The type edge weight map. The default type is 
  40.241 +  /// \tparam WM The type edge weight map. The default type is
  40.242    /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
  40.243  #ifdef DOXYGEN
  40.244    template <typename GR, typename WM>
  40.245 @@ -3115,7 +3115,7 @@
  40.246      /// @}
  40.247  
  40.248      /// \name Primal Solution
  40.249 -    /// Functions to get the primal solution, i.e. the maximum weighted 
  40.250 +    /// Functions to get the primal solution, i.e. the maximum weighted
  40.251      /// perfect matching.\n
  40.252      /// Either \ref run() or \ref start() function should be called before
  40.253      /// using them.
  40.254 @@ -3139,7 +3139,7 @@
  40.255  
  40.256      /// \brief Return \c true if the given edge is in the matching.
  40.257      ///
  40.258 -    /// This function returns \c true if the given edge is in the found 
  40.259 +    /// This function returns \c true if the given edge is in the found
  40.260      /// matching.
  40.261      ///
  40.262      /// \pre Either run() or start() must be called before using this function.
  40.263 @@ -3150,7 +3150,7 @@
  40.264      /// \brief Return the matching arc (or edge) incident to the given node.
  40.265      ///
  40.266      /// This function returns the matching arc (or edge) incident to the
  40.267 -    /// given node in the found matching or \c INVALID if the node is 
  40.268 +    /// given node in the found matching or \c INVALID if the node is
  40.269      /// not covered by the matching.
  40.270      ///
  40.271      /// \pre Either run() or start() must be called before using this function.
  40.272 @@ -3168,7 +3168,7 @@
  40.273  
  40.274      /// \brief Return the mate of the given node.
  40.275      ///
  40.276 -    /// This function returns the mate of the given node in the found 
  40.277 +    /// This function returns the mate of the given node in the found
  40.278      /// matching or \c INVALID if the node is not covered by the matching.
  40.279      ///
  40.280      /// \pre Either run() or start() must be called before using this function.
  40.281 @@ -3187,8 +3187,8 @@
  40.282  
  40.283      /// \brief Return the value of the dual solution.
  40.284      ///
  40.285 -    /// This function returns the value of the dual solution. 
  40.286 -    /// It should be equal to the primal value scaled by \ref dualScale 
  40.287 +    /// This function returns the value of the dual solution.
  40.288 +    /// It should be equal to the primal value scaled by \ref dualScale
  40.289      /// "dual scale".
  40.290      ///
  40.291      /// \pre Either run() or start() must be called before using this function.
  40.292 @@ -3243,9 +3243,9 @@
  40.293  
  40.294      /// \brief Iterator for obtaining the nodes of a blossom.
  40.295      ///
  40.296 -    /// This class provides an iterator for obtaining the nodes of the 
  40.297 +    /// This class provides an iterator for obtaining the nodes of the
  40.298      /// given blossom. It lists a subset of the nodes.
  40.299 -    /// Before using this iterator, you must allocate a 
  40.300 +    /// Before using this iterator, you must allocate a
  40.301      /// MaxWeightedPerfectMatching class and execute it.
  40.302      class BlossomIt {
  40.303      public:
  40.304 @@ -3254,8 +3254,8 @@
  40.305        ///
  40.306        /// Constructor to get the nodes of the given variable.
  40.307        ///
  40.308 -      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 
  40.309 -      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 
  40.310 +      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
  40.311 +      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
  40.312        /// must be called before initializing this iterator.
  40.313        BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
  40.314          : _algorithm(&algorithm)
    41.1 --- a/lemon/math.h	Fri Aug 05 09:33:42 2011 +0200
    41.2 +++ b/lemon/math.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    41.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   41.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   41.11   *
   41.12 @@ -56,7 +56,7 @@
   41.13    const long double SQRT1_2 = 0.7071067811865475244008443621048490L;
   41.14  
   41.15    ///Check whether the parameter is NaN or not
   41.16 -  
   41.17 +
   41.18    ///This function checks whether the parameter is NaN or not.
   41.19    ///Is should be equivalent with std::isnan(), but it is not
   41.20    ///provided by all compilers.
    42.1 --- a/lemon/min_cost_arborescence.h	Fri Aug 05 09:33:42 2011 +0200
    42.2 +++ b/lemon/min_cost_arborescence.h	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    42.8 + * Copyright (C) 2003-2011
    42.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   42.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   42.11   *
   42.12 @@ -127,8 +127,8 @@
   42.13    class MinCostArborescence {
   42.14    public:
   42.15  
   42.16 -    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" 
   42.17 -    /// of the algorithm. 
   42.18 +    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
   42.19 +    /// of the algorithm.
   42.20      typedef TR Traits;
   42.21      /// The type of the underlying digraph.
   42.22      typedef typename Traits::Digraph Digraph;
   42.23 @@ -435,7 +435,7 @@
   42.24      ///
   42.25      /// \ref named-templ-param "Named parameter" for setting
   42.26      /// \c PredMap type.
   42.27 -    /// It must meet the \ref concepts::WriteMap "WriteMap" concept, 
   42.28 +    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
   42.29      /// and its value type must be the \c Arc type of the digraph.
   42.30      template <class T>
   42.31      struct SetPredMap
    43.1 --- a/lemon/network_simplex.h	Fri Aug 05 09:33:42 2011 +0200
    43.2 +++ b/lemon/network_simplex.h	Mon Aug 08 12:36:16 2011 +0200
    43.3 @@ -2,7 +2,7 @@
    43.4   *
    43.5   * This file is a part of LEMON, a generic C++ optimization library.
    43.6   *
    43.7 - * Copyright (C) 2003-2009
    43.8 + * Copyright (C) 2003-2011
    43.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   43.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   43.11   *
   43.12 @@ -95,7 +95,7 @@
   43.13        /// infinite upper bound.
   43.14        UNBOUNDED
   43.15      };
   43.16 -    
   43.17 +
   43.18      /// \brief Constants for selecting the type of the supply constraints.
   43.19      ///
   43.20      /// Enum type containing constants for selecting the supply type,
   43.21 @@ -113,7 +113,7 @@
   43.22        /// supply/demand constraints in the definition of the problem.
   43.23        LEQ
   43.24      };
   43.25 -    
   43.26 +
   43.27      /// \brief Constants for selecting the pivot rule.
   43.28      ///
   43.29      /// Enum type containing constants for selecting the pivot rule for
   43.30 @@ -156,7 +156,7 @@
   43.31        /// candidate list and extends this list in every iteration.
   43.32        ALTERING_LIST
   43.33      };
   43.34 -    
   43.35 +
   43.36    private:
   43.37  
   43.38      TEMPLATE_DIGRAPH_TYPEDEFS(GR);
   43.39 @@ -223,7 +223,7 @@
   43.40      Value delta;
   43.41  
   43.42    public:
   43.43 -  
   43.44 +
   43.45      /// \brief Constant for infinite upper bounds (capacities).
   43.46      ///
   43.47      /// Constant for infinite upper bounds (capacities).
   43.48 @@ -644,7 +644,7 @@
   43.49          "The flow type of NetworkSimplex must be signed");
   43.50        LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
   43.51          "The cost type of NetworkSimplex must be signed");
   43.52 -        
   43.53 +
   43.54        // Resize vectors
   43.55        _node_num = countNodes(_graph);
   43.56        _arc_num = countArcs(_graph);
   43.57 @@ -684,7 +684,7 @@
   43.58          _target[i] = _node_id[_graph.target(a)];
   43.59          if ((i += k) >= _arc_num) i = (i % k) + 1;
   43.60        }
   43.61 -      
   43.62 +
   43.63        // Initialize maps
   43.64        for (int i = 0; i != _node_num; ++i) {
   43.65          _supply[i] = 0;
   43.66 @@ -809,7 +809,7 @@
   43.67        _supply[_node_id[t]] = -k;
   43.68        return *this;
   43.69      }
   43.70 -    
   43.71 +
   43.72      /// \brief Set the type of the supply constraints.
   43.73      ///
   43.74      /// This function sets the type of the supply/demand constraints.
   43.75 @@ -835,7 +835,7 @@
   43.76      ///
   43.77      /// This function runs the algorithm.
   43.78      /// The paramters can be specified using functions \ref lowerMap(),
   43.79 -    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), 
   43.80 +    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
   43.81      /// \ref supplyType().
   43.82      /// For example,
   43.83      /// \code
   43.84 @@ -1054,7 +1054,7 @@
   43.85          _flow[i] = 0;
   43.86          _state[i] = STATE_LOWER;
   43.87        }
   43.88 -      
   43.89 +
   43.90        // Set data for the artificial root node
   43.91        _root = _node_num;
   43.92        _parent[_root] = -1;
   43.93 @@ -1228,7 +1228,7 @@
   43.94        // Search the cycle along the path form the second node to the root
   43.95        for (int u = second; u != join; u = _parent[u]) {
   43.96          e = _pred[u];
   43.97 -        d = _forward[u] ? 
   43.98 +        d = _forward[u] ?
   43.99            (_cap[e] == INF ? INF : _cap[e] - _flow[e]) : _flow[e];
  43.100          if (d <= delta) {
  43.101            delta = d;
  43.102 @@ -1435,7 +1435,7 @@
  43.103            updatePotential();
  43.104          }
  43.105        }
  43.106 -      
  43.107 +
  43.108        // Check feasibility
  43.109        for (int e = _search_arc_num; e != _all_arc_num; ++e) {
  43.110          if (_flow[e] != 0) return INFEASIBLE;
  43.111 @@ -1452,7 +1452,7 @@
  43.112            }
  43.113          }
  43.114        }
  43.115 -      
  43.116 +
  43.117        // Shift potentials to meet the requirements of the GEQ/LEQ type
  43.118        // optimality conditions
  43.119        if (_sum_supply == 0) {
    44.1 --- a/lemon/path.h	Fri Aug 05 09:33:42 2011 +0200
    44.2 +++ b/lemon/path.h	Mon Aug 08 12:36:16 2011 +0200
    44.3 @@ -2,7 +2,7 @@
    44.4   *
    44.5   * This file is a part of LEMON, a generic C++ optimization library.
    44.6   *
    44.7 - * Copyright (C) 2003-2009
    44.8 + * Copyright (C) 2003-2011
    44.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   44.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   44.11   *
   44.12 @@ -966,20 +966,20 @@
   44.13        }
   44.14      };
   44.15  
   44.16 -    
   44.17 +
   44.18      template <typename From, typename To,
   44.19                bool revEnable = RevPathTagIndicator<From>::value>
   44.20      struct PathCopySelector {
   44.21        static void copy(const From& from, To& to) {
   44.22          PathCopySelectorForward<From, To>::copy(from, to);
   44.23 -      }      
   44.24 +      }
   44.25      };
   44.26  
   44.27      template <typename From, typename To>
   44.28      struct PathCopySelector<From, To, true> {
   44.29        static void copy(const From& from, To& to) {
   44.30          PathCopySelectorBackward<From, To>::copy(from, to);
   44.31 -      }      
   44.32 +      }
   44.33      };
   44.34  
   44.35    }
    45.1 --- a/lemon/preflow.h	Fri Aug 05 09:33:42 2011 +0200
    45.2 +++ b/lemon/preflow.h	Mon Aug 08 12:36:16 2011 +0200
    45.3 @@ -2,7 +2,7 @@
    45.4   *
    45.5   * This file is a part of LEMON, a generic C++ optimization library.
    45.6   *
    45.7 - * Copyright (C) 2003-2009
    45.8 + * Copyright (C) 2003-2011
    45.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   45.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   45.11   *
   45.12 @@ -536,10 +536,10 @@
   45.13            (*_excess)[v] += rem;
   45.14          }
   45.15        }
   45.16 -      for (NodeIt n(_graph); n != INVALID; ++n) 
   45.17 +      for (NodeIt n(_graph); n != INVALID; ++n)
   45.18          if(n!=_source && n!=_target && _tolerance.positive((*_excess)[n]))
   45.19            _level->activate(n);
   45.20 -          
   45.21 +
   45.22        return true;
   45.23      }
   45.24  
   45.25 @@ -567,7 +567,7 @@
   45.26            if (n == INVALID) goto first_phase_done;
   45.27            level = _level->highestActiveLevel();
   45.28            --num;
   45.29 -          
   45.30 +
   45.31            Value excess = (*_excess)[n];
   45.32            int new_level = _level->maxLevel();
   45.33  
    46.1 --- a/lemon/soplex.cc	Fri Aug 05 09:33:42 2011 +0200
    46.2 +++ b/lemon/soplex.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    46.8 + * Copyright (C) 2003-2011
    46.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   46.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   46.11   *
   46.12 @@ -274,7 +274,7 @@
   46.13    SoplexLp::SolveExitStatus SoplexLp::_solve() {
   46.14  
   46.15      _clear_temporals();
   46.16 -    
   46.17 +
   46.18      _applyMessageLevel();
   46.19  
   46.20      soplex::SPxSolver::Status status = soplex->solve();
    47.1 --- a/lemon/soplex.h	Fri Aug 05 09:33:42 2011 +0200
    47.2 +++ b/lemon/soplex.h	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    47.8 + * Copyright (C) 2003-2011
    47.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   47.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   47.11   *
    48.1 --- a/lemon/suurballe.h	Fri Aug 05 09:33:42 2011 +0200
    48.2 +++ b/lemon/suurballe.h	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    48.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   48.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   48.11   *
    49.1 --- a/lemon/unionfind.h	Fri Aug 05 09:33:42 2011 +0200
    49.2 +++ b/lemon/unionfind.h	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    49.8 + * Copyright (C) 2003-2011
    49.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   49.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   49.11   *
    50.1 --- a/test/bfs_test.cc	Fri Aug 05 09:33:42 2011 +0200
    50.2 +++ b/test/bfs_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    50.8 + * Copyright (C) 2003-2011
    50.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   50.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   50.11   *
   50.12 @@ -83,7 +83,7 @@
   50.13      n = const_bfs_test.nextNode();
   50.14      b = const_bfs_test.emptyQueue();
   50.15      i = const_bfs_test.queueSize();
   50.16 -    
   50.17 +
   50.18      bfs_test.start();
   50.19      bfs_test.start(t);
   50.20      bfs_test.start(nm);
   50.21 @@ -104,12 +104,12 @@
   50.22        ::SetStandardProcessedMap
   50.23        ::SetProcessedMap<concepts::WriteMap<Node,bool> >
   50.24        ::Create bfs_test(G);
   50.25 -      
   50.26 +
   50.27      concepts::ReadWriteMap<Node,Arc> pred_map;
   50.28      concepts::ReadWriteMap<Node,int> dist_map;
   50.29      concepts::ReadWriteMap<Node,bool> reached_map;
   50.30      concepts::WriteMap<Node,bool> processed_map;
   50.31 -    
   50.32 +
   50.33      bfs_test
   50.34        .predMap(pred_map)
   50.35        .distMap(dist_map)
   50.36 @@ -119,7 +119,7 @@
   50.37      bfs_test.run(s);
   50.38      bfs_test.run(s,t);
   50.39      bfs_test.run();
   50.40 -    
   50.41 +
   50.42      bfs_test.init();
   50.43      bfs_test.addSource(s);
   50.44      n = bfs_test.processNextNode();
   50.45 @@ -128,7 +128,7 @@
   50.46      n = bfs_test.nextNode();
   50.47      b = bfs_test.emptyQueue();
   50.48      i = bfs_test.queueSize();
   50.49 -    
   50.50 +
   50.51      bfs_test.start();
   50.52      bfs_test.start(t);
   50.53      bfs_test.start(nm);
    51.1 --- a/test/circulation_test.cc	Fri Aug 05 09:33:42 2011 +0200
    51.2 +++ b/test/circulation_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    51.8 + * Copyright (C) 2003-2011
    51.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   51.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   51.11   *
   51.12 @@ -81,7 +81,7 @@
   51.13              ::Create CirculationType;
   51.14    CirculationType circ_test(g, lcap, ucap, supply);
   51.15    const CirculationType& const_circ_test = circ_test;
   51.16 -   
   51.17 +
   51.18    circ_test
   51.19      .lowerMap(lcap)
   51.20      .upperMap(ucap)
   51.21 @@ -97,7 +97,7 @@
   51.22    const FlowMap& fm = const_circ_test.flowMap();
   51.23    b = const_circ_test.barrier(n);
   51.24    const_circ_test.barrierMap(bar);
   51.25 -  
   51.26 +
   51.27    ignore_unused_variable_warning(fm);
   51.28  }
   51.29  
    52.1 --- a/test/connectivity_test.cc	Fri Aug 05 09:33:42 2011 +0200
    52.2 +++ b/test/connectivity_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    52.8 + * Copyright (C) 2003-2011
    52.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   52.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   52.11   *
   52.12 @@ -29,12 +29,12 @@
   52.13  {
   52.14    typedef ListDigraph Digraph;
   52.15    typedef Undirector<Digraph> Graph;
   52.16 -  
   52.17 +
   52.18    {
   52.19      Digraph d;
   52.20      Digraph::NodeMap<int> order(d);
   52.21      Graph g(d);
   52.22 -    
   52.23 +
   52.24      check(stronglyConnected(d), "The empty digraph is strongly connected");
   52.25      check(countStronglyConnectedComponents(d) == 0,
   52.26            "The empty digraph has 0 strongly connected component");
   52.27 @@ -48,7 +48,7 @@
   52.28      check(biEdgeConnected(g), "The empty graph is bi-edge-connected");
   52.29      check(countBiEdgeConnectedComponents(g) == 0,
   52.30            "The empty graph has 0 bi-edge-connected component");
   52.31 -          
   52.32 +
   52.33      check(dag(d), "The empty digraph is DAG.");
   52.34      check(checkedTopologicalSort(d, order), "The empty digraph is DAG.");
   52.35      check(loopFree(d), "The empty digraph is loop-free.");
   52.36 @@ -82,7 +82,7 @@
   52.37      check(biEdgeConnected(g), "This graph is bi-edge-connected");
   52.38      check(countBiEdgeConnectedComponents(g) == 1,
   52.39            "This graph has 1 bi-edge-connected component");
   52.40 -          
   52.41 +
   52.42      check(dag(d), "This digraph is DAG.");
   52.43      check(checkedTopologicalSort(d, order), "This digraph is DAG.");
   52.44      check(loopFree(d), "This digraph is loop-free.");
   52.45 @@ -101,14 +101,14 @@
   52.46      Digraph d;
   52.47      Digraph::NodeMap<int> order(d);
   52.48      Graph g(d);
   52.49 -    
   52.50 +
   52.51      Digraph::Node n1 = d.addNode();
   52.52      Digraph::Node n2 = d.addNode();
   52.53      Digraph::Node n3 = d.addNode();
   52.54      Digraph::Node n4 = d.addNode();
   52.55      Digraph::Node n5 = d.addNode();
   52.56      Digraph::Node n6 = d.addNode();
   52.57 -    
   52.58 +
   52.59      d.addArc(n1, n3);
   52.60      d.addArc(n3, n2);
   52.61      d.addArc(n2, n1);
   52.62 @@ -136,23 +136,23 @@
   52.63      check(loopFree(g), "This graph is loop-free.");
   52.64      check(!parallelFree(g), "This graph is not parallel-free.");
   52.65      check(!simpleGraph(g), "This graph is not simple.");
   52.66 -    
   52.67 +
   52.68      d.addArc(n3, n3);
   52.69 -    
   52.70 +
   52.71      check(!loopFree(d), "This digraph is not loop-free.");
   52.72      check(!loopFree(g), "This graph is not loop-free.");
   52.73      check(!simpleGraph(d), "This digraph is not simple.");
   52.74 -    
   52.75 +
   52.76      d.addArc(n3, n2);
   52.77 -    
   52.78 +
   52.79      check(!parallelFree(d), "This digraph is not parallel-free.");
   52.80    }
   52.81 -  
   52.82 +
   52.83    {
   52.84      Digraph d;
   52.85      Digraph::ArcMap<bool> cutarcs(d, false);
   52.86      Graph g(d);
   52.87 -    
   52.88 +
   52.89      Digraph::Node n1 = d.addNode();
   52.90      Digraph::Node n2 = d.addNode();
   52.91      Digraph::Node n3 = d.addNode();
   52.92 @@ -172,7 +172,7 @@
   52.93      d.addArc(n1, n8);
   52.94      d.addArc(n6, n7);
   52.95      d.addArc(n7, n6);
   52.96 -   
   52.97 +
   52.98      check(!stronglyConnected(d), "This digraph is not strongly connected");
   52.99      check(countStronglyConnectedComponents(d) == 3,
  52.100            "This digraph has 3 strongly connected components");
  52.101 @@ -235,7 +235,7 @@
  52.102      // (T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein)
  52.103      Digraph d;
  52.104      Digraph::NodeMap<int> order(d);
  52.105 -    
  52.106 +
  52.107      Digraph::Node belt = d.addNode();
  52.108      Digraph::Node trousers = d.addNode();
  52.109      Digraph::Node necktie = d.addNode();
  52.110 @@ -255,7 +255,7 @@
  52.111      d.addArc(shirt, belt);
  52.112      d.addArc(shirt, necktie);
  52.113      d.addArc(necktie, coat);
  52.114 -    
  52.115 +
  52.116      check(dag(d), "This digraph is DAG.");
  52.117      topologicalSort(d, order);
  52.118      for (Digraph::ArcIt a(d); a != INVALID; ++a) {
  52.119 @@ -267,7 +267,7 @@
  52.120    {
  52.121      ListGraph g;
  52.122      ListGraph::NodeMap<bool> map(g);
  52.123 -    
  52.124 +
  52.125      ListGraph::Node n1 = g.addNode();
  52.126      ListGraph::Node n2 = g.addNode();
  52.127      ListGraph::Node n3 = g.addNode();
  52.128 @@ -283,10 +283,10 @@
  52.129      g.addEdge(n4, n6);
  52.130      g.addEdge(n4, n7);
  52.131      g.addEdge(n5, n7);
  52.132 -   
  52.133 +
  52.134      check(bipartite(g), "This graph is bipartite");
  52.135      check(bipartitePartitions(g, map), "This graph is bipartite");
  52.136 -    
  52.137 +
  52.138      check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7],
  52.139            "Wrong bipartitePartitions()");
  52.140      check(map[n3] == map[n4] && map[n3] == map[n5],
    53.1 --- a/test/dfs_test.cc	Fri Aug 05 09:33:42 2011 +0200
    53.2 +++ b/test/dfs_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    53.8 + * Copyright (C) 2003-2011
    53.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   53.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   53.11   *
   53.12 @@ -86,7 +86,7 @@
   53.13      e = const_dfs_test.nextArc();
   53.14      b = const_dfs_test.emptyQueue();
   53.15      i = const_dfs_test.queueSize();
   53.16 -    
   53.17 +
   53.18      dfs_test.start();
   53.19      dfs_test.start(t);
   53.20      dfs_test.start(am);
   53.21 @@ -112,7 +112,7 @@
   53.22      concepts::ReadWriteMap<Node,int> dist_map;
   53.23      concepts::ReadWriteMap<Node,bool> reached_map;
   53.24      concepts::WriteMap<Node,bool> processed_map;
   53.25 -    
   53.26 +
   53.27      dfs_test
   53.28        .predMap(pred_map)
   53.29        .distMap(dist_map)
   53.30 @@ -129,7 +129,7 @@
   53.31      e = dfs_test.nextArc();
   53.32      b = dfs_test.emptyQueue();
   53.33      i = dfs_test.queueSize();
   53.34 -    
   53.35 +
   53.36      dfs_test.start();
   53.37      dfs_test.start(t);
   53.38      dfs_test.start(am);
   53.39 @@ -219,7 +219,7 @@
   53.40    Dfs<Digraph> dfs(G);
   53.41    check(dfs.run(s1,t1) && dfs.reached(t1),"Node 3 is reachable from Node 6.");
   53.42    }
   53.43 -  
   53.44 +
   53.45    {
   53.46      NullMap<Node,Arc> myPredMap;
   53.47      dfs(G).predMap(myPredMap).run(s);
    54.1 --- a/test/dijkstra_test.cc	Fri Aug 05 09:33:42 2011 +0200
    54.2 +++ b/test/dijkstra_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    54.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   54.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   54.11   *
   54.12 @@ -85,7 +85,7 @@
   54.13      n = const_dijkstra_test.nextNode();
   54.14      b = const_dijkstra_test.emptyQueue();
   54.15      i = const_dijkstra_test.queueSize();
   54.16 -    
   54.17 +
   54.18      dijkstra_test.start();
   54.19      dijkstra_test.start(t);
   54.20      dijkstra_test.start(nm);
   54.21 @@ -109,7 +109,7 @@
   54.22        ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
   54.23        ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
   54.24        ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
   54.25 -      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >, 
   54.26 +      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
   54.27                  concepts::ReadWriteMap<Node,int> >
   54.28        ::Create dijkstra_test(G,length);
   54.29  
   54.30 @@ -119,7 +119,7 @@
   54.31      concepts::WriteMap<Node,bool> processed_map;
   54.32      concepts::ReadWriteMap<Node,int> heap_cross_ref;
   54.33      BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
   54.34 -    
   54.35 +
   54.36      dijkstra_test
   54.37        .lengthMap(length_map)
   54.38        .predMap(pred_map)
   54.39 @@ -136,7 +136,7 @@
   54.40      n = dijkstra_test.nextNode();
   54.41      b = dijkstra_test.emptyQueue();
   54.42      i = dijkstra_test.queueSize();
   54.43 -    
   54.44 +
   54.45      dijkstra_test.start();
   54.46      dijkstra_test.start(t);
   54.47      dijkstra_test.start(nm);
    55.1 --- a/test/edge_set_test.cc	Fri Aug 05 09:33:42 2011 +0200
    55.2 +++ b/test/edge_set_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2008
    55.8 + * Copyright (C) 2003-2011
    55.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   55.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   55.11   *
    56.1 --- a/test/euler_test.cc	Fri Aug 05 09:33:42 2011 +0200
    56.2 +++ b/test/euler_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    56.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   56.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   56.11   *
   56.12 @@ -85,11 +85,11 @@
   56.13  {
   56.14    typedef ListDigraph Digraph;
   56.15    typedef Undirector<Digraph> Graph;
   56.16 -  
   56.17 +
   56.18    {
   56.19      Digraph d;
   56.20      Graph g(d);
   56.21 -    
   56.22 +
   56.23      checkDiEulerIt(d);
   56.24      checkDiEulerIt(g);
   56.25      checkEulerIt(g);
   56.26 @@ -128,7 +128,7 @@
   56.27      Digraph::Node n1 = d.addNode();
   56.28      Digraph::Node n2 = d.addNode();
   56.29      Digraph::Node n3 = d.addNode();
   56.30 -    
   56.31 +
   56.32      d.addArc(n1, n2);
   56.33      d.addArc(n2, n1);
   56.34      d.addArc(n2, n3);
   56.35 @@ -153,7 +153,7 @@
   56.36      Digraph::Node n4 = d.addNode();
   56.37      Digraph::Node n5 = d.addNode();
   56.38      Digraph::Node n6 = d.addNode();
   56.39 -    
   56.40 +
   56.41      d.addArc(n1, n2);
   56.42      d.addArc(n2, n4);
   56.43      d.addArc(n1, n3);
   56.44 @@ -189,7 +189,7 @@
   56.45      Digraph::Node n3 = d.addNode();
   56.46      Digraph::Node n4 = d.addNode();
   56.47      Digraph::Node n5 = d.addNode();
   56.48 -    
   56.49 +
   56.50      d.addArc(n1, n2);
   56.51      d.addArc(n2, n3);
   56.52      d.addArc(n3, n1);
   56.53 @@ -211,7 +211,7 @@
   56.54      Digraph::Node n1 = d.addNode();
   56.55      Digraph::Node n2 = d.addNode();
   56.56      Digraph::Node n3 = d.addNode();
   56.57 -    
   56.58 +
   56.59      d.addArc(n1, n2);
   56.60      d.addArc(n2, n3);
   56.61  
    57.1 --- a/test/gomory_hu_test.cc	Fri Aug 05 09:33:42 2011 +0200
    57.2 +++ b/test/gomory_hu_test.cc	Mon Aug 08 12:36:16 2011 +0200
    57.3 @@ -1,3 +1,21 @@
    57.4 +/* -*- mode: C++; indent-tabs-mode: nil; -*-
    57.5 + *
    57.6 + * This file is a part of LEMON, a generic C++ optimization library.
    57.7 + *
    57.8 + * Copyright (C) 2003-2011
    57.9 + * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   57.10 + * (Egervary Research Group on Combinatorial Optimization, EGRES).
   57.11 + *
   57.12 + * Permission to use, modify and distribute this software is granted
   57.13 + * provided that this copyright notice appears in all copies. For
   57.14 + * precise terms see the accompanying LICENSE file.
   57.15 + *
   57.16 + * This software is provided "AS IS" with no warranty of any kind,
   57.17 + * express or implied, and with no claim as to its suitability for any
   57.18 + * purpose.
   57.19 + *
   57.20 + */
   57.21 +
   57.22  #include <iostream>
   57.23  
   57.24  #include "test_tools.h"
   57.25 @@ -33,7 +51,7 @@
   57.26    "@attributes\n"
   57.27    "source 0\n"
   57.28    "target 3\n";
   57.29 -  
   57.30 +
   57.31  void checkGomoryHuCompile()
   57.32  {
   57.33    typedef int Value;
   57.34 @@ -69,7 +87,7 @@
   57.35  typedef Graph::NodeMap<bool> BoolNodeMap;
   57.36  
   57.37  int cutValue(const Graph& graph, const BoolNodeMap& cut,
   57.38 -	     const IntEdgeMap& capacity) {
   57.39 +             const IntEdgeMap& capacity) {
   57.40  
   57.41    int sum = 0;
   57.42    for (EdgeIt e(graph); e != INVALID; ++e) {
   57.43 @@ -107,7 +125,7 @@
   57.44  
   57.45        int sum=0;
   57.46        for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
   57.47 -        sum+=capacity[a]; 
   57.48 +        sum+=capacity[a];
   57.49        check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
   57.50  
   57.51        sum=0;
   57.52 @@ -118,6 +136,6 @@
   57.53        check(sum == countNodes(graph), "Problem with MinCutNodeIt");
   57.54      }
   57.55    }
   57.56 -  
   57.57 +
   57.58    return 0;
   57.59  }
    58.1 --- a/test/graph_copy_test.cc	Fri Aug 05 09:33:42 2011 +0200
    58.2 +++ b/test/graph_copy_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    58.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   58.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   58.11   *
   58.12 @@ -70,7 +70,7 @@
   58.13      nodeRef(nr).arcRef(er).
   58.14      nodeCrossRef(ncr).arcCrossRef(ecr).
   58.15      node(fn, tn).arc(fa, ta).run();
   58.16 -  
   58.17 +
   58.18    check(countNodes(from) == countNodes(to), "Wrong copy.");
   58.19    check(countArcs(from) == countArcs(to), "Wrong copy.");
   58.20  
   58.21 @@ -98,7 +98,7 @@
   58.22  
   58.23    // Test repeated copy
   58.24    digraphCopy(from, to).run();
   58.25 -  
   58.26 +
   58.27    check(countNodes(from) == countNodes(to), "Wrong copy.");
   58.28    check(countArcs(from) == countArcs(to), "Wrong copy.");
   58.29  }
   58.30 @@ -200,7 +200,7 @@
   58.31  
   58.32    // Test repeated copy
   58.33    graphCopy(from, to).run();
   58.34 -  
   58.35 +
   58.36    check(countNodes(from) == countNodes(to), "Wrong copy.");
   58.37    check(countEdges(from) == countEdges(to), "Wrong copy.");
   58.38    check(countArcs(from) == countArcs(to), "Wrong copy.");
    59.1 --- a/test/hao_orlin_test.cc	Fri Aug 05 09:33:42 2011 +0200
    59.2 +++ b/test/hao_orlin_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    59.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   59.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   59.11   *
   59.12 @@ -83,7 +83,7 @@
   59.13  }
   59.14  
   59.15  template <typename Graph, typename CapMap, typename CutMap>
   59.16 -typename CapMap::Value 
   59.17 +typename CapMap::Value
   59.18    cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
   59.19  {
   59.20    typename CapMap::Value sum = 0;
   59.21 @@ -110,7 +110,7 @@
   59.22      HaoOrlin<SmartDigraph> ho(graph, cap1);
   59.23      ho.run();
   59.24      ho.minCutMap(cut);
   59.25 -    
   59.26 +
   59.27      check(ho.minCutValue() == 1, "Wrong cut value");
   59.28      check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
   59.29    }
   59.30 @@ -126,19 +126,19 @@
   59.31      HaoOrlin<SmartDigraph> ho(graph, cap3);
   59.32      ho.run();
   59.33      ho.minCutMap(cut);
   59.34 -    
   59.35 +
   59.36      check(ho.minCutValue() == 1, "Wrong cut value");
   59.37      check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
   59.38    }
   59.39 -  
   59.40 +
   59.41    typedef Undirector<SmartDigraph> UGraph;
   59.42    UGraph ugraph(graph);
   59.43 -  
   59.44 +
   59.45    {
   59.46      HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap1);
   59.47      ho.run();
   59.48      ho.minCutMap(cut);
   59.49 -    
   59.50 +
   59.51      check(ho.minCutValue() == 2, "Wrong cut value");
   59.52      check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value");
   59.53    }
   59.54 @@ -146,7 +146,7 @@
   59.55      HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap2);
   59.56      ho.run();
   59.57      ho.minCutMap(cut);
   59.58 -    
   59.59 +
   59.60      check(ho.minCutValue() == 5, "Wrong cut value");
   59.61      check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
   59.62    }
   59.63 @@ -154,7 +154,7 @@
   59.64      HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap3);
   59.65      ho.run();
   59.66      ho.minCutMap(cut);
   59.67 -    
   59.68 +
   59.69      check(ho.minCutValue() == 5, "Wrong cut value");
   59.70      check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
   59.71    }
    60.1 --- a/test/heap_test.cc	Fri Aug 05 09:33:42 2011 +0200
    60.2 +++ b/test/heap_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    60.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   60.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   60.11   *
    61.1 --- a/test/lgf_test.cc	Fri Aug 05 09:33:42 2011 +0200
    61.2 +++ b/test/lgf_test.cc	Mon Aug 08 12:36:16 2011 +0200
    61.3 @@ -63,10 +63,10 @@
    61.4    "0 1\n";
    61.5  
    61.6  
    61.7 -int main() 
    61.8 +int main()
    61.9  {
   61.10    {
   61.11 -    ListDigraph d; 
   61.12 +    ListDigraph d;
   61.13      ListDigraph::Node s,t;
   61.14      ListDigraph::ArcMap<int> label(d);
   61.15      std::istringstream input(test_lgf);
   61.16 @@ -93,7 +93,7 @@
   61.17    }
   61.18  
   61.19    {
   61.20 -    ListDigraph d; 
   61.21 +    ListDigraph d;
   61.22      std::istringstream input(test_lgf_nomap);
   61.23      digraphReader(d, input).
   61.24        run();
   61.25 @@ -110,14 +110,14 @@
   61.26    }
   61.27  
   61.28    {
   61.29 -    ListDigraph d; 
   61.30 +    ListDigraph d;
   61.31      std::istringstream input(test_lgf_bad1);
   61.32      bool ok=false;
   61.33      try {
   61.34        digraphReader(d, input).
   61.35          run();
   61.36      }
   61.37 -    catch (FormatError& error) 
   61.38 +    catch (FormatError& error)
   61.39        {
   61.40          ok = true;
   61.41        }
   61.42 @@ -139,7 +139,7 @@
   61.43    }
   61.44  
   61.45    {
   61.46 -    ListDigraph d; 
   61.47 +    ListDigraph d;
   61.48      std::istringstream input(test_lgf_bad2);
   61.49      bool ok=false;
   61.50      try {
    62.1 --- a/test/maps_test.cc	Fri Aug 05 09:33:42 2011 +0200
    62.2 +++ b/test/maps_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    62.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   62.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   62.11   *
   62.12 @@ -70,8 +70,10 @@
   62.13    checkConcept<WriteMap<A,C>, WriteMap<A,C> >();
   62.14    checkConcept<ReadWriteMap<A,B>, ReadWriteMap<A,B> >();
   62.15    checkConcept<ReadWriteMap<A,C>, ReadWriteMap<A,C> >();
   62.16 -  checkConcept<ReferenceMap<A,B,B&,const B&>, ReferenceMap<A,B,B&,const B&> >();
   62.17 -  checkConcept<ReferenceMap<A,C,C&,const C&>, ReferenceMap<A,C,C&,const C&> >();
   62.18 +  checkConcept<ReferenceMap<A,B,B&,const B&>,
   62.19 +               ReferenceMap<A,B,B&,const B&> >();
   62.20 +  checkConcept<ReferenceMap<A,C,C&,const C&>,
   62.21 +               ReferenceMap<A,C,C&,const C&> >();
   62.22  
   62.23    // NullMap
   62.24    {
   62.25 @@ -200,7 +202,8 @@
   62.26      B b = functorToMap(F())[A()];
   62.27  
   62.28      checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
   62.29 -    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
   62.30 +    MapToFunctor<ReadMap<A,B> > map =
   62.31 +      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
   62.32  
   62.33      check(functorToMap(&func)[A()] == 3,
   62.34            "Something is wrong with FunctorToMap");
   62.35 @@ -349,7 +352,7 @@
   62.36            it != map2.end(); ++it )
   62.37        check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
   62.38    }
   62.39 -  
   62.40 +
   62.41    // CrossRefMap
   62.42    {
   62.43      typedef ListDigraph Graph;
   62.44 @@ -357,16 +360,16 @@
   62.45  
   62.46      checkConcept<ReadWriteMap<Node, int>,
   62.47                   CrossRefMap<Graph, Node, int> >();
   62.48 -    
   62.49 +
   62.50      Graph gr;
   62.51      typedef CrossRefMap<Graph, Node, char> CRMap;
   62.52      typedef CRMap::ValueIterator ValueIt;
   62.53      CRMap map(gr);
   62.54 -    
   62.55 +
   62.56      Node n0 = gr.addNode();
   62.57      Node n1 = gr.addNode();
   62.58      Node n2 = gr.addNode();
   62.59 -    
   62.60 +
   62.61      map.set(n0, 'A');
   62.62      map.set(n1, 'B');
   62.63      map.set(n2, 'C');
    63.1 --- a/test/matching_test.cc	Fri Aug 05 09:33:42 2011 +0200
    63.2 +++ b/test/matching_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2009
    63.8 + * Copyright (C) 2003-2011
    63.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   63.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   63.11   *
   63.12 @@ -134,7 +134,7 @@
   63.13    mat_test.startSparse();
   63.14    mat_test.startDense();
   63.15    mat_test.run();
   63.16 -  
   63.17 +
   63.18    const_mat_test.matchingSize();
   63.19    const_mat_test.matching(e);
   63.20    const_mat_test.matching(n);
   63.21 @@ -143,7 +143,7 @@
   63.22    e = mmap[n];
   63.23    const_mat_test.mate(n);
   63.24  
   63.25 -  MaxMatching<Graph>::Status stat = 
   63.26 +  MaxMatching<Graph>::Status stat =
   63.27      const_mat_test.status(n);
   63.28    const MaxMatching<Graph>::StatusMap& smap =
   63.29      const_mat_test.statusMap();
   63.30 @@ -170,7 +170,7 @@
   63.31    mat_test.init();
   63.32    mat_test.start();
   63.33    mat_test.run();
   63.34 -  
   63.35 +
   63.36    const_mat_test.matchingWeight();
   63.37    const_mat_test.matchingSize();
   63.38    const_mat_test.matching(e);
   63.39 @@ -179,7 +179,7 @@
   63.40      const_mat_test.matchingMap();
   63.41    e = mmap[n];
   63.42    const_mat_test.mate(n);
   63.43 -  
   63.44 +
   63.45    int k = 0;
   63.46    const_mat_test.dualValue();
   63.47    const_mat_test.nodeValue(n);
   63.48 @@ -207,7 +207,7 @@
   63.49    mat_test.init();
   63.50    mat_test.start();
   63.51    mat_test.run();
   63.52 -  
   63.53 +
   63.54    const_mat_test.matchingWeight();
   63.55    const_mat_test.matching(e);
   63.56    const_mat_test.matching(n);
   63.57 @@ -215,7 +215,7 @@
   63.58      const_mat_test.matchingMap();
   63.59    e = mmap[n];
   63.60    const_mat_test.mate(n);
   63.61 -  
   63.62 +
   63.63    int k = 0;
   63.64    const_mat_test.dualValue();
   63.65    const_mat_test.nodeValue(n);
    64.1 --- a/test/min_cost_arborescence_test.cc	Fri Aug 05 09:33:42 2011 +0200
    64.2 +++ b/test/min_cost_arborescence_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    64.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   64.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   64.11   *
   64.12 @@ -110,7 +110,7 @@
   64.13    n = mcarb_test.processNextNode();
   64.14    b = const_mcarb_test.emptyQueue();
   64.15    i = const_mcarb_test.queueSize();
   64.16 -  
   64.17 +
   64.18    c = const_mcarb_test.arborescenceCost();
   64.19    b = const_mcarb_test.arborescence(e);
   64.20    e = const_mcarb_test.pred(n);
   64.21 @@ -120,12 +120,12 @@
   64.22      const_mcarb_test.predMap();
   64.23    b = const_mcarb_test.reached(n);
   64.24    b = const_mcarb_test.processed(n);
   64.25 -  
   64.26 +
   64.27    i = const_mcarb_test.dualNum();
   64.28    c = const_mcarb_test.dualValue();
   64.29    i = const_mcarb_test.dualSize(i);
   64.30    c = const_mcarb_test.dualValue(i);
   64.31 -  
   64.32 +
   64.33    ignore_unused_variable_warning(am);
   64.34    ignore_unused_variable_warning(pm);
   64.35  }
    65.1 --- a/test/min_cost_flow_test.cc	Fri Aug 05 09:33:42 2011 +0200
    65.2 +++ b/test/min_cost_flow_test.cc	Mon Aug 08 12:36:16 2011 +0200
    65.3 @@ -2,7 +2,7 @@
    65.4   *
    65.5   * This file is a part of LEMON, a generic C++ optimization library.
    65.6   *
    65.7 - * Copyright (C) 2003-2009
    65.8 + * Copyright (C) 2003-2011
    65.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   65.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   65.11   *
   65.12 @@ -47,7 +47,7 @@
   65.13    "   10    -2    0    0    0   -7   -2\n"
   65.14    "   11     0    0    0    0  -10    0\n"
   65.15    "   12   -20  -27    0  -30  -30  -20\n"
   65.16 -  "\n"                
   65.17 +  "\n"
   65.18    "@arcs\n"
   65.19    "       cost  cap low1 low2 low3\n"
   65.20    " 1  2    70   11    0    8    8\n"
   65.21 @@ -93,7 +93,7 @@
   65.22    struct Constraints {
   65.23      void constraints() {
   65.24        checkConcept<concepts::Digraph, GR>();
   65.25 -      
   65.26 +
   65.27        const Constraints& me = *this;
   65.28  
   65.29        MCF mcf(me.g);
   65.30 @@ -122,7 +122,7 @@
   65.31      typedef concepts::ReadMap<Arc, Cost> CAM;
   65.32      typedef concepts::WriteMap<Arc, Value> FlowMap;
   65.33      typedef concepts::WriteMap<Node, Cost> PotMap;
   65.34 -  
   65.35 +
   65.36      GR g;
   65.37      VAM lower;
   65.38      VAM upper;
   65.39 @@ -176,7 +176,7 @@
   65.40  template < typename GR, typename LM, typename UM,
   65.41             typename CM, typename SM, typename FM, typename PM >
   65.42  bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
   65.43 -                     const CM& cost, const SM& supply, const FM& flow, 
   65.44 +                     const CM& cost, const SM& supply, const FM& flow,
   65.45                       const PM& pi, SupplyType type )
   65.46  {
   65.47    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
   65.48 @@ -189,7 +189,7 @@
   65.49            (red_cost > 0 && flow[e] == lower[e]) ||
   65.50            (red_cost < 0 && flow[e] == upper[e]);
   65.51    }
   65.52 -  
   65.53 +
   65.54    for (NodeIt n(gr); opt && n != INVALID; ++n) {
   65.55      typename SM::Value sum = 0;
   65.56      for (OutArcIt e(gr, n); e != INVALID; ++e)
   65.57 @@ -202,7 +202,7 @@
   65.58        opt = (pi[n] >= 0) && (sum == supply[n] || pi[n] == 0);
   65.59      }
   65.60    }
   65.61 -  
   65.62 +
   65.63    return opt;
   65.64  }
   65.65  
   65.66 @@ -227,7 +227,7 @@
   65.67        red_supply[gr.target(a)] += lower[a];
   65.68      }
   65.69    }
   65.70 -  
   65.71 +
   65.72    for (NodeIt n(gr); n != INVALID; ++n) {
   65.73      dual_cost -= red_supply[n] * pi[n];
   65.74    }
   65.75 @@ -236,7 +236,7 @@
   65.76        cost[a] + pi[gr.source(a)] - pi[gr.target(a)];
   65.77      dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
   65.78    }
   65.79 -  
   65.80 +
   65.81    return dual_cost == total;
   65.82  }
   65.83  
   65.84 @@ -308,7 +308,7 @@
   65.85      .node("source", v)
   65.86      .node("target", w)
   65.87      .run();
   65.88 -  
   65.89 +
   65.90    // Build test digraphs with negative costs
   65.91    Digraph neg_gr;
   65.92    Node n1 = neg_gr.addNode();
   65.93 @@ -318,7 +318,7 @@
   65.94    Node n5 = neg_gr.addNode();
   65.95    Node n6 = neg_gr.addNode();
   65.96    Node n7 = neg_gr.addNode();
   65.97 -  
   65.98 +
   65.99    Arc a1 = neg_gr.addArc(n1, n2);
  65.100    Arc a2 = neg_gr.addArc(n1, n3);
  65.101    Arc a3 = neg_gr.addArc(n2, n4);
  65.102 @@ -328,17 +328,17 @@
  65.103    Arc a7 = neg_gr.addArc(n5, n6);
  65.104    Arc a8 = neg_gr.addArc(n6, n7);
  65.105    Arc a9 = neg_gr.addArc(n7, n5);
  65.106 -  
  65.107 +
  65.108    Digraph::ArcMap<int> neg_c(neg_gr), neg_l1(neg_gr, 0), neg_l2(neg_gr, 0);
  65.109    ConstMap<Arc, int> neg_u1(std::numeric_limits<int>::max()), neg_u2(5000);
  65.110    Digraph::NodeMap<int> neg_s(neg_gr, 0);
  65.111 -  
  65.112 +
  65.113    neg_l2[a7] =  1000;
  65.114    neg_l2[a8] = -1000;
  65.115 -  
  65.116 +
  65.117    neg_s[n1] =  100;
  65.118    neg_s[n4] = -100;
  65.119 -  
  65.120 +
  65.121    neg_c[a1] =  100;
  65.122    neg_c[a2] =   30;
  65.123    neg_c[a3] =   20;
  65.124 @@ -422,7 +422,7 @@
  65.125      neg_mcf.reset().lowerMap(neg_l2).costMap(neg_c).supplyMap(neg_s);
  65.126      checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l2, neg_u1,
  65.127        neg_c, neg_s, neg_mcf.UNBOUNDED, false,    0, "#A18");
  65.128 -      
  65.129 +
  65.130      NetworkSimplex<Digraph> negs_mcf(negs_gr);
  65.131      negs_mcf.costMap(negs_c).supplyMap(negs_s);
  65.132      checkMcf(negs_mcf, negs_mcf.run(), negs_gr, negs_l, negs_u,
    66.1 --- a/test/preflow_test.cc	Fri Aug 05 09:33:42 2011 +0200
    66.2 +++ b/test/preflow_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    66.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   66.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   66.11   *
   66.12 @@ -113,7 +113,7 @@
   66.13    const FlowMap& fm = const_preflow_test.flowMap();
   66.14    b = const_preflow_test.minCut(n);
   66.15    const_preflow_test.minCutMap(cut);
   66.16 -  
   66.17 +
   66.18    ignore_unused_variable_warning(fm);
   66.19  }
   66.20  
   66.21 @@ -154,7 +154,7 @@
   66.22  void initFlowTest()
   66.23  {
   66.24    DIGRAPH_TYPEDEFS(SmartDigraph);
   66.25 -  
   66.26 +
   66.27    SmartDigraph g;
   66.28    SmartDigraph::ArcMap<int> cap(g),iflow(g);
   66.29    Node s=g.addNode(); Node t=g.addNode();
   66.30 @@ -266,6 +266,6 @@
   66.31          "The max flow value or the three min cut values are incorrect.");
   66.32  
   66.33    initFlowTest();
   66.34 -  
   66.35 +
   66.36    return 0;
   66.37  }
    67.1 --- a/test/suurballe_test.cc	Fri Aug 05 09:33:42 2011 +0200
    67.2 +++ b/test/suurballe_test.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    67.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   67.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   67.11   *
   67.12 @@ -80,7 +80,7 @@
   67.13    typedef Digraph::Node Node;
   67.14    typedef Digraph::Arc Arc;
   67.15    typedef concepts::ReadMap<Arc, VType> LengthMap;
   67.16 -  
   67.17 +
   67.18    typedef Suurballe<Digraph, LengthMap> SuurballeType;
   67.19  
   67.20    Digraph g;
   67.21 @@ -104,7 +104,7 @@
   67.22    k = suurb_test.findFlow(n);
   67.23    k = suurb_test.findFlow(n, k);
   67.24    suurb_test.findPaths();
   67.25 -  
   67.26 +
   67.27    int f;
   67.28    VType c;
   67.29    c = const_suurb_test.totalLength();
   67.30 @@ -116,7 +116,7 @@
   67.31      const_suurb_test.potentialMap();
   67.32    k = const_suurb_test.pathNum();
   67.33    Path<Digraph> p = const_suurb_test.path(k);
   67.34 -  
   67.35 +
   67.36    ignore_unused_variable_warning(fm);
   67.37    ignore_unused_variable_warning(pm);
   67.38  }
    68.1 --- a/tools/dimacs-solver.cc	Fri Aug 05 09:33:42 2011 +0200
    68.2 +++ b/tools/dimacs-solver.cc	Mon Aug 08 12:36:16 2011 +0200
    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-2011
    68.9   * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
   68.10   * (Egervary Research Group on Combinatorial Optimization, EGRES).
   68.11   *
   68.12 @@ -88,7 +88,7 @@
   68.13    ti.restart();
   68.14    pre.run();
   68.15    if(report) std::cerr << "Run Preflow: " << ti << '\n';
   68.16 -  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  
   68.17 +  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
   68.18  }
   68.19  
   68.20  template<class Value>
   68.21 @@ -147,7 +147,7 @@
   68.22    mat.run();
   68.23    if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
   68.24    if(report) std::cerr << "\nCardinality of max matching: "
   68.25 -                       << mat.matchingSize() << '\n';  
   68.26 +                       << mat.matchingSize() << '\n';
   68.27  }
   68.28  
   68.29  
   68.30 @@ -165,7 +165,7 @@
   68.31                  << std::endl;
   68.32        exit(1);
   68.33      }
   68.34 -  
   68.35 +
   68.36    switch(desc.type)
   68.37      {
   68.38      case DimacsDescriptor::MIN:
   68.39 @@ -237,7 +237,7 @@
   68.40    std::ostream& os = (ap.files().size()<2 ? std::cout : output);
   68.41  
   68.42    DimacsDescriptor desc = dimacsType(is);
   68.43 -  
   68.44 +
   68.45    if(!ap.given("q"))
   68.46      {
   68.47        std::cout << "Problem type: ";
   68.48 @@ -262,7 +262,7 @@
   68.49        std::cout << "\nNum of arcs:  " << desc.edgeNum;
   68.50        std::cout << "\n\n";
   68.51      }
   68.52 -    
   68.53 +
   68.54    if(ap.given("double"))
   68.55      solve<double>(ap,is,os,desc);
   68.56    else if(ap.given("ldouble"))