Changeset 956:141f9c0db4a3 – LEMON

demo/arg_parser_demo.cc

-                      r915
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   // about memory leaks.
   ap.throwOnProblems();
   // Perform the parsing process
   // (in case of any error it terminates the program)

doc/groups.dox

r953	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/mainpage.dox

-                      r921
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 It is a C++ template library providing efficient implementations of common
 data structures and algorithms with focus on combinatorial optimization
 tasks connected mainly with graphs and networks.
+tasks connected mainly with graphs and networks.
 <b>
 …
 </b>
 The project is maintained by the
+The project is maintained by the
 <a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
 Combinatorial Optimization</a> \ref egres

doc/min_cost_flow.dox

-                      r835
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
 Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc
 \f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e.
 …
 \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
 It means that the total demand must be less or equal to the
+It means that the total demand must be less or equal to the
 total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
 positive) and all the demands have to be satisfied, but there

lemon/adaptors.h

-                      r834
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       Parent::initialize(digraph);
       _node_filter = &node_filter;
       _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;
+    }
 …
     template <typename V>
     class NodeMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
               LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
+    class NodeMap
+      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
+              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
+        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
     public:
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
               LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
+              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 …
       Parent::initialize(digraph);
       _node_filter = &node_filter;
       _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;
+    }
 …
     template <typename V>
     class NodeMap
+    class NodeMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 …
     template <typename V>
     class NodeMap
+    class NodeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 …
     template <typename V>
     class EdgeMap
+    class EdgeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 …
     NF* _node_filter;
     EF* _edge_filter;
     SubGraphBase()
           : Parent(), _node_filter(0), _edge_filter(0) { }
+    SubGraphBase()
+          : Parent(), _node_filter(0), _edge_filter(0) { }
     void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
 …
     template <typename V>
     class NodeMap
+    class NodeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 …
     template <typename V>
     class ArcMap
+    class ArcMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 …
     template <typename V>
     class EdgeMap
+    class EdgeMap
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
       typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
     public:
 …
 #endif
     typedef DigraphAdaptorExtender<
       SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
                      true> > Parent;
 …
     /// Creates a subgraph for the given digraph or graph with the
     /// given node filter map.
     FilterNodes(GR& graph, NF& node_filter)
+    FilterNodes(GR& graph, NF& node_filter)
       : Parent(), const_true_map()
+    {
 …
                     typename enable_if<UndirectedTagIndicator<GR> >::type> :
     public GraphAdaptorExtender<
       SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
                    true> > {
     typedef GraphAdaptorExtender<
       SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
                    true> > Parent;
 …
 #endif
     typedef DigraphAdaptorExtender<
       SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
+      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
                      AF, false> > Parent;
 …
   class FilterEdges :
     public GraphAdaptorExtender<
       SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
                    EF, false> > {
 #endif
     typedef GraphAdaptorExtender<
       SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
                    EF, false> > Parent;
 …
     /// Creates a subgraph for the given graph with the given edge
     /// filter map.
     FilterEdges(GR& graph, EF& edge_filter)
+    FilterEdges(GR& graph, EF& edge_filter)
       : Parent(), const_true_map() {
       Parent::initialize(graph, const_true_map, edge_filter);
 …
       bool _forward;
       Arc(const Edge& edge, bool forward)
+      Arc(const Edge& edge, bool forward)
         : _edge(edge), _forward(forward) {}
 …
       ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
         : _forward(*adaptor._digraph, value),
+        : _forward(*adaptor._digraph, value),
           _backward(*adaptor._digraph, value) {}
 …
     typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
     EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
     typedef EdgeNotifier ArcNotifier;
     ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
 …
            typename FM = CM,
            typename TL = Tolerance<typename CM::Value> >
   class ResidualDigraph
+  class ResidualDigraph
     : public SubDigraph<
         Undirector<const DGR>,
 …
     ResidualDigraph(const DGR& digraph, const CM& capacity,
                     FM& flow, const TL& tolerance = Tolerance())
       : Parent(), _capacity(&capacity), _flow(&flow),
+      : Parent(), _capacity(&capacity), _flow(&flow),
         _graph(digraph), _node_filter(),
         _forward_filter(capacity, flow, tolerance),
 …
       /// Constructor
       ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
+      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
         : _adaptor(&adaptor) {}
 …
     /// to get a node map of the split digraph.
     /// Its value type is inherited from the first node map type (\c IN).
     /// \tparam IN The type of the node map for the in-nodes.
+    /// \tparam IN The type of the node map for the in-nodes.
     /// \tparam OUT The type of the node map for the out-nodes.
     template <typename IN, typename OUT>

lemon/arg_parser.cc

r915	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).
…	…
27	27	else throw(ArgParserException(reason));
28	28	}
29
30
	29
	30
31	31	void ArgParser::_showHelp(void *p)
32	32	{

lemon/arg_parser.h

-                      r915
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       INVALID_OPT   /// Invalid combination of options
     };
   private:
     Reason _reason;
   public:
     ///Constructor
 …
     std::string _command_name;
   private:
     //Bind a function to an option.
 …
     bool _exit_on_problems;
     void _terminate(ArgParserException::Reason reason) const;
 …
     ///Throw instead of exit in case of problems
     void throwOnProblems()
+    void throwOnProblems()
+    {
       _exit_on_problems=false;

lemon/bellman_ford.h

-                      r917
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// \brief Default operation traits for the BellmanFord algorithm class.
   ///
+  ///
   /// This operation traits class defines all computational operations
   /// and constants that are used in the Bellman-Ford algorithm.
 …
   /// \see BellmanFordToleranceOperationTraits
   template <
     typename V,
+    typename V,
     bool has_inf = std::numeric_limits<V>::has_infinity>
   struct BellmanFordDefaultOperationTraits {
 …
+    }
   };
   /// \brief Operation traits for the BellmanFord algorithm class
   /// using tolerance.
 …
   template<typename GR, typename LEN>
   struct BellmanFordDefaultTraits {
     /// The type of the digraph the algorithm runs on.
+    /// The type of the digraph the algorithm runs on.
     typedef GR Digraph;
 …
     /// BellmanFordToleranceOperationTraits
     typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
     /// \brief The type of the map that stores the last arcs of the
+    /// \brief The type of the map that stores the last arcs of the
     /// shortest paths.
     ///
+    ///
     /// The type of the map that stores the last
     /// arcs of the shortest paths.
 …
     /// \brief Instantiates a \c PredMap.
     ///
     /// This function instantiates a \ref PredMap.
+    ///
+    /// This function instantiates a \ref PredMap.
     /// \param g is the digraph to which we would like to define the
     /// \ref PredMap.
 …
     /// \brief Instantiates a \c DistMap.
     ///
     /// This function instantiates a \ref DistMap.
     /// \param g is the digraph to which we would like to define the
+    /// This function instantiates a \ref DistMap.
+    /// \param g is the digraph to which we would like to define the
     /// \ref DistMap.
     static DistMap *createDistMap(const GR& g) {
 …
   };
   /// \brief %BellmanFord algorithm class.
   ///
   /// \ingroup shortest_path
   /// This class provides an efficient implementation of the Bellman-Ford
+  /// This class provides an efficient implementation of the Bellman-Ford
   /// algorithm. The maximum time complexity of the algorithm is
   /// <tt>O(ne)</tt>.
 …
   ///
   /// The arc lengths are passed to the algorithm using a
   /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
+  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
   /// kind of length. The type of the length values is determined by the
   /// \ref concepts::ReadMap::Value "Value" type of the length map.
 …
     ///The type of the underlying digraph.
     typedef typename TR::Digraph Digraph;
     /// \brief The type of the arc lengths.
     typedef typename TR::LengthMap::Value Value;
 …
     void create_maps() {
       if(!_pred) {
         _local_pred = true;
         _pred = Traits::createPredMap(*_gr);
+        _local_pred = true;
+        _pred = Traits::createPredMap(*_gr);
+      }
       if(!_dist) {
         _local_dist = true;
         _dist = Traits::createDistMap(*_gr);
+        _local_dist = true;
+        _dist = Traits::createDistMap(*_gr);
+      }
       if(!_mask) {
 …
+      }
+    }
   public :
     typedef BellmanFord Create;
 …
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap
+    struct SetPredMap
       : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
       typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
     };
     template <class T>
     struct SetDistMapTraits : public Traits {
 …
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap
+    struct SetDistMap
       : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
       typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
 …
       typedef T OperationTraits;
     };
     /// \brief \ref named-templ-param "Named parameter" for setting
+    /// \brief \ref named-templ-param "Named parameter" for setting
     /// \c OperationTraits type.
     ///
 …
       Create;
     };
     ///@}
   protected:
     BellmanFord() {}
   public:
+  public:
     /// \brief Constructor.
     ///
 …
       _pred(0), _local_pred(false),
       _dist(0), _local_dist(false), _mask(0) {}
     ///Destructor.
     ~BellmanFord() {
 …
     BellmanFord &predMap(PredMap &map) {
       if(_local_pred) {
         delete _pred;
         _local_pred=false;
+        delete _pred;
+        _local_pred=false;
+      }
       _pred = &map;
 …
     BellmanFord &distMap(DistMap &map) {
       if(_local_dist) {
         delete _dist;
         _local_dist=false;
+        delete _dist;
+        _local_dist=false;
+      }
       _dist = &map;
 …
     /// \brief Initializes the internal data structures.
     ///
+    ///
     /// Initializes the internal data structures. The optional parameter
     /// is the initial distance of each node.
 …
       create_maps();
       for (NodeIt it(*_gr); it != INVALID; ++it) {
         _pred->set(it, INVALID);
         _dist->set(it, value);
+        _pred->set(it, INVALID);
+        _dist->set(it, value);
+      }
       _process.clear();
       if (OperationTraits::less(value, OperationTraits::infinity())) {
         for (NodeIt it(*_gr); it != INVALID; ++it) {
           _process.push_back(it);
           _mask->set(it, true);
+        }
+        for (NodeIt it(*_gr); it != INVALID; ++it) {
+          _process.push_back(it);
+          _mask->set(it, true);
+        }
       } else {
         for (NodeIt it(*_gr); it != INVALID; ++it) {
           _mask->set(it, false);
+        }
+      }
+    }
+        for (NodeIt it(*_gr); it != INVALID; ++it) {
+          _mask->set(it, false);
+        }
+      }
+    }
     /// \brief Adds a new source node.
     ///
 …
       _dist->set(source, dst);
       if (!(*_mask)[source]) {
         _process.push_back(source);
         _mask->set(source, true);
+        _process.push_back(source);
+        _mask->set(source, true);
+      }
+    }
 …
     bool processNextRound() {
       for (int i = 0; i < int(_process.size()); ++i) {
         _mask->set(_process[i], false);
+        _mask->set(_process[i], false);
+      }
       std::vector<Node> nextProcess;
       std::vector<Value> values(_process.size());
       for (int i = 0; i < int(_process.size()); ++i) {
         values[i] = (*_dist)[_process[i]];
+        values[i] = (*_dist)[_process[i]];
+      }
       for (int i = 0; i < int(_process.size()); ++i) {
         for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
           Node target = _gr->target(it);
           Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
           if (OperationTraits::less(relaxed, (*_dist)[target])) {
             _pred->set(target, it);
             _dist->set(target, relaxed);
             if (!(*_mask)[target]) {
               _mask->set(target, true);
               nextProcess.push_back(target);
+            }
+          }
+        }
+        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
+          Node target = _gr->target(it);
+          Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
+          if (OperationTraits::less(relaxed, (*_dist)[target])) {
+            _pred->set(target, it);
+            _dist->set(target, relaxed);
+            if (!(*_mask)[target]) {
+              _mask->set(target, true);
+              nextProcess.push_back(target);
+            }
+          }
+        }
+      }
       _process.swap(nextProcess);
 …
     bool processNextWeakRound() {
       for (int i = 0; i < int(_process.size()); ++i) {
         _mask->set(_process[i], false);
+        _mask->set(_process[i], false);
+      }
       std::vector<Node> nextProcess;
       for (int i = 0; i < int(_process.size()); ++i) {
         for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
           Node target = _gr->target(it);
+          Value relaxed =
             OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
           if (OperationTraits::less(relaxed, (*_dist)[target])) {
             _pred->set(target, it);
             _dist->set(target, relaxed);
             if (!(*_mask)[target]) {
               _mask->set(target, true);
               nextProcess.push_back(target);
+            }
+          }
+        }
+        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
+          Node target = _gr->target(it);
+          Value relaxed =
+            OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
+          if (OperationTraits::less(relaxed, (*_dist)[target])) {
+            _pred->set(target, it);
+            _dist->set(target, relaxed);
+            if (!(*_mask)[target]) {
+              _mask->set(target, true);
+              nextProcess.push_back(target);
+            }
+          }
+        }
+      }
       _process.swap(nextProcess);
 …
       int num = countNodes(*_gr) - 1;
       for (int i = 0; i < num; ++i) {
         if (processNextWeakRound()) break;
+        if (processNextWeakRound()) break;
+      }
+    }
 …
     /// if the digraph contains cycles with negative total length.
     ///
     /// The algorithm computes
+    /// The algorithm computes
     /// - the shortest path tree (forest),
     /// - the distance of each node from the root(s).
     ///
+    ///
     /// \return \c false if there is a negative cycle in the digraph.
     ///
     /// \pre init() must be called and at least one root node should be
     /// added with addSource() before using this function.
+    /// added with addSource() before using this function.
     bool checkedStart() {
       int num = countNodes(*_gr);
       for (int i = 0; i < num; ++i) {
         if (processNextWeakRound()) return true;
+        if (processNextWeakRound()) return true;
+      }
       return _process.empty();
 …
     ///
     /// \pre init() must be called and at least one root node should be
     /// added with addSource() before using this function.
+    /// added with addSource() before using this function.
     void limitedStart(int num) {
       for (int i = 0; i < num; ++i) {
         if (processNextRound()) break;
+      }
+    }
+        if (processNextRound()) break;
+      }
+    }
     /// \brief Runs the algorithm from the given root node.
     ///
+    ///
     /// This method runs the Bellman-Ford algorithm from the given root
     /// node \c s in order to compute the shortest path to each node.
 …
       start();
+    }
     /// \brief Runs the algorithm from the given root node with arc
     /// number limit.
     ///
+    ///
     /// This method runs the Bellman-Ford algorithm from the given root
     /// node \c s in order to compute the shortest path distance for each
 …
       limitedStart(num);
+    }
     ///@}
 …
       ///
       /// Constructor for getting the active nodes of the given BellmanFord
       /// instance.
+      /// instance.
       ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
+      {
 …
       ///
       /// Conversion to \c Node.
       operator Node() const {
+      operator Node() const {
         return _index >= 0 ? _algorithm->_process[_index] : INVALID;
+      }
 …
       ActiveIt& operator++() {
         --_index;
         return *this;
+      }
       bool operator==(const ActiveIt& it) const {
         return static_cast<Node>(*this) == static_cast<Node>(it);
+      }
       bool operator!=(const ActiveIt& it) const {
         return static_cast<Node>(*this) != static_cast<Node>(it);
+      }
       bool operator<(const ActiveIt& it) const {
         return static_cast<Node>(*this) < static_cast<Node>(it);
+      }
+        return *this;
+      }
+      bool operator==(const ActiveIt& it) const {
+        return static_cast<Node>(*this) == static_cast<Node>(it);
+      }
+      bool operator!=(const ActiveIt& it) const {
+        return static_cast<Node>(*this) != static_cast<Node>(it);
+      }
+      bool operator<(const ActiveIt& it) const {
+        return static_cast<Node>(*this) < static_cast<Node>(it);
+      }
     private:
       const BellmanFord* _algorithm;
       int _index;
     };
     /// \name Query Functions
     /// The result of the Bellman-Ford algorithm can be obtained using these
     /// functions.\n
     /// Either \ref run() or \ref init() should be called before using them.
     ///@{
     /// \brief The shortest path to the given node.
     ///
+    ///
     /// Gives back the shortest path to the given node from the root(s).
     ///
 …
       return Path(*_gr, *_pred, t);
+    }
     /// \brief The distance of the given node from the root(s).
     ///
 …
     /// \pre Either \ref run() or \ref init() must be called before
     /// using this function.
     Node predNode(Node v) const {
       return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
+    }
+    Node predNode(Node v) const {
+      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
+    }
     /// \brief Returns a const reference to the node map that stores the
     /// distances of the nodes.
 …
     /// using this function.
     const DistMap &distMap() const { return *_dist;}
     /// \brief Returns a const reference to the node map that stores the
     /// predecessor arcs.
 …
     /// using this function.
     const PredMap &predMap() const { return *_pred; }
     /// \brief Checks if a node is reached from the root(s).
     ///
 …
     /// \brief Gives back a negative cycle.
     ///
+    ///
     /// This function gives back a directed cycle with negative total
     /// length if the algorithm has already found one.
 …
       return cycle;
+    }
     ///@}
   };
   /// \brief Default traits class of bellmanFord() function.
   ///
 …
   template <typename GR, typename LEN>
   struct BellmanFordWizardDefaultTraits {
     /// The type of the digraph the algorithm runs on.
+    /// The type of the digraph the algorithm runs on.
     typedef GR Digraph;
 …
     /// \brief The type of the map that stores the last
     /// arcs of the shortest paths.
     ///
+    ///
     /// The type of the map that stores the last arcs of the shortest paths.
     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 …
     /// \brief Instantiates a \c PredMap.
     ///
+    ///
     /// This function instantiates a \ref PredMap.
     /// \param g is the digraph to which we would like to define the
 …
     /// \brief Instantiates a \c DistMap.
     ///
     /// This function instantiates a \ref DistMap.
+    /// This function instantiates a \ref DistMap.
     /// \param g is the digraph to which we would like to define the
     /// \ref DistMap.
 …
     typedef lemon::Path<Digraph> Path;
   };
   /// \brief Default traits class used by BellmanFordWizard.
   ///
 …
   /// \tparam LEN The type of the length map.
   template <typename GR, typename LEN>
   class BellmanFordWizardBase
+  class BellmanFordWizardBase
     : public BellmanFordWizardDefaultTraits<GR, LEN> {
 …
     public:
     /// Constructor.
     /// This constructor does not require parameters, it initiates
     /// all of the attributes to default values \c 0.
 …
     /// Constructor.
     /// This constructor requires two parameters,
     /// others are initiated to \c 0.
     /// \param gr The digraph the algorithm runs on.
     /// \param len The length map.
     BellmanFordWizardBase(const GR& gr,
                           const LEN& len) :
       _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))),
       _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))),
+    BellmanFordWizardBase(const GR& gr,
+                          const LEN& len) :
+      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))),
+      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))),
       _pred(0), _dist(0), _path(0), _di(0) {}
   };
   /// \brief Auxiliary class for the function-type interface of the
   /// \ref BellmanFord "Bellman-Ford" algorithm.
 …
     typedef typename Digraph::Arc Arc;
     typedef typename Digraph::OutArcIt ArcIt;
     typedef typename TR::LengthMap LengthMap;
     typedef typename LengthMap::Value Value;
 …
     /// \param gr The digraph the algorithm runs on.
     /// \param len The length map.
     BellmanFordWizard(const Digraph& gr, const LengthMap& len)
+    BellmanFordWizard(const Digraph& gr, const LengthMap& len)
       : TR(gr, len) {}
 …
     /// \brief Runs the Bellman-Ford algorithm from the given source node.
     ///
+    ///
     /// This method runs the Bellman-Ford algorithm from the given source
     /// node in order to compute the shortest path to each node.
     void run(Node s) {
       BellmanFord<Digraph,LengthMap,TR>
+        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
+      BellmanFord<Digraph,LengthMap,TR>
+        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
            *reinterpret_cast<const LengthMap*>(Base::_length));
       if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
 …
       SetPredMapBase(const TR &b) : TR(b) {}
     };
     /// \brief \ref named-templ-param "Named parameter" for setting
     /// the predecessor map.
 …
       return BellmanFordWizard<SetPredMapBase<T> >(*this);
+    }
     template<class T>
     struct SetDistMapBase : public Base {
 …
       SetDistMapBase(const TR &b) : TR(b) {}
     };
     /// \brief \ref named-templ-param "Named parameter" for setting
     /// the distance map.
 …
       return *this;
+    }
   };
   /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
   /// algorithm.
 …
   /// algorithm.
   ///
   /// This function also has several \ref named-templ-func-param
   /// "named parameters", they are declared as the members of class
+  /// This function also has several \ref named-templ-func-param
+  /// "named parameters", they are declared as the members of class
   /// \ref BellmanFordWizard.
   /// The following examples show how to use these parameters.
 …
   BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
   bellmanFord(const GR& digraph,
               const LEN& length)
+              const LEN& length)
+  {
     return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);

lemon/bfs.h

-                      r891
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
 …
     ///
     /// The type of the map that indicates which nodes are reached.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;

lemon/binomial_heap.h

-                      r929
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       int p=_data[i].parent;
       _data[i].prio=value;
       while( p!=-1 && _comp(value, _data[p].prio) ) {
         _data[i].name=_data[p].name;
 …
   private:
     // Find the minimum of the roots
     int findMin() {
 …
+      }
       if( _data[_head].right_neighbor==-1 ) return;
       int x=_head;
       int x_prev=-1, x_next=_data[x].right_neighbor;
 …
       int curr=_data.size();
       _data.push_back(Store());
       while( p!=-1 || q!=-1 ) {
         if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
 …
+        }
+      }
       _head=_data.back().right_neighbor;
       _data.pop_back();

lemon/bits/array_map.h

-                      r664
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   private:
     // The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;

lemon/bits/default_map.h

-                      r674
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   public:
     typedef DefaultMap<_Graph, _Item, _Value> Map;
     typedef typename Parent::GraphType GraphType;
     typedef typename Parent::Value Value;

lemon/bits/edge_set_extender.h

-                      r732
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     Node oppositeNode(const Node &n, const Arc &e) const {
       if (n == Parent::source(e))
         return Parent::target(e);
+        return Parent::target(e);
       else if(n==Parent::target(e))
         return Parent::source(e);
+        return Parent::source(e);
       else
         return INVALID;
+        return INVALID;
+    }
 …
     // Iterable extensions
     class NodeIt : public Node {
+    class NodeIt : public Node {
       const Digraph* digraph;
     public:
 …
       explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
         _graph.first(static_cast<Node&>(*this));
+      }
       NodeIt(const Digraph& _graph, const Node& node)
         : Node(node), digraph(&_graph) {}
       NodeIt& operator++() {
         digraph->next(*this);
+        return *this;
+      }
     };
     class ArcIt : public Arc {
+        _graph.first(static_cast<Node&>(*this));
+      }
+      NodeIt(const Digraph& _graph, const Node& node)
+        : Node(node), digraph(&_graph) {}
+      NodeIt& operator++() {
+        digraph->next(*this);
+        return *this;
+      }
+    };
+    class ArcIt : public Arc {
       const Digraph* digraph;
     public:
 …
       explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
         _graph.first(static_cast<Arc&>(*this));
+      }
       ArcIt(const Digraph& _graph, const Arc& e) :
         Arc(e), digraph(&_graph) { }
       ArcIt& operator++() {
         digraph->next(*this);
+        return *this;
+      }
     };
     class OutArcIt : public Arc {
+        _graph.first(static_cast<Arc&>(*this));
+      }
+      ArcIt(const Digraph& _graph, const Arc& e) :
+        Arc(e), digraph(&_graph) { }
+      ArcIt& operator++() {
+        digraph->next(*this);
+        return *this;
+      }
+    };
+    class OutArcIt : public Arc {
       const Digraph* digraph;
     public:
 …
       OutArcIt(Invalid i) : Arc(i) { }
       OutArcIt(const Digraph& _graph, const Node& node)
         : digraph(&_graph) {
         _graph.firstOut(*this, node);
+      }
       OutArcIt(const Digraph& _graph, const Arc& arc)
         : Arc(arc), digraph(&_graph) {}
       OutArcIt& operator++() {
         digraph->nextOut(*this);
+        return *this;
+      }
     };
     class InArcIt : public Arc {
+      OutArcIt(const Digraph& _graph, const Node& node)
+        : digraph(&_graph) {
+        _graph.firstOut(*this, node);
+      }
+      OutArcIt(const Digraph& _graph, const Arc& arc)
+        : Arc(arc), digraph(&_graph) {}
+      OutArcIt& operator++() {
+        digraph->nextOut(*this);
+        return *this;
+      }
+    };
+    class InArcIt : public Arc {
       const Digraph* digraph;
     public:
 …
       InArcIt(Invalid i) : Arc(i) { }
       InArcIt(const Digraph& _graph, const Node& node)
         : digraph(&_graph) {
         _graph.firstIn(*this, node);
+      }
       InArcIt(const Digraph& _graph, const Arc& arc) :
         Arc(arc), digraph(&_graph) {}
       InArcIt& operator++() {
         digraph->nextIn(*this);
+        return *this;
+      InArcIt(const Digraph& _graph, const Node& node)
+        : digraph(&_graph) {
+        _graph.firstIn(*this, node);
+      }
+      InArcIt(const Digraph& _graph, const Arc& arc) :
+        Arc(arc), digraph(&_graph) {}
+      InArcIt& operator++() {
+        digraph->nextIn(*this);
+        return *this;
+      }
 …
     // Mappable extension
     template <typename _Value>
     class ArcMap
+    class ArcMap
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
     public:
       explicit ArcMap(const Digraph& _g)
         : Parent(_g) {}
       ArcMap(const Digraph& _g, const _Value& _v)
         : Parent(_g, _v) {}
+      explicit ArcMap(const Digraph& _g)
+        : Parent(_g) {}
+      ArcMap(const Digraph& _g, const _Value& _v)
+        : Parent(_g, _v) {}
       ArcMap& operator=(const ArcMap& cmap) {
         return operator=<ArcMap>(cmap);
+        return operator=<ArcMap>(cmap);
+      }
 …
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
+        return *this;
+      }
 …
       return arc;
+    }
     void clear() {
       notifier(Arc()).clear();
 …
     Node oppositeNode(const Node &n, const Edge &e) const {
       if( n == Parent::u(e))
         return Parent::v(e);
+        return Parent::v(e);
       else if( n == Parent::v(e))
         return Parent::u(e);
+        return Parent::u(e);
       else
         return INVALID;
+        return INVALID;
+    }
 …
     using Parent::notifier;
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
 …
     class NodeIt : public Node {
+    class NodeIt : public Node {
       const Graph* graph;
     public:
 …
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
         _graph.first(static_cast<Node&>(*this));
+      }
       NodeIt(const Graph& _graph, const Node& node)
         : Node(node), graph(&_graph) {}
       NodeIt& operator++() {
         graph->next(*this);
+        return *this;
+      }
     };
     class ArcIt : public Arc {
+        _graph.first(static_cast<Node&>(*this));
+      }
+      NodeIt(const Graph& _graph, const Node& node)
+        : Node(node), graph(&_graph) {}
+      NodeIt& operator++() {
+        graph->next(*this);
+        return *this;
+      }
+    };
+    class ArcIt : public Arc {
       const Graph* graph;
     public:
 …
       explicit ArcIt(const Graph& _graph) : graph(&_graph) {
         _graph.first(static_cast<Arc&>(*this));
+      }
       ArcIt(const Graph& _graph, const Arc& e) :
         Arc(e), graph(&_graph) { }
       ArcIt& operator++() {
         graph->next(*this);
+        return *this;
+      }
     };
     class OutArcIt : public Arc {
+        _graph.first(static_cast<Arc&>(*this));
+      }
+      ArcIt(const Graph& _graph, const Arc& e) :
+        Arc(e), graph(&_graph) { }
+      ArcIt& operator++() {
+        graph->next(*this);
+        return *this;
+      }
+    };
+    class OutArcIt : public Arc {
       const Graph* graph;
     public:
 …
       OutArcIt(Invalid i) : Arc(i) { }
       OutArcIt(const Graph& _graph, const Node& node)
         : graph(&_graph) {
         _graph.firstOut(*this, node);
+      }
       OutArcIt(const Graph& _graph, const Arc& arc)
         : Arc(arc), graph(&_graph) {}
       OutArcIt& operator++() {
         graph->nextOut(*this);
+        return *this;
+      }
     };
     class InArcIt : public Arc {
+      OutArcIt(const Graph& _graph, const Node& node)
+        : graph(&_graph) {
+        _graph.firstOut(*this, node);
+      }
+      OutArcIt(const Graph& _graph, const Arc& arc)
+        : Arc(arc), graph(&_graph) {}
+      OutArcIt& operator++() {
+        graph->nextOut(*this);
+        return *this;
+      }
+    };
+    class InArcIt : public Arc {
       const Graph* graph;
     public:
 …
       InArcIt(Invalid i) : Arc(i) { }
       InArcIt(const Graph& _graph, const Node& node)
         : graph(&_graph) {
         _graph.firstIn(*this, node);
+      }
       InArcIt(const Graph& _graph, const Arc& arc) :
         Arc(arc), graph(&_graph) {}
       InArcIt& operator++() {
         graph->nextIn(*this);
+        return *this;
+      }
     };
     class EdgeIt : public Parent::Edge {
+      InArcIt(const Graph& _graph, const Node& node)
+        : graph(&_graph) {
+        _graph.firstIn(*this, node);
+      }
+      InArcIt(const Graph& _graph, const Arc& arc) :
+        Arc(arc), graph(&_graph) {}
+      InArcIt& operator++() {
+        graph->nextIn(*this);
+        return *this;
+      }
+    };
+    class EdgeIt : public Parent::Edge {
       const Graph* graph;
     public:
 …
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
         _graph.first(static_cast<Edge&>(*this));
+      }
       EdgeIt(const Graph& _graph, const Edge& e) :
         Edge(e), graph(&_graph) { }
       EdgeIt& operator++() {
         graph->next(*this);
+        return *this;
+        _graph.first(static_cast<Edge&>(*this));
+      }
+      EdgeIt(const Graph& _graph, const Edge& e) :
+        Edge(e), graph(&_graph) { }
+      EdgeIt& operator++() {
+        graph->next(*this);
+        return *this;
+      }
 …
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
         _graph.firstInc(*this, direction, n);
+        _graph.firstInc(*this, direction, n);
+      }
       IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
         : graph(&_graph), Edge(ue) {
         direction = (_graph.source(ue) == n);
+        : graph(&_graph), Edge(ue) {
+        direction = (_graph.source(ue) == n);
+      }
       IncEdgeIt& operator++() {
         graph->nextInc(*this, direction);
+        return *this;
+        graph->nextInc(*this, direction);
+        return *this;
+      }
     };
 …
     template <typename _Value>
     class ArcMap
+    class ArcMap
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
     public:
       explicit ArcMap(const Graph& _g)
         : Parent(_g) {}
       ArcMap(const Graph& _g, const _Value& _v)
         : Parent(_g, _v) {}
+      explicit ArcMap(const Graph& _g)
+        : Parent(_g) {}
+      ArcMap(const Graph& _g, const _Value& _v)
+        : Parent(_g, _v) {}
       ArcMap& operator=(const ArcMap& cmap) {
         return operator=<ArcMap>(cmap);
+        return operator=<ArcMap>(cmap);
+      }
 …
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
+        return *this;
+      }
 …
     template <typename _Value>
     class EdgeMap
+    class EdgeMap
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     public:
       explicit EdgeMap(const Graph& _g)
         : Parent(_g) {}
       EdgeMap(const Graph& _g, const _Value& _v)
         : Parent(_g, _v) {}
+      explicit EdgeMap(const Graph& _g)
+        : Parent(_g) {}
+      EdgeMap(const Graph& _g, const _Value& _v)
+        : Parent(_g, _v) {}
       EdgeMap& operator=(const EdgeMap& cmap) {
         return operator=<EdgeMap>(cmap);
+        return operator=<EdgeMap>(cmap);
+      }
 …
       EdgeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
         return *this;
+        return *this;
+      }
 …
       return edge;
+    }
     void clear() {
       notifier(Arc()).clear();
 …
       arc_notifier.clear();
+    }
   };

lemon/bits/solver_bits.h

r566	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/windows.cc

-                      r513
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       GetSystemTime(&time);
       char buf1[11], buf2[9], buf3[5];
           if (GetDateFormat(MY_LOCALE, 0, &time,
+          if (GetDateFormat(MY_LOCALE, 0, &time,
                         ("ddd MMM dd"), buf1, 11) &&
           GetTimeFormat(MY_LOCALE, 0, &time,

lemon/bucket_heap.h

-                      r758
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///
   /// Note that this implementation does not conform to the
   /// \ref concepts::Heap "heap concept" due to the lack of some
+  /// \ref concepts::Heap "heap concept" due to the lack of some
   /// functionality.
   ///

lemon/capacity_scaling.h

-                      r941
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       UNBOUNDED
     };
   private:
 …
   public:
     /// \brief Constant for infinite upper bounds (capacities).
     ///
 …
       CostVector &_pi;
       IntVector &_pred;
       IntVector _proc_nodes;
       CostVector _dist;
     public:
 …
       return *this;
+    }
     /// @}
 …
       _cost.resize(_res_arc_num);
       _supply.resize(_node_num);
       _res_cap.resize(_res_arc_num);
       _pi.resize(_node_num);
 …
         _reverse[bi] = fi;
+      }
       // Reset parameters
       resetParams();
 …
+      }
       if (_sum_supply > 0) return INFEASIBLE;
       // Initialize vectors
       for (int i = 0; i != _root; ++i) {
 …
+        }
+      }
       // Handle GEQ supply type
       if (_sum_supply < 0) {
 …
         for (int i = 0; i != _node_num; ++i) {
           _pi[i] -= pr;
+        }
+      }
+        }
+      }
       return pt;
+    }

lemon/cbc.h

-                      r793
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     int _message_level;
   };

lemon/circulation.h

-                      r891
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \brief The type of supply map.
     ///
     /// The type of the map that stores the signed supply values of the
     /// nodes.
+    /// The type of the map that stores the signed supply values of the
+    /// nodes.
     /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef SM SupplyMap;
 …
      \geq sup(u) \quad \forall u\in V, \f]
      \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
      The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
      zero or negative in order to have a feasible solution (since the sum
 …
      constraints have to be satisfied with equality, i.e. all demands
      have to be satisfied and all supplies have to be used.
      If you need the opposite inequalities in the supply/demand constraints
      (i.e. the total demand is less than the total supply and all the demands
 …
     /// \param graph The digraph the algorithm runs on.
     /// \param lower The lower bounds for the flow values on the arcs.
     /// \param upper The upper bounds (capacities) for the flow values
+    /// \param upper The upper bounds (capacities) for the flow values
     /// on the arcs.
     /// \param supply The signed supply values of the nodes.

lemon/clp.cc

r793	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/clp.h

-                      r793
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     virtual void _messageLevel(MessageLevel);
   public:

lemon/concepts/digraph.h

-                      r833
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       private:
         ///Copy constructor
         NodeMap(const NodeMap& nm) :
+        NodeMap(const NodeMap& nm) :
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator

lemon/concepts/graph.h

-                      r833
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// run properly, of course.
     /// An actual graph implementation like \ref ListGraph or
     /// \ref SmartGraph may have additional functionality.
+    /// \ref SmartGraph may have additional functionality.
     ///
     /// The undirected graphs also fulfill the concept of \ref Digraph
 …
       ///
       /// Undirected graphs should be tagged with \c UndirectedTag.
       ///
+      ///
       /// This tag helps the \c enable_if technics to make compile time
       /// specializations for undirected graphs.
 …
         /// Converison to \c Edge
         /// Converison to \c Edge.
         ///

lemon/concepts/graph_components.h

-                      r833
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \note This class is a template class so that we can use it to
     /// create graph skeleton classes. The reason for this is that \c Node
     /// and \c Arc (or \c Edge) types should \e not derive from the same
+    /// and \c Arc (or \c Edge) types should \e not derive from the same
     /// base class. For \c Node you should instantiate it with character
     /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
 …
       ///
       /// This operator defines an ordering of the items.
       /// It makes possible to use graph item types as key types in
+      /// It makes possible to use graph item types as key types in
       /// associative containers (e.g. \c std::map).
       ///
 …
     /// This class describes the base interface of directed graph types.
     /// All digraph %concepts have to conform to this class.
     /// It just provides types for nodes and arcs and functions
+    /// It just provides types for nodes and arcs and functions
     /// to get the source and the target nodes of arcs.
     class BaseDigraphComponent {
 …
     /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
     ///
     /// This class describes the concept of \c NodeIt, \c ArcIt and
+    /// This class describes the concept of \c NodeIt, \c ArcIt and
     /// \c EdgeIt subtypes of digraph and graph types.
     template <typename GR, typename Item>
 …
       /// next item.
       GraphItemIt& operator++() { return *this; }
       /// \brief Equality operator
       ///
 …
     };
     /// \brief Concept class for \c InArcIt, \c OutArcIt and
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and
     /// \c IncEdgeIt types.
     ///
     /// This class describes the concept of \c InArcIt, \c OutArcIt
+    /// This class describes the concept of \c InArcIt, \c OutArcIt
     /// and \c IncEdgeIt subtypes of digraph and graph types.
     ///
     /// \note Since these iterator classes do not inherit from the same
     /// base class, there is an additional template parameter (selector)
     /// \c sel. For \c InArcIt you should instantiate it with character
+    /// \c sel. For \c InArcIt you should instantiate it with character
     /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
     template <typename GR,
 …
       GraphIncIt(const GraphIncIt& it) : Item(it) {}
       /// \brief Constructor that sets the iterator to the first
+      /// \brief Constructor that sets the iterator to the first
       /// incoming or outgoing arc.
       ///
       /// Constructor that sets the iterator to the first arc
+      /// Constructor that sets the iterator to the first arc
       /// incoming to or outgoing from the given node.
       explicit GraphIncIt(const GR&, const Base&) {}
 …
       /// \brief Return the first edge incident to the given node.
       ///
       /// This function gives back the first edge incident to the given
+      /// This function gives back the first edge incident to the given
       /// node. The bool parameter gives back the direction for which the
       /// source node of the directed arc representing the edge is the
+      /// source node of the directed arc representing the edge is the
       /// given node.
       void firstInc(Edge&, bool&, const Node&) const {}
 …
       /// given node.
       ///
       /// This function gives back the next edge incident to the given
+      /// This function gives back the next edge incident to the given
       /// node. The bool parameter should be used as \c firstInc() use it.
       void nextInc(Edge&, bool&) const {}
 …
     ///
     /// This class describes the concept of standard graph maps, i.e.
     /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
+    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
     /// graph types, which can be used for associating data to graph items.
     /// The standard graph maps must conform to the ReferenceMap concept.
 …
           _Map m1(g);
           _Map m2(g,t);
           // Copy constructor
           // _Map m3(m);
 …
     ///
     /// This class describes the interface of mappable directed graphs.
     /// It extends \ref BaseDigraphComponent with the standard digraph
+    /// It extends \ref BaseDigraphComponent with the standard digraph
     /// map classes, namely \c NodeMap and \c ArcMap.
     /// This concept is part of the Digraph concept.
 …
     ///
     /// This class describes the interface of mappable undirected graphs.
     /// It extends \ref MappableDigraphComponent with the standard graph
+    /// It extends \ref MappableDigraphComponent with the standard graph
     /// map class for edges (\c EdgeMap).
     /// This concept is part of the Graph concept.
 …
     ///
     /// This class describes the interface of extendable directed graphs.
     /// It extends \ref BaseDigraphComponent with functions for adding
+    /// It extends \ref BaseDigraphComponent with functions for adding
     /// nodes and arcs to the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
 …
     ///
     /// This class describes the interface of extendable undirected graphs.
     /// It extends \ref BaseGraphComponent with functions for adding
+    /// It extends \ref BaseGraphComponent with functions for adding
     /// nodes and edges to the graph.
     /// This concept requires \ref AlterableGraphComponent.
 …
     ///
     /// This class describes the interface of erasable directed graphs.
     /// It extends \ref BaseDigraphComponent with functions for removing
+    /// It extends \ref BaseDigraphComponent with functions for removing
     /// nodes and arcs from the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
 …
       /// \brief Erase a node from the digraph.
       ///
       /// This function erases the given node from the digraph and all arcs
+      /// This function erases the given node from the digraph and all arcs
       /// connected to the node.
       void erase(const Node&) {}
 …
     ///
     /// This class describes the interface of erasable undirected graphs.
     /// It extends \ref BaseGraphComponent with functions for removing
+    /// It extends \ref BaseGraphComponent with functions for removing
     /// nodes and edges from the graph.
     /// This concept requires \ref AlterableGraphComponent.

lemon/concepts/heap.h

-                      r883
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #else
       explicit Heap(ItemIntMap&) {}
 #endif
+#endif
       /// \brief Constructor.
 …
 #else
       explicit Heap(ItemIntMap&, const CMP&) {}
 #endif
+#endif
       /// \brief The number of items stored in the heap.
 …
 #else
       void push(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Return the item having minimum priority.
 …
 #else
       void erase(const Item&) {}
 #endif
+#endif
       /// \brief The priority of the given item.
 …
 #else
       Prio operator[](const Item&) const { return Prio(); }
 #endif
+#endif
       /// \brief Set the priority of an item or insert it, if it is
 …
 #else
       void set(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Decrease the priority of an item to the given value.
 …
 #else
       void decrease(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Increase the priority of an item to the given value.
 …
 #else
       void increase(const Item&, const Prio&) {}
 #endif
+#endif
       /// \brief Return the state of an item.
 …
 #else
       State state(const Item&) const { return PRE_HEAP; }
 #endif
+#endif
       /// \brief Set the state of an item in the heap.
 …
 #else
       void state(const Item&, State) {}
 #endif
+#endif

lemon/connectivity.h

-                      r695
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// \return \c true if the digraph is strongly connected.
   /// \note By definition, the empty digraph is strongly connected.
   ///
+  ///
   /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   /// \see connected()
 …
   /// \ingroup graph_properties
   ///
   /// \brief Count the number of strongly connected components of a
+  /// \brief Count the number of strongly connected components of a
   /// directed graph
   ///
 …
   /// \brief Check whether an undirected graph is bi-node-connected.
   ///
   /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is
   /// bi-node-connected, i.e. any two edges are on same circle.
   ///
 …
   /// \ingroup graph_properties
   ///
   /// \brief Count the number of bi-node-connected components of an
+  /// \brief Count the number of bi-node-connected components of an
   /// undirected graph.
   ///
 …
   /// \retval compMap A writable edge map. The values will be set from 0
   /// to the number of the bi-node-connected components minus one. Each
   /// value of the map will be set exactly once, and the values of a
+  /// value of the map will be set exactly once, and the values of a
   /// certain component will be set continuously.
   /// \return The number of bi-node-connected components.
 …
   ///
   /// \param graph The undirected graph.
   /// \retval cutMap A writable node map. The values will be set to
+  /// \retval cutMap A writable node map. The values will be set to
   /// \c true for the nodes that separate two or more components
   /// (exactly once for each cut node), and will not be changed for
 …
   /// \brief Check whether an undirected graph is bi-edge-connected.
   ///
   /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is
   /// bi-edge-connected, i.e. any two nodes are connected with at least
   /// two edge-disjoint paths.
 …
   ///
   /// This function finds the bi-edge-connected cut edges in the given
   /// undirected graph.
+  /// undirected graph.
   ///
   /// The bi-edge-connected components are the classes of an equivalence
 …
   /// \param digraph The digraph.
   /// \retval order A readable and writable node map. The values will be
   /// set from 0 to the number of the nodes in the digraph minus one.
+  /// set from 0 to the number of the nodes in the digraph minus one.
   /// Each value of the map will be set exactly once, and the values will
   /// be set descending order.

lemon/core.h

-                      r718
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   protected:
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type
+    {
       typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 …
     };
   protected:
+  protected:
     const Digraph &_g;

lemon/cost_scaling.h

-                      r941
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// push/augment and relabel operations for finding a \ref min_cost_flow
   /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation,
   /// \ref goldberg97efficient, \ref bunnagel98efficient.
+  /// \ref goldberg97efficient, \ref bunnagel98efficient.
   /// It is a highly efficient primal-dual solution method, which
   /// can be viewed as the generalization of the \ref Preflow
 …
       /// paths from a node with excess to a node with deficit.
       AUGMENT,
       /// Partial augment operations are used, i.e. flow is moved on
+      /// Partial augment operations are used, i.e. flow is moved on
       /// admissible paths started from a node with excess, but the
       /// lengths of these paths are limited. This method can be viewed
 …
   private:
     template <typename KT, typename VT>
     class StaticVectorMap {
 …
       typedef KT Key;
       typedef VT Value;
       StaticVectorMap(std::vector<Value>& v) : _v(v) {}
       const Value& operator[](const Key& key) const {
         return _v[StaticDigraph::id(key)];
 …
         return _v[StaticDigraph::id(key)];
+      }
       void set(const Key& key, const Value& val) {
         _v[StaticDigraph::id(key)] = val;
 …
     IntVector _rank;
     int _max_rank;
     // Data for a StaticDigraph structure
     typedef std::pair<int, int> IntPair;
 …
     LargeCostArcMap _cost_map;
     LargeCostNodeMap _pi_map;
   public:
     /// \brief Constant for infinite upper bounds (capacities).
     ///
 …
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
         "The cost type of CostScaling must be signed");
       // Reset data structures
       reset();
 …
       return *this;
+    }
     /// @}
 …
         _scost[j] = 0;
         _scost[_reverse[j]] = 0;
+      }
+      }
       _have_lower = false;
       return *this;
 …
       _scost.resize(_res_arc_num);
       _supply.resize(_res_node_num);
       _res_cap.resize(_res_arc_num);
       _cost.resize(_res_arc_num);
 …
         _reverse[bi] = fi;
+      }
       // Reset parameters
       resetParams();
 …
+      }
       if (_sum_supply > 0) return INFEASIBLE;
       // Initialize vectors
 …
         _excess[i] = _supply[i];
+      }
       // Remove infinite upper bounds and check negative arcs
       const Value MAX = std::numeric_limits<Value>::max();
 …
+        }
+      }
       return OPTIMAL;
+    }
 …
       const int MAX_PATH_LENGTH = 4;
       // Initialize data structures for buckets
+      // Initialize data structures for buckets
       _max_rank = _alpha * _res_node_num;
       _buckets.resize(_max_rank);
 …
       _bucket_prev.resize(_res_node_num + 1);
       _rank.resize(_res_node_num + 1);
       // Execute the algorithm
       switch (method) {
 …
+      }
+    }
     // Initialize a cost scaling phase
     void initPhase() {
 …
+        }
+      }
       // Find active nodes (i.e. nodes with positive excess)
       for (int u = 0; u != _res_node_num; ++u) {
 …
+      }
+    }
     // Early termination heuristic
     bool earlyTermination() {
 …
     void globalUpdate() {
       int bucket_end = _root + 1;
       // Initialize buckets
       for (int r = 0; r != _max_rank; ++r) {
 …
           int u = _buckets[r];
           _buckets[r] = _bucket_next[u];
           // Search the incomming arcs of u
           LargeCost pi_u = _pi[u];
 …
                 if (nrc < LargeCost(_max_rank))
                   new_rank_v = r + 1 + int(nrc);
                 // Change the rank of v
                 if (new_rank_v < old_rank_v) {
                   _rank[v] = new_rank_v;
                   _next_out[v] = _first_out[v];
                   // Remove v from its old bucket
                   if (old_rank_v < _max_rank) {
 …
+                    }
+                  }
                   // Insert v to its new bucket
                   _bucket_next[v] = _buckets[new_rank_v];
 …
         if (total_excess <= 0) break;
+      }
       // Relabel nodes
       for (int u = 0; u != _res_node_num; ++u) {
 …
         (_res_node_num + _sup_node_num * _sup_node_num));
       int next_update_limit = global_update_freq;
       int relabel_cnt = 0;
       // Perform cost scaling phases
       std::vector<int> path;
 …
           if (earlyTermination()) break;
+        }
         // Initialize current phase
         initPhase();
         // Perform partial augment and relabel operations
         while (true) {
 …
       int relabel_cnt = 0;
       // Perform cost scaling phases
       BoolVector hyper(_res_node_num, false);
 …
           if (earlyTermination()) break;
+        }
         // Initialize current phase
         initPhase();
 …
           last_out = _first_out[n+1];
           pi_n = _pi[n];
           // Perform push operations if there are admissible arcs
           if (_excess[n] > 0) {
 …
                 LargeCost pi_t = _pi[t];
                 for (int ta = _next_out[t]; ta != last_out_t; ++ta) {
                   if (_res_cap[ta] > 0 &&
+                  if (_res_cap[ta] > 0 &&
                       _cost[ta] + pi_t - _pi[_target[ta]] < 0)
                     ahead += _res_cap[ta];
 …
             ++relabel_cnt;
+          }
           // Remove nodes that are not active nor hyper
         remove_nodes:
 …
             _active_nodes.pop_front();
+          }
           // Global update heuristic
           if (relabel_cnt >= next_update_limit) {

lemon/cplex.cc

-                      r793
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
+  }
   int CplexBase::_addRow(Value lb, ExprIterator b,
+  int CplexBase::_addRow(Value lb, ExprIterator b,
                          ExprIterator e, Value ub) {
     int i = CPXgetnumrows(cplexEnv(), _prob);
 …
   void CplexBase::_applyMessageLevel() {
     CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
+    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
                    _message_enabled ? CPX_ON : CPX_OFF);
+  }

lemon/cycle_canceling.h

-                      r942
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     TEMPLATE_DIGRAPH_TYPEDEFS(GR);
     typedef std::vector<int> IntVector;
     typedef std::vector<double> DoubleVector;
 …
   private:
     template <typename KT, typename VT>
     class StaticVectorMap {
 …
       typedef KT Key;
       typedef VT Value;
       StaticVectorMap(std::vector<Value>& v) : _v(v) {}
       const Value& operator[](const Key& key) const {
         return _v[StaticDigraph::id(key)];
 …
         return _v[StaticDigraph::id(key)];
+      }
       void set(const Key& key, const Value& val) {
         _v[StaticDigraph::id(key)] = val;
 …
     CostArcMap _cost_map;
     CostNodeMap _pi_map;
   public:
     /// \brief Constant for infinite upper bounds (capacities).
     ///
 …
       return *this;
+    }
     /// @}
 …
         _cost[j] = 0;
         _cost[_reverse[j]] = 0;
+      }
+      }
       _have_lower = false;
       return *this;
 …
       _cost.resize(_res_arc_num);
       _supply.resize(_res_node_num);
       _res_cap.resize(_res_arc_num);
       _pi.resize(_res_node_num);
 …
         _reverse[bi] = fi;
+      }
       // Reset parameters
       resetParams();
 …
+      }
       if (_sum_supply > 0) return INFEASIBLE;
       // Initialize vectors
 …
+      }
       ValueVector excess(_supply);
       // Remove infinite upper bounds and check negative arcs
       const Value MAX = std::numeric_limits<Value>::max();
 …
+        }
+      }
       return OPTIMAL;
+    }
     // Build a StaticDigraph structure containing the current
     // residual network
 …
       const int BF_FIRST_LIMIT  = 2;
       const double BF_LIMIT_FACTOR = 1.5;
       typedef StaticVectorMap<StaticDigraph::Arc, Value> FilterMap;
       typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;
 …
         ::template SetDistMap<CostNodeMap>
         ::template SetPredMap<PredMap>::Create BF;
       // Build the residual network
       _arc_vec.clear();
 …
       typedef typename HowardMmc<StaticDigraph, CostArcMap>
         ::template SetPath<SPath>::Create MMC;
       SPath cycle;
       MMC mmc(_sgr, _cost_map);
 …
+        }
         // Rebuild the residual network
+        // Rebuild the residual network
         buildResidualNetwork();
+      }
 …
           Cost cycle_cost = mmc.cycleCost();
           int cycle_size = mmc.cycleSize();
           // Compute feasible potentials for the current epsilon
           for (int i = 0; i != int(_cost_vec.size()); ++i) {
 …
             pi[u] = static_cast<double>(_pi[u]) / cycle_size;
+          }
           iter = limit;
+        }

lemon/dfs.h

-                      r891
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
 …
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
 …
     ///The type of the map that indicates which nodes are reached.
+    ///It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must conform to
+    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
 …
     ///
     /// The type of the map that indicates which nodes are reached.
+    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must conform to the
+    /// \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;

lemon/dijkstra.h

r891	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/dimacs.h

-                      r631
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///This function starts seeking the beginning of the given file for the
   ///problem type and size info.
+  ///problem type and size info.
   ///The found data is returned in a special struct that can be evaluated
   ///and passed to the appropriate reader function.
 …
         std::numeric_limits<Capacity>::infinity() :
         std::numeric_limits<Capacity>::max();
     while (is >> c) {
       switch (c) {
 …
           e = g.addArc(nodes[i], nodes[j]);
           capacity.set(e, _cap);
+        }
+        }
         else if (desc.type==DimacsDescriptor::MAX) {
           is >> i >> j >> _cap;
 …
     g.addArc(s,t);
+  }
   /// \brief DIMACS plain (di)graph reader function.
   ///
   /// This function reads a plain (di)graph without any designated nodes
   /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
+  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
   /// DIMACS files having a line starting with
   /// \code
 …
       nodes[k] = g.addNode();
+    }
     while (is >> c) {
       switch (c) {

lemon/edge_set.h

r834	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/euler.h

-                      r695
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /// \ingroup graph_properties
 /// \file
 /// \brief Euler tour iterators and a function for checking the \e Eulerian
+/// \brief Euler tour iterators and a function for checking the \e Eulerian
 /// property.
 ///
 …
   ///
   ///For example, if the given digraph has an Euler tour (i.e it has only one
   ///non-trivial component and the in-degree is equal to the out-degree
+  ///non-trivial component and the in-degree is equal to the out-degree
   ///for all nodes), then the following code will put the arcs of \c g
   ///to the vector \c et according to an Euler tour of \c g.
 …
   ///and \c Edge types of the graph.
   ///
   ///For example, if the given graph has an Euler tour (i.e it has only one
+  ///For example, if the given graph has an Euler tour (i.e it has only one
   ///non-trivial component and the degree of each node is even),
   ///the following code will print the arc IDs according to an
 …
   ///  }
   ///\endcode
   ///Although this iterator is for undirected graphs, it still returns
+  ///Although this iterator is for undirected graphs, it still returns
   ///arcs in order to indicate the direction of the tour.
   ///(But arcs convert to edges, of course.)
 …
     /// Postfix incrementation.
     ///
     ///\warning This incrementation returns an \c Arc (which converts to
+    ///\warning This incrementation returns an \c Arc (which converts to
     ///an \c Edge), not an \ref EulerIt, as one may expect.
     Arc operator++(int)

lemon/fractional_matching.h

-                      r955
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \brief Run the algorithm.
     ///
     /// This method runs the \c %MaxWeightedPerfectFractionalMatching
+    /// This method runs the \c %MaxWeightedPerfectFractionalMatching
     /// algorithm.
     ///

lemon/full_graph.h

-                      r834
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \brief Returns the node with the given index.
     ///
     /// Returns the node with the given index. Since this structure is
+    /// Returns the node with the given index. Since this structure is
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
 …
     /// \brief Returns the index of the given node.
     ///
     /// Returns the index of the given node. Since this structure is
+    /// Returns the index of the given node. Since this structure is
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
 …
     /// \brief Returns the node with the given index.
     ///
     /// Returns the node with the given index. Since this structure is
+    /// Returns the node with the given index. Since this structure is
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.
 …
     /// \brief Returns the index of the given node.
     ///
     /// Returns the index of the given node. Since this structure is
+    /// Returns the index of the given node. Since this structure is
     /// completely static, the nodes can be indexed with integers from
     /// the range <tt>[0..nodeNum()-1]</tt>.

lemon/glpk.cc

-                      r793
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
+  }
   int GlpkBase::_addRow(Value lo, ExprIterator b,
+  int GlpkBase::_addRow(Value lo, ExprIterator b,
                         ExprIterator e, Value up) {
     int i = glp_add_rows(lp, 1);
 …
       } else {
         glp_set_row_bnds(lp, i, GLP_UP, lo, up);
+      }
+      }
     } else {
       if (up == INF) {
         glp_set_row_bnds(lp, i, GLP_LO, lo, up);
       } else if (lo != up) {
+      } else if (lo != up) {
         glp_set_row_bnds(lp, i, GLP_DB, lo, up);
       } else {

lemon/glpk.h

-                      r902
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     class VoidPtr {
     private:
       void *_ptr;
+      void *_ptr;
     public:
       VoidPtr() : _ptr(0) {}
 …
       template <typename T>
       VoidPtr& operator=(T* ptr) {
         _ptr = reinterpret_cast<void*>(ptr);
+      VoidPtr& operator=(T* ptr) {
+        _ptr = reinterpret_cast<void*>(ptr);
         return *this;
+      }
 …
+      }
     };
     static FreeEnvHelper freeEnvHelper;
   protected:
     int _message_level;
   public:

lemon/gomory_hu.h

-                      r833
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /// \ingroup min_cut
 /// \file
+/// \file
 /// \brief Gomory-Hu cut tree in graphs.
 …
   /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   /// may contain edges which are not in the original graph. It has the
   /// property that the minimum capacity edge of the path between two nodes
+  /// property that the minimum capacity edge of the path between two nodes
   /// in this tree has the same weight as the minimum cut in the graph
   /// between these nodes. Moreover the components obtained by removing
 …
   /// Therefore once this tree is computed, the minimum cut between any pair
   /// of nodes can easily be obtained.
   ///
+  ///
   /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
   /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
 …
 #ifdef DOXYGEN
   template <typename GR,
             typename CAP>
+            typename CAP>
 #else
   template <typename GR,
             typename CAP = typename GR::template EdgeMap<int> >
+            typename CAP = typename GR::template EdgeMap<int> >
 #endif
   class GomoryHu {
 …
     /// The value type of capacities
     typedef typename Capacity::Value Value;
   private:
 …
     void createStructures() {
       if (!_pred) {
         _pred = new typename Graph::template NodeMap<Node>(_graph);
+        _pred = new typename Graph::template NodeMap<Node>(_graph);
+      }
       if (!_weight) {
         _weight = new typename Graph::template NodeMap<Value>(_graph);
+        _weight = new typename Graph::template NodeMap<Value>(_graph);
+      }
       if (!_order) {
         _order = new typename Graph::template NodeMap<int>(_graph);
+        _order = new typename Graph::template NodeMap<int>(_graph);
+      }
+    }
 …
     void destroyStructures() {
       if (_pred) {
         delete _pred;
+        delete _pred;
+      }
       if (_weight) {
         delete _weight;
+        delete _weight;
+      }
       if (_order) {
         delete _order;
+      }
+    }
+        delete _order;
+      }
+    }
   public:
 …
     /// \param graph The undirected graph the algorithm runs on.
     /// \param capacity The edge capacity map.
     GomoryHu(const Graph& graph, const Capacity& capacity)
+    GomoryHu(const Graph& graph, const Capacity& capacity)
       : _graph(graph), _capacity(capacity),
+        _pred(0), _weight(0), _order(0)
+        _pred(0), _weight(0), _order(0)
+    {
       checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
 …
   private:
     // Initialize the internal data structures
     void init() {
 …
+      }
       (*_pred)[_root] = INVALID;
       (*_weight)[_root] = std::numeric_limits<Value>::max();
+      (*_weight)[_root] = std::numeric_limits<Value>::max();
+    }
 …
       for (NodeIt n(_graph); n != INVALID; ++n) {
         if (n == _root) continue;
         Node pn = (*_pred)[n];
         fa.source(n);
         fa.target(pn);
         fa.runMinCut();
         (*_weight)[n] = fa.flowValue();
         for (NodeIt nn(_graph); nn != INVALID; ++nn) {
           if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
             (*_pred)[nn] = n;
+          }
+        }
         if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
           (*_pred)[n] = (*_pred)[pn];
           (*_pred)[pn] = n;
           (*_weight)[n] = (*_weight)[pn];
           (*_weight)[pn] = fa.flowValue();
+        }
+        if (n == _root) continue;
+        Node pn = (*_pred)[n];
+        fa.source(n);
+        fa.target(pn);
+        fa.runMinCut();
+        (*_weight)[n] = fa.flowValue();
+        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
+          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
+            (*_pred)[nn] = n;
+          }
+        }
+        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
+          (*_pred)[n] = (*_pred)[pn];
+          (*_pred)[pn] = n;
+          (*_weight)[n] = (*_weight)[pn];
+          (*_weight)[pn] = fa.flowValue();
+        }
+      }
 …
       for (NodeIt n(_graph); n != INVALID; ++n) {
         std::vector<Node> st;
         Node nn = n;
         while ((*_order)[nn] == -1) {
           st.push_back(nn);
           nn = (*_pred)[nn];
+        }
         while (!st.empty()) {
           (*_order)[st.back()] = index++;
           st.pop_back();
+        }
+        std::vector<Node> st;
+        Node nn = n;
+        while ((*_order)[nn] == -1) {
+          st.push_back(nn);
+          nn = (*_pred)[nn];
+        }
+        while (!st.empty()) {
+          (*_order)[st.back()] = index++;
+          st.pop_back();
+        }
+      }
+    }
 …
     ///\name Execution Control
     ///@{
 …
       start();
+    }
     /// @}
 …
     /// Gomory-Hu tree.
     ///
     /// This function returns the weight of the predecessor edge of the
+    /// This function returns the weight of the predecessor edge of the
     /// given node in the Gomory-Hu tree.
     /// If \c node is the root of the tree, the result is undefined.
 …
     ///
     /// This function returns the minimum cut value between the nodes
     /// \c s and \c t.
+    /// \c s and \c t.
     /// It finds the nearest common ancestor of the given nodes in the
     /// Gomory-Hu tree and calculates the minimum weight edge on the
 …
       Node sn = s, tn = t;
       Value value = std::numeric_limits<Value>::max();
       while (sn != tn) {
         if ((*_order)[sn] < (*_order)[tn]) {
           if ((*_weight)[tn] <= value) value = (*_weight)[tn];
           tn = (*_pred)[tn];
         } else {
           if ((*_weight)[sn] <= value) value = (*_weight)[sn];
           sn = (*_pred)[sn];
+        }
+        if ((*_order)[sn] < (*_order)[tn]) {
+          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
+          tn = (*_pred)[tn];
+        } else {
+          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
+          sn = (*_pred)[sn];
+        }
+      }
       return value;
 …
       Node rn = INVALID;
       Value value = std::numeric_limits<Value>::max();
       while (sn != tn) {
         if ((*_order)[sn] < (*_order)[tn]) {
           if ((*_weight)[tn] <= value) {
             rn = tn;
+        if ((*_order)[sn] < (*_order)[tn]) {
+          if ((*_weight)[tn] <= value) {
+            rn = tn;
             s_root = false;
             value = (*_weight)[tn];
+          }
           tn = (*_pred)[tn];
         } else {
           if ((*_weight)[sn] <= value) {
             rn = sn;
+            value = (*_weight)[tn];
+          }
+          tn = (*_pred)[tn];
+        } else {
+          if ((*_weight)[sn] <= value) {
+            rn = sn;
             s_root = true;
             value = (*_weight)[sn];
+          }
           sn = (*_pred)[sn];
+        }
+            value = (*_weight)[sn];
+          }
+          sn = (*_pred)[sn];
+        }
+      }
 …
       std::vector<Node> st;
       for (NodeIt n(_graph); n != INVALID; ++n) {
         st.clear();
+        st.clear();
         Node nn = n;
         while (!reached[nn]) {
           st.push_back(nn);
           nn = (*_pred)[nn];
+        }
         while (!st.empty()) {
           cutMap.set(st.back(), cutMap[nn]);
           st.pop_back();
+        }
+      }
+        while (!reached[nn]) {
+          st.push_back(nn);
+          nn = (*_pred)[nn];
+        }
+        while (!st.empty()) {
+          cutMap.set(st.back(), cutMap[nn]);
+          st.pop_back();
+        }
+      }
       return value;
+    }
 …
     /// Iterate on the nodes of a minimum cut
     /// This iterator class lists the nodes of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
 …
+      }
     };
     friend class MinCutEdgeIt;
     /// Iterate on the edges of a minimum cut
     /// This iterator class lists the edges of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
 …
+          }
+      }
     public:
       /// Constructor
 …
+      }
       /// Postfix incrementation
       /// Postfix incrementation.
       ///

lemon/graph_to_eps.h

r909	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/hao_orlin.h

-                      r934
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /// \brief Implementation of the Hao-Orlin algorithm.
 ///
 /// Implementation of the Hao-Orlin algorithm for finding a minimum cut
+/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
 /// in a digraph.
 …
   ///
   /// This class implements the Hao-Orlin algorithm for finding a minimum
   /// value cut in a directed graph \f$D=(V,A)\f$.
+  /// value cut in a directed graph \f$D=(V,A)\f$.
   /// It takes a fixed node \f$ source \in V \f$ and
   /// consists of two phases: in the first phase it determines a
 …
   /// For an undirected graph you can run just the first phase of the
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
   /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
+  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
   /// time. It is implemented in the NagamochiIbaraki algorithm class.
   ///
 …
   class HaoOrlin {
   public:
     /// The digraph type of the algorithm
     typedef GR Digraph;
 …
     ///
     /// This function initializes the internal data structures. It creates
     /// the maps and some bucket structures for the algorithm.
+    /// the maps and some bucket structures for the algorithm.
     /// The given node is used as the source node for the push-relabel
     /// algorithm.
 …
     /// \brief Run the algorithm.
     ///
     /// This function runs the algorithm. It uses the given \c source node,
+    /// This function runs the algorithm. It uses the given \c source node,
     /// finds a proper \c target node and then calls the \ref init(),
     /// \ref calculateOut() and \ref calculateIn().
 …
     /// The result of the %HaoOrlin algorithm
     /// can be obtained using these functions.\n
     /// \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \ref run(), \ref calculateOut() or \ref calculateIn()
     /// should be called before using them.
 …
     /// This function returns the value of the minimum cut.
     ///
     /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
     /// must be called before using this function.
     Value minCutValue() const {
 …
     /// \return The value of the minimum cut.
     ///
     /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
     /// must be called before using this function.
     template <typename CutMap>

lemon/hartmann_orlin_mmc.h

-                      r942
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       init();
       findComponents();
       // Find the minimum cycle mean in the components
       for (int comp = 0; comp < _comp_num; ++comp) {
         if (!initComponent(comp)) continue;
         processRounds();
         // Update the best cycle (global minimum mean cycle)
         if ( _curr_found && (!_best_found ||
+        if ( _curr_found && (!_best_found ||
              _curr_cost * _best_size < _best_cost * _curr_size) ) {
           _best_found = true;
 …
       if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
         return false;
+      }
+      }
       for (int i = 0; i < n; ++i) {
         _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
 …
+      }
+    }
     // Check early termination
     bool checkTermination(int k) {
 …
       int size;
       Node u;
       // Search for cycles that are already found
       _curr_found = false;
 …
           level[u] = Pair(i, j);
           if (j != 0) {
             u = _gr.source(_data[u][j].pred);
+          }
+            u = _gr.source(_data[u][j].pred);
+          }
+        }
+      }

lemon/howard_mmc.h

-                      r942
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
+  {
   public:
     /// The type of the digraph
     typedef typename TR::Digraph Digraph;
 …
     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     // The digraph the algorithm runs on
     const Digraph &_gr;
 …
     std::vector<Node>* _nodes;
     typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;
     // Queue used for BFS search
     std::vector<Node> _queue;
 …
     Tolerance _tolerance;
     // Infinite constant
     const LargeCost INF;
   public:
     /// \name Named Template Parameters
     /// @{
 …
       typedef HowardMmc<GR, CM, SetPathTraits<T> > Create;
     };
     /// @}
 …
       init();
       findComponents();
       // Find the minimum cycle mean in the components
       for (int comp = 0; comp < _comp_num; ++comp) {
 …
       _cycle_path->clear();
+    }
     // Find strongly connected components and initialize _comp_nodes
     // and _in_arcs

lemon/karp_mmc.h

-                      r942
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     Tolerance _tolerance;
     // Infinite constant
     const LargeCost INF;
 …
       init();
       findComponents();
       // Find the minimum cycle mean in the components
       for (int comp = 0; comp < _comp_num; ++comp) {
 …
       if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
         return false;
+      }
+      }
       for (int i = 0; i < n; ++i) {
         _data[(*_nodes)[i]].resize(n + 1, PathData(INF));

lemon/lgf_reader.h

-                      r833
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
     template <typename TDGR>
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
+    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
                                              const std::string& fn);
     template <typename TDGR>
 …
   };
   /// \ingroup lemon_io
   ///
 …
   /// This function just returns a \ref DigraphReader class.
   ///
   /// With this function a digraph can be read from an
+  /// With this function a digraph can be read from an
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is network flow problem on a
 …
   template <typename GR>
   class GraphReader;
   template <typename TGR>
   GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
 …
     friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
+    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
 …
   /// \brief Return a \ref GraphReader class
   ///
   /// This function just returns a \ref GraphReader class.
   ///
   /// With this function a graph can be read from an
+  /// This function just returns a \ref GraphReader class.
+  ///
+  /// With this function a graph can be read from an
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is weighted matching problem on a

lemon/lgf_writer.h

-                      r646
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   template <typename TDGR>
   DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
                                    std::ostream& os = std::cout);
   template <typename TDGR>
 …
     template <typename TDGR>
     friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
                                              std::ostream& os);
     template <typename TDGR>
 …
   /// \brief Return a \ref DigraphWriter class
   ///
   /// This function just returns a \ref DigraphWriter class.
+  /// This function just returns a \ref DigraphWriter class.
   ///
   /// With this function a digraph can be write to a file or output
 …
   /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   template <typename TDGR>
   DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
                                     const std::string& fn) {
     DigraphWriter<TDGR> tmp(digraph, fn);
 …
     friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph,
+    friend GraphWriter<TGR> graphWriter(const TGR& graph,
                                         const std::string& fn);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
     GraphWriter(GraphWriter& other)
       : _os(other._os), local_os(other.local_os), _graph(other._graph),
 …
   /// \brief Return a \ref GraphWriter class
   ///
   /// This function just returns a \ref GraphWriter class.
+  /// This function just returns a \ref GraphWriter class.
   ///
   /// With this function a graph can be write to a file or output

lemon/list_graph.h

-                      r835
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     ///invalidated for the outgoing arcs of node \c v and \c InArcIt
     ///iterators are invalidated for the incomming arcs of \c v.
     ///Moreover all iterators referencing node \c v or the removed
+    ///Moreover all iterators referencing node \c v or the removed
     ///loops are also invalidated. Other iterators remain valid.
     ///
 …
     /// restore() function.
     ///
     /// \note After a state is restored, you cannot restore a later state,
+    /// \note After a state is restored, you cannot restore a later state,
     /// i.e. you cannot add the removed nodes and arcs again using
     /// another Snapshot instance.
 …
     /// or changeV(), thus all edge and arc iterators whose base node is
     /// \c b are invalidated.
     /// Moreover all iterators referencing node \c b or the removed
+    /// Moreover all iterators referencing node \c b or the removed
     /// loops are also invalidated. Other iterators remain valid.
     ///
 …
     /// using the restore() function.
     ///
     /// \note After a state is restored, you cannot restore a later state,
+    /// \note After a state is restored, you cannot restore a later state,
     /// i.e. you cannot add the removed nodes and edges again using
     /// another Snapshot instance.

lemon/lp.h

-                      r674
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #elif LEMON_HAVE_CLP
 # define DEFAULT_LP CLP
   typedef ClpLp Lp;
+  typedef ClpLp Lp;
 #endif
 #endif

lemon/lp_base.cc

r557	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/lp_base.h

-                      r903
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       MESSAGE_VERBOSE
     };
     ///The floating point type used by the solver
 …
       typedef True LpCol;
       /// Default constructor
       /// \warning The default constructor sets the Col to an
       /// undefined value.
       Col() {}
       /// Invalid constructor \& conversion.
       /// This constructor initializes the Col to be invalid.
       /// \sa Invalid for more details.
+      /// \sa Invalid for more details.
       Col(const Invalid&) : _id(-1) {}
       /// Equality operator
 …
     public:
       /// Default constructor
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       ColIt() {}
       /// Sets the iterator to the first Col
       /// Sets the iterator to the first Col.
       ///
 …
+      }
       /// Invalid constructor \& conversion
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       ColIt(const Invalid&) : Col(INVALID) {}
       /// Next column
       /// Assign the iterator to the next column.
       ///
 …
       typedef True LpRow;
       /// Default constructor
       /// \warning The default constructor sets the Row to an
       /// undefined value.
       Row() {}
       /// Invalid constructor \& conversion.
       /// This constructor initializes the Row to be invalid.
       /// \sa Invalid for more details.
+      /// \sa Invalid for more details.
       Row(const Invalid&) : _id(-1) {}
       /// Equality operator
 …
       bool operator==(Row r) const  {return _id == r._id;}
       /// Inequality operator
       /// \sa operator==(Row r)
       ///
 …
     public:
       /// Default constructor
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       RowIt() {}
       /// Sets the iterator to the first Row
       /// Sets the iterator to the first Row.
       ///
 …
+      }
       /// Invalid constructor \& conversion
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       RowIt(const Invalid&) : Row(INVALID) {}
       /// Next row
       /// Assign the iterator to the next row.
       ///
 …
       typedef True SolverExpr;
       /// Default constructor
       /// Construct an empty expression, the coefficients and
       /// the constant component are initialized to zero.
 …
       ///Iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         const Value& operator*() const { return _it->second; }
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
       /// Const iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
       typedef True SolverExpr;
       /// Default constructor
       /// Construct an empty expression, the coefficients are
       /// initialized to zero.
 …
+      }
       /// \brief Removes the coefficients which's absolute value does
       /// not exceed \c epsilon.
+      /// not exceed \c epsilon.
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
 …
       ///Iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
       ///Iterator over the expression
       ///The iterator iterates over the terms of the expression.
       ///
+      ///The iterator iterates over the terms of the expression.
+      ///
       ///\code
       ///double s=0;
 …
         /// Sets the iterator to the first term
         /// Sets the iterator to the first term of the expression.
         ///
 …
         /// Next term
         /// Assign the iterator to the next term.
         ///
 …
       Row r;
       c.expr().simplify();
       r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
+      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
                                 ExprIterator(c.expr().comps.begin(), cols),
                                 ExprIterator(c.expr().comps.end(), cols),
 …
     enum VarStatus {
       /// The variable is in the basis
       BASIC,
+      BASIC,
       /// The variable is free, but not basic
       FREE,
       /// The variable has active lower bound
+      /// The variable has active lower bound
       LOWER,
       /// The variable has active upper bound
 …
+    }
     /// Returns a component of the primal ray
     /// The primal ray is solution of the modified primal problem,
     /// where we change each finite bound to 0, and we looking for a
 …
     /// Returns a component of the dual ray
     /// The dual ray is solution of the modified primal problem, where
     /// we change each finite bound to 0 (i.e. the objective function
 …
+    }
     ///The value of the objective function
     ///\return
     ///- \ref INF or -\ref INF means either infeasibility or unboundedness

lemon/lp_skeleton.cc

r793	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/lp_skeleton.h

-                      r793
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 ///\file
 ///\brief Skeleton file to implement LP/MIP solver interfaces
 ///
+///
 ///The classes in this file do nothing, but they can serve as skeletons when
 ///implementing an interface to new solvers.
 …
   ///A skeleton class to implement LP/MIP solver base interface
   ///This class does nothing, but it can serve as a skeleton when
   ///implementing an interface to new solvers.

lemon/maps.h

-                      r839
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// heap types and \c UnionFind, when the used items are small
   /// integers. This map conforms to the \ref concepts::ReferenceMap
   /// "ReferenceMap" concept.
+  /// "ReferenceMap" concept.
   ///
   /// The simplest way of using this map is through the rangeMap()
 …
   /// \c InverseMap or \c operator()(), and the values of the map can be
   /// accessed with an STL compatible forward iterator (\c ValueIt).
   ///
+  ///
   /// This map is intended to be used when all associated values are
   /// different (the map is actually invertable) or there are only a few
   /// items with the same value.
   /// Otherwise consider to use \c IterableValueMap, which is more
+  /// Otherwise consider to use \c IterableValueMap, which is more
   /// suitable and more efficient for such cases. It provides iterators
   /// to traverse the items with the same associated value, but
 …
       typename Container::const_iterator it;
     };
     /// Alias for \c ValueIt
     typedef ValueIt ValueIterator;
 …
       return it != _inv_map.end() ? it->second : INVALID;
+    }
     /// \brief Returns the number of items with the given value.
     ///
 …
     return RangeIdMap<GR, K>(graph);
+  }
   /// \brief Dynamic iterable \c bool map.
   ///
 …
       /// \param value The value.
       ItemIt(const IterableBoolMap& map, bool value)
         : Parent(value ?
+        : Parent(value ?
                  (map._sep > 0 ?
                   map._array[map._sep - 1] : INVALID) :
 …
     typedef typename To::Key Item;
     typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
     for (ItemIt it(gr); it != INVALID; ++it) {
       to.set(it, from[it]);
 …
   /// \brief Compare two graph maps.
   ///
   /// This function compares the values of two graph maps. It returns
+  /// This function compares the values of two graph maps. It returns
   /// \c true if the maps assign the same value for all items in the graph.
   /// The \c Key type of the maps (\c Node, \c Arc or \c Edge) must be equal
 …
     typedef typename Map2::Key Item;
     typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
     for (ItemIt it(gr); it != INVALID; ++it) {
       if (!(map1[it] == map2[it])) return false;

lemon/matching.h

-                      r955
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
+      }
       _unmatched = _node_num;
 …
       _blossom_node_list.clear();
       _blossom_potential.clear();
       if (_fractional == 0) {
         _fractional = new FractionalMatching(_graph, _weight, false);
 …
             subblossoms[--num] = _blossom_set->find(v);
             _delta1->push(v, _fractional->nodeValue(v));
             v = _graph.target(_fractional->matching(v));
+            v = _graph.target(_fractional->matching(v));
+          }
           int surface =
+          int surface =
             _blossom_set->join(subblossoms.begin(), subblossoms.end());
           (*_blossom_data)[surface].status = EVEN;
 …
           (*_blossom_data)[surface].pot = 0;
           (*_blossom_data)[surface].offset = 0;
           _tree_set->insert(surface);
           ++_unmatched;
 …
+          }
+        }
         if (!(*_node_data)[ni].heap.empty()) {
           _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
 …
     int _unmatched;
     typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
+    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
     FractionalMatching;
     FractionalMatching *_fractional;
 …
       _blossom_node_list.clear();
       _blossom_potential.clear();
       if (_fractional == 0) {
         _fractional = new FractionalMatching(_graph, _weight, false);
 …
           while (n != v) {
             subblossoms[--num] = _blossom_set->find(v);
             v = _graph.target(_fractional->matching(v));
+            v = _graph.target(_fractional->matching(v));
+          }
           int surface =
+          int surface =
             _blossom_set->join(subblossoms.begin(), subblossoms.end());
           (*_blossom_data)[surface].status = EVEN;
 …
           (*_blossom_data)[surface].pot = 0;
           (*_blossom_data)[surface].offset = 0;
           _tree_set->insert(surface);
           ++_unmatched;
 …
+          }
+        }
         if (!(*_node_data)[ni].heap.empty()) {
           _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());

lemon/math.h

-                      r558
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///Check whether the parameter is NaN or not
   ///This function checks whether the parameter is NaN or not.
   ///Is should be equivalent with std::isnan(), but it is not

lemon/min_cost_arborescence.h

-                      r891
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   public:
     /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
     /// of the algorithm.
+    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
+    /// of the algorithm.
     typedef TR Traits;
     /// The type of the underlying digraph.
 …
     /// \ref named-templ-param "Named parameter" for setting
     /// \c PredMap type.
     /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
     /// and its value type must be the \c Arc type of the digraph.
     template <class T>

lemon/network_simplex.h

-                      r936
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
       UNBOUNDED
     };
     /// \brief Constants for selecting the type of the supply constraints.
     ///
 …
       LEQ
     };
     /// \brief Constants for selecting the pivot rule.
     ///
 …
       ALTERING_LIST
     };
   private:
 …
     int stem, par_stem, new_stem;
     Value delta;
     const Value MAX;
   public:
     /// \brief Constant for infinite upper bounds (capacities).
     ///
 …
+        }
         if (_curr_length == 0) return false;
       search_end:
+      search_end:
         _minor_count = 1;
         _next_arc = e;
 …
+        }
         if (_curr_length == 0) return false;
       search_end:
 …
     /// \param graph The digraph the algorithm runs on.
     /// \param arc_mixing Indicate if the arcs have to be stored in a
     /// mixed order in the internal data structure.
+    /// mixed order in the internal data structure.
     /// In special cases, it could lead to better overall performance,
     /// but it is usually slower. Therefore it is disabled by default.
 …
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
         "The cost type of NetworkSimplex must be signed");
       // Reset data structures
       reset();
 …
       return *this;
+    }
     /// \brief Set the type of the supply constraints.
     ///
 …
     /// This function runs the algorithm.
     /// The paramters can be specified using functions \ref lowerMap(),
     /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
     /// \ref supplyType().
     /// For example,
 …
+        }
+      }
       // Reset parameters
       resetParams();
       return *this;
+    }
     /// @}
 …
         _state[i] = STATE_LOWER;
+      }
       // Set data for the artificial root node
       _root = _node_num;
 …
       for (int u = second; u != join; u = _parent[u]) {
         e = _pred[u];
         d = _forward[u] ?
+        d = _forward[u] ?
           (_cap[e] >= MAX ? INF : _cap[e] - _flow[e]) : _flow[e];
         if (d <= delta) {
 …
+        }
+      }
       // Check feasibility
       for (int e = _search_arc_num; e != _all_arc_num; ++e) {
 …
+        }
+      }
       // Shift potentials to meet the requirements of the GEQ/LEQ type
       // optimality conditions

lemon/path.h

-                      r868
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     };
     template <typename From, typename To,
               bool revEnable = RevPathTagIndicator<From>::value>
 …
       static void copy(const From& from, To& to) {
         PathCopySelectorForward<From, To>::copy(from, to);
+      }
+      }
     };
 …
       static void copy(const From& from, To& to) {
         PathCopySelectorBackward<From, To>::copy(from, to);
+      }
+      }
     };

lemon/planarity.h

-                      r896
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     class PlanarityChecking {
     private:
       TEMPLATE_GRAPH_TYPEDEFS(Graph);
 …
     private:
       typedef typename Graph::template NodeMap<Arc> PredMap;
       typedef typename Graph::template EdgeMap<bool> TreeMap;
       typedef typename Graph::template NodeMap<int> OrderMap;
       typedef std::vector<Node> OrderList;
 …
           for (typename MergeRoots::Value::iterator it =
                  merge_roots[node].begin();
+                 merge_roots[node].begin();
                it != merge_roots[node].end(); ++it) {
             int rn = *it;
 …
               bool rd;
               if (!external(xnode, rorder, child_lists,
+              if (!external(xnode, rorder, child_lists,
                             ancestor_map, low_map)) {
                 rd = true;

lemon/preflow.h

r891	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/smart_graph.h

-                      r834
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///\ref SmartDigraph is a simple and fast digraph implementation.
   ///It is also quite memory efficient but at the price
   ///that it does not support node and arc deletion
+  ///that it does not support node and arc deletion
   ///(except for the Snapshot feature).
   ///
 …
     ///arcs from a SmartDigraph structure.
     ///
     ///\note After a state is restored, you cannot restore a later state,
+    ///\note After a state is restored, you cannot restore a later state,
     ///i.e. you cannot add the removed nodes and arcs again using
     ///another Snapshot instance.
 …
   /// \ref SmartGraph is a simple and fast graph implementation.
   /// It is also quite memory efficient but at the price
   /// that it does not support node and edge deletion
+  /// that it does not support node and edge deletion
   /// (except for the Snapshot feature).
   ///
 …
     ///edges from a SmartGraph structure.
     ///
     ///\note After a state is restored, you cannot restore a later state,
+    ///\note After a state is restored, you cannot restore a later state,
     ///i.e. you cannot add the removed nodes and edges again using
     ///another Snapshot instance.

lemon/soplex.cc

-                      r793
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     _clear_temporals();
     _applyMessageLevel();

lemon/soplex.h

r793	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/static_graph.h

-                      r834
+                      r956
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   public:
     StaticDigraphBase()
       : built(false), node_num(0), arc_num(0),
+    StaticDigraphBase()
+      : built(false), node_num(0), arc_num(0),
         node_first_out(NULL), node_first_in(NULL),
         arc_source(NULL), arc_target(NULL),
+        arc_source(NULL), arc_target(NULL),
         arc_next_in(NULL), arc_next_out(NULL) {}
     ~StaticDigraphBase() {
       if (built) {
 …
     class Arc {
       friend class StaticDigraphBase;
+      friend class StaticDigraphBase;
     protected:
       int id;
 …
     static void next(Arc& e) { --e.id; }
     void firstOut(Arc& e, const Node& n) const {
       e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
+    void firstOut(Arc& e, const Node& n) const {
+      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
         node_first_out[n.id] : -1;
+    }
 …
       typedef typename Digraph::Arc Arc;
       ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
+      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
         : digraph(_graph), nodeRef(_nodeRef) {}
       bool operator()(const Arc& left, const Arc& right) const {
         return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
+        return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
+      }
     private:
 …
       const NodeRefMap& nodeRef;
     };
   public:
     typedef True BuildTag;
     void clear() {
       if (built) {
 …
       arc_num = 0;
+    }
     template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
     void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
 …
             int target = nodeRef[digraph.target(*it)].id;
             arcRef[*it] = Arc(arc_index);
             arc_source[arc_index] = source;
+            arc_source[arc_index] = source;
             arc_target[arc_index] = target;
             arc_next_in[arc_index] = node_first_in[target];
 …
       node_first_out[node_num] = arc_num;
+    }
     template <typename ArcListIterator>
     void build(int n, ArcListIterator first, ArcListIterator last) {
 …
       arc_next_out = new int[arc_num];
       arc_next_in = new int[arc_num];
       for (int i = 0; i != node_num; ++i) {
         node_first_in[i] = -1;
+      }
+      }
       int arc_index = 0;
       for (int i = 0; i != node_num; ++i) {
 …
   /// Since this digraph structure is completely static, its nodes and arcs
   /// can be indexed with integers from the ranges <tt>[0..nodeNum()-1]</tt>
   /// and <tt>[0..arcNum()-1]</tt>, respectively.
+  /// and <tt>[0..arcNum()-1]</tt>, respectively.
   /// The index of an item is the same as its ID, it can be obtained
   /// using the corresponding \ref index() or \ref concepts::Digraph::id()
 …
     typedef ExtendedStaticDigraphBase Parent;
   public:
     /// \brief Constructor
     ///
 …
     /// This method also makes possible to copy a digraph to a StaticDigraph
     /// structure using \ref DigraphCopy.
     ///
+    ///
     /// \param digraph An existing digraph to be copied.
     /// \param nodeRef The node references will be copied into this map.
 …
       Parent::build(digraph, nodeRef, arcRef);
+    }
     /// \brief Build the digraph from an arc list.
     ///
 …
     using Parent::fastNextOut;
     using Parent::fastLastOut;
   public:
 …
       OutArcIt(const StaticDigraph& digraph, const Node& node) {
         digraph.fastFirstOut(*this, node);
         digraph.fastLastOut(last, node);
+        digraph.fastFirstOut(*this, node);
+        digraph.fastLastOut(last, node);
         if (last == *this) *this = INVALID;
+      }
 …
+      }
       OutArcIt& operator++() {
+      OutArcIt& operator++() {
         StaticDigraph::fastNextOut(*this);
         if (last == *this) *this = INVALID;
         return *this;
+        return *this;
+      }

lemon/suurballe.h

-                      r941
+                      r956
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// and it must have an \c addBack() function.
     typedef lemon::Path<Digraph> Path;
     /// The cross reference type used for the heap.
     typedef typename GR::template NodeMap<int> HeapCrossRef;
 …
       Node _s;
       Node _t;
       PotentialMap _dist;
       std::vector<Node> _proc_nodes;
 …
       ResidualDijkstra(Suurballe &srb) :
         _graph(srb._graph), _length(srb._length),
         _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred),
+        _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred),
         _s(srb._s), _t(srb._t), _dist(_graph) {}
       // Run the algorithm and return true if a path is found
       // from the source node to the target node.
 …
     private:
       // Execute the algorithm for the first time (the flow and potential
       // functions have to be identically zero).
 …
       typedef Suurballe<GR, LEN, SetPathTraits<T> > Create;
     };
     template <typename H, typename CR>
     struct SetHeapTraits : public Traits {
 …
     ///
     /// \ref named-templ-param "Named parameter" for setting \c Heap
     /// and \c HeapCrossRef types with automatic allocation.
+    /// and \c HeapCrossRef types with automatic allocation.
     /// They will be used for internal Dijkstra computations.
     /// The heap type must conform to the \ref lemon::concepts::Heap "Heap"
 …
     // The pred arc map
     PredMap _pred;
     // Data for full init
     PotentialMap *_init_dist;
 …
       dijk.distMap(*_init_dist).predMap(*_init_pred);
       dijk.run(s);
       _full_init = true;
+    }
 …
       _t = t;
       ResidualDijkstra dijkstra(*this);
       // Initialization
       for (ArcIt e(_graph); e != INVALID; ++e) {
 …
           (*_flow)[e] = 1;
           u = _graph.source(e);
+        }
+        }
         _path_num = 1;
       } else {

lemon/unionfind.h

r954	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/bellman_ford_test.cc

r917	r956
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2009
	5	* Copyright (C) 2003-2010
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	*

Context Navigation

Changeset 956:141f9c0db4a3 in lemon

Legend: