LEMON/LEMON-main Changeset - r877:141f9c0db4a3

demo/arg_parser_demo.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -64,17 +64,17 @@
 		  // Add non-parsed arguments (e.g. input files)
 		  ap.other("infile", "The input file.")
 		    .other("...");
 		  // Throw an exception when problems occurs. The default behavior is to
 		  // exit(1) on these cases, but this makes Valgrind falsely warn
 		  // about memory leaks.
 		  ap.throwOnProblems();
 		  // Perform the parsing process
 		  // (in case of any error it terminates the program)
 		  // The try {} construct is necessary only if the ap.trowOnProblems()
 		  // setting is in use.
 		  try {
 		    ap.parse();
 		  } catch (ArgParserException &) { return 1; }

doc/groups.dox

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

doc/mainpage.dox

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -20,27 +20,27 @@
 		\mainpage LEMON Documentation
 		\section intro Introduction
 		<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
 		and <b>O</b>ptimization in <b>N</b>etworks</i>.
 		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>
 		LEMON is an <a class="el" href="http://opensource.org/">open&nbsp;source</a>
 		project.
 		You are free to use it in your commercial or
 		non-commercial applications under very permissive
 		\ref license "license terms".
 		</b>
-		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
 		at the Operations Research Department of the
 		<a href="http://www.elte.hu/en/">E&ouml;tv&ouml;s Lor&aacute;nd University</a>,
 		Budapest, Hungary.
 		LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
 		initiative \ref coinor.

doc/min_cost_flow.dox

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -76,17 +76,17 @@
 		 - For all \f$uv\in A\f$ arcs:
 		   - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$;
 		   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;
 		   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
 		 - For all \f$u\in V\f$ nodes:
 		   - \f$\pi(u)\leq 0\f$;
 		   - 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[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f]
 		All algorithms provide dual solution (node potentials), as well,
 		if an optimal flow is found.
@@ -114,17 +114,17 @@
 		when there are <em>"less or equal"</em> (LEQ) supply/demand constraints,
 		instead of the <em>"greater or equal"</em> (GEQ) constraints.
 		\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]
 		\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \leq
 		    sup(u) \quad \forall u\in V \f]
 		\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
 		could be supplies that are not carried out from the supply
 		nodes.
 		The equality form is also a special case of this form, of course.
 		You could easily transform this case to the \ref mcf_def "GEQ form"
 		of the problem by reversing the direction of the arcs and taking the

lemon/adaptors.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -416,17 +416,17 @@
 		    NF* _node_filter;
 		    AF* _arc_filter;
 		    SubDigraphBase()
 		      : Parent(), _node_filter(0), _arc_filter(0) { }
 		    void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
 		      Parent::initialize(digraph);
 		      _node_filter = &node_filter;
-		      _arc_filter = &arc_filter;
 		      _arc_filter = &arc_filter;
+		    }
 		  public:
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    void first(Node& i) const {
@@ -503,21 +503,21 @@
 		        arc = Parent::findArc(source, target, arc);
+		      }
 		      return arc;
+		    }
 		  public:
 		    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:
 		      typedef V Value;
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor, const V& value)
 		        : Parent(adaptor, value) {}
@@ -530,19 +530,19 @@
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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;
 		    public:
 		      typedef V Value;
 		      ArcMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
 		        : Parent(adaptor) {}
@@ -577,17 +577,17 @@
 		    NF* _node_filter;
 		    AF* _arc_filter;
 		    SubDigraphBase()
 		      : Parent(), _node_filter(0), _arc_filter(0) { }
 		    void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
 		      Parent::initialize(digraph);
 		      _node_filter = &node_filter;
-		      _arc_filter = &arc_filter;
 		      _arc_filter = &arc_filter;
+		    }
 		  public:
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    void first(Node& i) const {
@@ -646,20 +646,20 @@
 		      Arc arc = Parent::findArc(source, target, prev);
 		      while (arc != INVALID && !(*_arc_filter)[arc]) {
 		        arc = Parent::findArc(source, target, arc);
+		      }
 		      return arc;
+		    }
 		    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;
 		    public:
 		      typedef V Value;
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubDigraphBase<DGR, NF, AF, false>& adaptor, const V& value)
@@ -673,17 +673,17 @@
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    template <typename V>
-		    class ArcMap
 		    class ArcMap
 		      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		          LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 		      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 		        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 		    public:
 		      typedef V Value;
@@ -1016,20 +1016,20 @@
 		      Edge edge = Parent::findEdge(u, v, prev);
 		      while (edge != INVALID && !(*_edge_filter)[edge]) {
 		        edge = Parent::findEdge(u, v, edge);
+		      }
 		      return edge;
+		    }
 		    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;
 		    public:
 		      typedef V Value;
 		      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
@@ -1043,20 +1043,20 @@
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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;
 		    public:
 		      typedef V Value;
 		      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const SubGraphBase<GR, NF, EF, ch>& adaptor, const V& value)
@@ -1070,20 +1070,20 @@
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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;
 		    public:
 		      typedef V Value;
 		      EdgeMap(const SubGraphBase<GR, NF, EF, ch>& adaptor)
 		        : Parent(adaptor) {}
@@ -1112,18 +1112,18 @@
 		    typedef GR Graph;
 		    typedef NF NodeFilterMap;
 		    typedef EF EdgeFilterMap;
 		    typedef SubGraphBase Adaptor;
 		  protected:
 		    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) {
 		      Parent::initialize(graph);
 		      _node_filter = &node_filter;
 		      _edge_filter = &edge_filter;
+		    }
 		  public:
@@ -1214,20 +1214,20 @@
 		      Edge edge = Parent::findEdge(u, v, prev);
 		      while (edge != INVALID && !(*_edge_filter)[edge]) {
 		        edge = Parent::findEdge(u, v, edge);
+		      }
 		      return edge;
+		    }
 		    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;
 		    public:
 		      typedef V Value;
 		      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      NodeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
@@ -1241,20 +1241,20 @@
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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;
 		    public:
 		      typedef V Value;
 		      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      ArcMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
@@ -1268,21 +1268,21 @@
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 		        return *this;
+		      }
 		    };
 		    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:
 		      typedef V Value;
 		      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
 		        : Parent(adaptor) {}
 		      EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor, const V& value)
@@ -1499,17 +1499,17 @@
 		           typename NF = typename GR::template NodeMap<bool>,
 		           typename Enable = void>
 		  class FilterNodes :
 		    public DigraphAdaptorExtender<
 		      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
 		                     true> > {
 		#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;
 		  public:
 		    typedef GR Digraph;
 		    typedef NF NodeFilterMap;
 		    typedef typename Parent::Node Node;
@@ -1520,17 +1520,17 @@
 		    FilterNodes() : const_true_map() {}
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// 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()
+		    {
 		      Parent::initialize(graph, node_filter, const_true_map);
+		    }
 		    /// \brief Sets the status of the given node
 		    ///
 		    /// This function sets the status of the given node.
@@ -1558,21 +1558,21 @@
 		    void enable(const Node& n) const { Parent::status(n, true); }
 		  };
 		  template<typename GR, typename NF>
 		  class FilterNodes<GR, NF,
 		                    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;
 		  public:
 		    typedef GR Graph;
 		    typedef NF NodeFilterMap;
 		    typedef typename Parent::Node Node;
@@ -1648,17 +1648,17 @@
 		  template<typename DGR,
 		           typename AF = typename DGR::template ArcMap<bool> >
 		  class FilterArcs :
 		    public DigraphAdaptorExtender<
 		      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 		                     AF, false> > {
 		#endif
 		    typedef DigraphAdaptorExtender<
-		      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 		      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 		                     AF, false> > Parent;
 		  public:
 		    /// The type of the adapted digraph.
 		    typedef DGR Digraph;
 		    /// The type of the arc filter map.
 		    typedef AF ArcFilterMap;
@@ -1756,21 +1756,21 @@
 		  template<typename GR,
 		           typename EF>
 		  class FilterEdges {
 		#else
 		  template<typename GR,
 		           typename EF = typename GR::template EdgeMap<bool> >
 		  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;
 		  public:
 		    /// The type of the adapted graph.
 		    typedef GR Graph;
 		    /// The type of the edge filter map.
 		    typedef EF EdgeFilterMap;
@@ -1785,17 +1785,17 @@
+		    }
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// 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);
+		    }
 		    /// \brief Sets the status of the given edge
 		    ///
 		    /// This function sets the status of the given edge.
 		    /// It is done by simply setting the assigned value of \c e
@@ -1853,17 +1853,17 @@
 		    typedef typename Digraph::Node Node;
 		    class Arc {
 		      friend class UndirectorBase;
 		    protected:
 		      Edge _edge;
 		      bool _forward;
-		      Arc(const Edge& edge, bool forward)
 		      Arc(const Edge& edge, bool forward)
 		        : _edge(edge), _forward(forward) {}
 		    public:
 		      Arc() {}
 		      Arc(Invalid) : _edge(INVALID), _forward(true) {}
 		      operator const Edge&() const { return _edge; }
@@ -2093,17 +2093,17 @@
 		      typedef typename MapTraits<MapImpl>::ReturnValue ReturnValue;
 		      typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReference;
 		      typedef typename MapTraits<MapImpl>::ReturnValue Reference;
 		      ArcMapBase(const UndirectorBase<DGR>& adaptor) :
 		        _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
 		      ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
-		        : _forward(*adaptor._digraph, value),
 		        : _forward(*adaptor._digraph, value),
 		          _backward(*adaptor._digraph, value) {}
 		      void set(const Arc& a, const V& value) {
 		        if (direction(a)) {
 		          _forward.set(a, value);
 		        } else {
 		          _backward.set(a, value);
+		        }
@@ -2211,17 +2211,17 @@
 		    };
 		    typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
 		    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
 		    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()); }
 		  protected:
 		    UndirectorBase() : _digraph(0) {}
 		    DGR* _digraph;
@@ -2723,17 +2723,17 @@
 		#ifdef DOXYGEN
 		  template<typename DGR, typename CM, typename FM, typename TL>
 		  class ResidualDigraph
 		#else
 		  template<typename DGR,
 		           typename CM = typename DGR::template ArcMap<int>,
 		           typename FM = CM,
 		           typename TL = Tolerance<typename CM::Value> >
-		  class ResidualDigraph
 		  class ResidualDigraph
 		    : public SubDigraph<
 		        Undirector<const DGR>,
 		        ConstMap<typename DGR::Node, Const<bool, true> >,
 		        typename Undirector<const DGR>::template CombinedArcMap<
 		          _adaptor_bits::ResForwardFilter<const DGR, CM, FM, TL>,
 		          _adaptor_bits::ResBackwardFilter<const DGR, CM, FM, TL> > >
 		#endif
+		  {
@@ -2780,17 +2780,17 @@
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Constructor of the residual digraph adaptor. The parameters are the
 		    /// digraph, the capacity map, the flow map, and a tolerance object.
 		    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),
 		        _backward_filter(capacity, flow, tolerance),
 		        _arc_filter(_forward_filter, _backward_filter)
+		    {
 		      Parent::initialize(_graph, _node_filter, _arc_filter);
+		    }
@@ -2862,17 +2862,17 @@
 		      const Adaptor* _adaptor;
 		    public:
 		      /// The key type of the map
 		      typedef Arc Key;
 		      /// The value type of the map
 		      typedef typename CapacityMap::Value Value;
 		      /// Constructor
-		      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
 		      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
 		        : _adaptor(&adaptor) {}
 		      /// Returns the value associated with the given residual arc
 		      Value operator[](const Arc& a) const {
 		        return _adaptor->residualCapacity(a);
+		      }
 		    };
@@ -3442,17 +3442,17 @@
 		      return Parent::arc(a);
+		    }
 		    /// \brief Node map combined from two original node maps
 		    ///
 		    /// This map adaptor class adapts two node maps of the original digraph
 		    /// 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>
 		    class CombinedNodeMap {
 		    public:
 		      /// The key type of the map
 		      typedef Node Key;
 		      /// The value type of the map

lemon/arg_parser.cc

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
@@ -21,18 +21,18 @@
namespace lemon {

  void ArgParser::_terminate(ArgParserException::Reason reason) const
  {
    if(_exit_on_problems)
      exit(1);
    else throw(ArgParserException(reason));
  }
  
  


  void ArgParser::_showHelp(void *p)
  {
    (static_cast<ArgParser*>(p))->showHelp();
    (static_cast<ArgParser*>(p))->_terminate(ArgParserException::HELP);
  }

  ArgParser::ArgParser(int argc, const char * const *argv)
    :_argc(argc), _argv(argv), _command_name(argv[0]),

lemon/arg_parser.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -37,20 +37,20 @@
 		  ///Exception used by ArgParser
 		  class ArgParserException : public Exception {
 		  public:
 		    enum Reason {
 		      HELP,         /// <tt>--help</tt> option was given
 		      UNKNOWN_OPT,  /// Unknown option was given
 		      INVALID_OPT   /// Invalid combination of options
 		    };
 		  private:
 		    Reason _reason;
 		  public:
 		    ///Constructor
 		    ArgParserException(Reason r) throw() : _reason(r) {}
 		    ///Virtual destructor
 		    virtual ~ArgParserException() throw() {}
 		    ///A short description of the exception
 		    virtual const char* what() const throw() {
 		      switch(_reason)
@@ -136,31 +136,31 @@
 		      OtherArg(std::string n, std::string h) :name(n), help(h) {}
 		    };
 		    std::vector<OtherArg> _others_help;
 		    std::vector<std::string> _file_args;
 		    std::string _command_name;
 		  private:
 		    //Bind a function to an option.
 		    //\param name The name of the option. The leading '-' must be omitted.
 		    //\param help A help string.
 		    //\retval func The function to be called when the option is given. It
 		    //  must be of type "void f(void *)"
 		    //\param data Data to be passed to \c func
 		    ArgParser &funcOption(const std::string &name,
 		                    const std::string &help,
 		                    void (*func)(void *),void *data);
 		    bool _exit_on_problems;
 		    void _terminate(ArgParserException::Reason reason) const;
 		  public:
 		    ///Constructor
 		    ArgParser(int argc, const char * const *argv);
 		    ~ArgParser();
@@ -418,16 +418,16 @@
 		    ///Give back the non-option type arguments.
 		    ///Give back a reference to a vector consisting of the program arguments
 		    ///not starting with a '-' character.
 		    const std::vector<std::string> &files() const { return _file_args; }
 		    ///Throw instead of exit in case of problems
-		    void throwOnProblems()
 		    void throwOnProblems()
+		    {
 		      _exit_on_problems=false;
+		    }
 		  };
+		}
 		#endif // LEMON_ARG_PARSER_H

lemon/bellman_ford.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -31,26 +31,26 @@
 		#include <lemon/tolerance.h>
 		#include <lemon/path.h>
 		#include <limits>
 		namespace lemon {
 		  /// \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.
 		  /// The default implementation is based on the \c numeric_limits class.
 		  /// If the numeric type does not have infinity value, then the maximum
 		  /// value is used as extremal infinity value.
 		  ///
 		  /// \see BellmanFordToleranceOperationTraits
 		  template <
-		    typename V,
 		    typename V,
 		    bool has_inf = std::numeric_limits<V>::has_infinity>
 		  struct BellmanFordDefaultOperationTraits {
 		    /// \brief Value type for the algorithm.
 		    typedef V Value;
 		    /// \brief Gives back the zero value of the type.
 		    static Value zero() {
 		      return static_cast<Value>(0);
+		    }
@@ -81,17 +81,17 @@
 		    static Value plus(const Value& left, const Value& right) {
 		      if (left == infinity() || right == infinity()) return infinity();
 		      return left + right;
+		    }
 		    static bool less(const Value& left, const Value& right) {
 		      return left < right;
+		    }
 		  };
 		  /// \brief Operation traits for the BellmanFord algorithm class
 		  /// using tolerance.
 		  ///
 		  /// This operation traits class defines all computational operations
 		  /// and constants that are used in the Bellman-Ford algorithm.
 		  /// The only difference between this implementation and
 		  /// \ref BellmanFordDefaultOperationTraits is that this class uses
 		  /// the \ref Tolerance "tolerance technique" in its \ref less()
@@ -134,17 +134,17 @@
 		  /// \brief Default traits class of BellmanFord class.
 		  ///
 		  /// Default traits class of BellmanFord class.
 		  /// \param GR The type of the digraph.
 		  /// \param LEN The type of the length map.
 		  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;
 		    /// \brief The type of the map that stores the arc lengths.
 		    ///
 		    /// The type of the map that stores the arc lengths.
 		    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef LEN LengthMap;
@@ -153,66 +153,66 @@
 		    /// \brief Operation traits for Bellman-Ford algorithm.
 		    ///
 		    /// It defines the used operations and the infinity value for the
 		    /// given \c Value type.
 		    /// \see BellmanFordDefaultOperationTraits,
 		    /// 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.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
 		    /// \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.
 		    static PredMap *createPredMap(const GR& g) {
 		      return new PredMap(g);
+		    }
 		    /// \brief The type of the map that stores the distances of the nodes.
 		    ///
 		    /// The type of the map that stores the distances of the nodes.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename GR::template NodeMap<typename LEN::Value> DistMap;
 		    /// \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) {
 		      return new DistMap(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 Bellman-Ford algorithm solves the single-source shortest path
 		  /// problem when the arcs can have negative lengths, but the digraph
 		  /// should not contain directed cycles with negative total length.
 		  /// If all arc costs are non-negative, consider to use the Dijkstra
 		  /// algorithm instead, since it is more efficient.
 		  ///
 		  /// 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.
 		  ///
 		  /// There is also a \ref bellmanFord() "function-type interface" for the
 		  /// Bellman-Ford algorithm, which is convenient in the simplier cases and
 		  /// it can be used easier.
 		  ///
 		  /// \tparam GR The type of the digraph the algorithm runs on.
@@ -232,17 +232,17 @@
 		            typename LEN=typename GR::template ArcMap<int>,
 		            typename TR=BellmanFordDefaultTraits<GR,LEN> >
 		#endif
 		  class BellmanFord {
 		  public:
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    /// \brief The type of the arc lengths.
 		    typedef typename TR::LengthMap::Value Value;
 		    /// \brief The type of the map that stores the arc lengths.
 		    typedef typename TR::LengthMap LengthMap;
 		    /// \brief The type of the map that stores the last
 		    /// arcs of the shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    /// \brief The type of the map that stores the distances of the nodes.
@@ -279,30 +279,30 @@
 		    typedef typename Digraph::template NodeMap<bool> MaskMap;
 		    MaskMap *_mask;
 		    std::vector<Node> _process;
 		    // Creates the maps if necessary.
 		    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) {
 		        _mask = new MaskMap(*_gr);
+		      }
+		    }
 		  public :
 		    typedef BellmanFord Create;
 		    /// \name Named Template Parameters
 		    ///@{
 		    template <class T>
 		    struct SetPredMapTraits : public Traits {
@@ -315,78 +315,78 @@
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \c PredMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c PredMap type.
 		    /// 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 {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph&) {
 		        LEMON_ASSERT(false, "DistMap is not initialized");
 		        return 0; // ignore warnings
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \c DistMap type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c DistMap type.
 		    /// 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;
 		    };
 		    template <class T>
 		    struct SetOperationTraitsTraits : public Traits {
 		      typedef T OperationTraits;
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \c OperationTraits type.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// \c OperationTraits type.
 		    /// For more information, see \ref BellmanFordDefaultOperationTraits.
 		    template <class T>
 		    struct SetOperationTraits
 		      : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {
 		      typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> >
 		      Create;
 		    };
 		    ///@}
 		  protected:
 		    BellmanFord() {}
 		  public:
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// Constructor.
 		    /// \param g The digraph the algorithm runs on.
 		    /// \param length The length map used by the algorithm.
 		    BellmanFord(const Digraph& g, const LengthMap& length) :
 		      _gr(&g), _length(&length),
 		      _pred(0), _local_pred(false),
 		      _dist(0), _local_dist(false), _mask(0) {}
 		    ///Destructor.
 		    ~BellmanFord() {
 		      if(_local_pred) delete _pred;
 		      if(_local_dist) delete _dist;
 		      if(_mask) delete _mask;
+		    }
 		    /// \brief Sets the length map.
@@ -403,36 +403,36 @@
 		    /// Sets the map that stores the predecessor arcs.
 		    /// If you don't use this function before calling \ref run()
 		    /// or \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    BellmanFord &predMap(PredMap &map) {
 		      if(_local_pred) {
 			delete _pred;
 			_local_pred=false;
 		        delete _pred;
 		        _local_pred=false;
+		      }
 		      _pred = &map;
 		      return *this;
+		    }
 		    /// \brief Sets the map that stores the distances of the nodes.
 		    ///
 		    /// Sets the map that stores the distances of the nodes calculated
 		    /// by the algorithm.
 		    /// If you don't use this function before calling \ref run()
 		    /// or \ref init(), an instance will be allocated automatically.
 		    /// The destructor deallocates this automatically allocated map,
 		    /// of course.
 		    /// \return <tt>(*this)</tt>
 		    BellmanFord &distMap(DistMap &map) {
 		      if(_local_dist) {
 			delete _dist;
 			_local_dist=false;
 		        delete _dist;
 		        _local_dist=false;
+		      }
 		      _dist = &map;
 		      return *this;
+		    }
 		    /// \name Execution Control
 		    /// The simplest way to execute the Bellman-Ford algorithm is to use
 		    /// one of the member functions called \ref run().\n
@@ -440,47 +440,47 @@
 		    /// \ref init() first, then you can add several source nodes
 		    /// with \ref addSource(). Finally the actual path computation can be
 		    /// performed with \ref start(), \ref checkedStart() or
 		    /// \ref limitedStart().
 		    ///@{
 		    /// \brief Initializes the internal data structures.
-		    ///
 		    ///
 		    /// Initializes the internal data structures. The optional parameter
 		    /// is the initial distance of each node.
 		    void init(const Value value = OperationTraits::infinity()) {
 		      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.
 		    ///
 		    /// This function adds a new source node. The optional second parameter
 		    /// is the initial distance of the node.
 		    void addSource(Node source, Value dst = OperationTraits::zero()) {
 		      _dist->set(source, dst);
 		      if (!(*_mask)[source]) {
 			_process.push_back(source);
 			_mask->set(source, true);
 		        _process.push_back(source);
 		        _mask->set(source, true);
+		      }
+		    }
 		    /// \brief Executes one round from the Bellman-Ford algorithm.
 		    ///
 		    /// If the algoritm calculated the distances in the previous round
 		    /// exactly for the paths of at most \c k arcs, then this function
 		    /// will calculate the distances exactly for the paths of at most
@@ -495,36 +495,36 @@
 		    /// and build the path manually.
 		    ///
 		    /// \return \c true when the algorithm have not found more shorter
 		    /// paths.
 		    ///
 		    /// \see ActiveIt
 		    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);
 		      return _process.empty();
+		    }
 		    /// \brief Executes one weak round from the Bellman-Ford algorithm.
 		    ///
 		    /// If the algorithm calculated the distances in the previous round
@@ -536,33 +536,33 @@
 		    /// this is why it is called weak round.
 		    ///
 		    /// \return \c true when the algorithm have not found more shorter
 		    /// paths.
 		    ///
 		    /// \see ActiveIt
 		    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);
 		      return _process.empty();
+		    }
 		    /// \brief Executes the algorithm.
 		    ///
 		    /// Executes the algorithm.
@@ -574,40 +574,40 @@
 		    /// - the shortest path tree (forest),
 		    /// - the distance of each node from the root(s).
 		    ///
 		    /// \pre init() must be called and at least one root node should be
 		    /// added with addSource() before using this function.
 		    void start() {
 		      int num = countNodes(*_gr) - 1;
 		      for (int i = 0; i < num; ++i) {
-			if (processNextWeakRound()) break;
+		        if (processNextWeakRound()) break;
+		      }
+		    }
 		    /// \brief Executes the algorithm and checks the negative cycles.
 		    ///
 		    /// Executes the algorithm and checks the negative cycles.
 		    ///
 		    /// This method runs the Bellman-Ford algorithm from the root node(s)
 		    /// in order to compute the shortest path to each node and also checks
 		    /// 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();
+		    }
 		    /// \brief Executes the algorithm with arc number limit.
 		    ///
 		    /// Executes the algorithm with arc number limit.
 		    ///
@@ -621,25 +621,25 @@
 		    ///
 		    /// \warning The paths with limited arc number cannot be retrieved
 		    /// easily with \ref path() or \ref predArc() functions. If you also
 		    /// need the shortest paths and not only the distances, you should
 		    /// store the \ref predMap() "predecessor map" after each iteration
 		    /// and build the path manually.
 		    ///
 		    /// \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.
 		    ///
 		    /// The algorithm computes
 		    /// - the shortest path tree (forest),
 		    /// - the distance of each node from the root(s).
 		    ///
 		    /// \note bf.run(s) is just a shortcut of the following code.
@@ -648,20 +648,20 @@
 		    ///   bf.addSource(s);
 		    ///   bf.start();
 		    /// \endcode
 		    void run(Node s) {
 		      init();
 		      addSource(s);
 		      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
 		    /// node using only the paths consisting of at most \c num arcs.
 		    ///
 		    /// The algorithm computes
 		    /// - the limited distance of each node from the root(s),
 		    /// - the predecessor arc for each node.
 		    ///
@@ -677,92 +677,92 @@
 		    ///   bf.addSource(s);
 		    ///   bf.limitedStart(num);
 		    /// \endcode
 		    void run(Node s, int num) {
 		      init();
 		      addSource(s);
 		      limitedStart(num);
+		    }
 		    ///@}
 		    /// \brief LEMON iterator for getting the active nodes.
 		    ///
 		    /// This class provides a common style LEMON iterator that traverses
 		    /// the active nodes of the Bellman-Ford algorithm after the last
 		    /// phase. These nodes should be checked in the next phase to
 		    /// find augmenting arcs outgoing from them.
 		    class ActiveIt {
 		    public:
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor for getting the active nodes of the given BellmanFord
-		      /// instance.
 		      /// instance.
 		      ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
+		      {
 		        _index = _algorithm->_process.size() - 1;
+		      }
 		      /// \brief Invalid constructor.
 		      ///
 		      /// Invalid constructor.
 		      ActiveIt(Invalid) : _algorithm(0), _index(-1) {}
 		      /// \brief Conversion to \c Node.
 		      ///
 		      /// Conversion to \c Node.
-		      operator Node() const {
 		      operator Node() const {
 		        return _index >= 0 ? _algorithm->_process[_index] : INVALID;
+		      }
 		      /// \brief Increment operator.
 		      ///
 		      /// Increment operator.
 		      ActiveIt& operator++() {
 		        --_index;
-		        return *this;
 		        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);
 		      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).
 		    ///
 		    /// \warning \c t should be reached from the root(s).
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    Path path(Node t) const
+		    {
 		      return Path(*_gr, *_pred, t);
+		    }
 		    /// \brief The distance of the given node from the root(s).
 		    ///
 		    /// Returns the distance of the given node from the root(s).
 		    ///
 		    /// \warning If node \c v is not reached from the root(s), then
 		    /// the return value of this function is undefined.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
@@ -792,52 +792,52 @@
 		    /// a shortest path from a root to \c v. It is \c INVALID if \c v
 		    /// is not reached from the root(s) or if \c v is a root.
 		    ///
 		    /// The shortest path tree used here is equal to the shortest path
 		    /// tree used in \ref predArc() and \ref predMap().
 		    ///
 		    /// \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.
 		    ///
 		    /// Returns a const reference to the node map that stores the distances
 		    /// of the nodes calculated by the algorithm.
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    const DistMap &distMap() const { return *_dist;}
 		    /// \brief Returns a const reference to the node map that stores the
 		    /// predecessor arcs.
 		    ///
 		    /// Returns a const reference to the node map that stores the predecessor
 		    /// arcs, which form the shortest path tree (forest).
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    const PredMap &predMap() const { return *_pred; }
 		    /// \brief Checks if a node is reached from the root(s).
 		    ///
 		    /// Returns \c true if \c v is reached from the root(s).
 		    ///
 		    /// \pre Either \ref run() or \ref init() must be called before
 		    /// using this function.
 		    bool reached(Node v) const {
 		      return (*_dist)[v] != OperationTraits::infinity();
+		    }
 		    /// \brief Gives back a negative cycle.
-		    ///
 		    ///
 		    /// This function gives back a directed cycle with negative total
 		    /// length if the algorithm has already found one.
 		    /// Otherwise it gives back an empty path.
 		    lemon::Path<Digraph> negativeCycle() const {
 		      typename Digraph::template NodeMap<int> state(*_gr, -1);
 		      lemon::Path<Digraph> cycle;
 		      for (int i = 0; i < int(_process.size()); ++i) {
 		        if (state[_process[i]] != -1) continue;
@@ -854,28 +854,28 @@
 		          else if (state[v] >= 0) {
 		            break;
+		          }
 		          state[v] = i;
+		        }
+		      }
 		      return cycle;
+		    }
 		    ///@}
 		  };
 		  /// \brief Default traits class of bellmanFord() function.
 		  ///
 		  /// Default traits class of bellmanFord() function.
 		  /// \tparam GR The type of the digraph.
 		  /// \tparam LEN The type of the length map.
 		  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 arc lengths.
 		    ///
 		    /// The type of the map that stores the arc lengths.
 		    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef LEN LengthMap;
@@ -887,59 +887,59 @@
 		    /// It defines the used operations and the infinity value for the
 		    /// given \c Value type.
 		    /// \see BellmanFordDefaultOperationTraits,
 		    /// BellmanFordToleranceOperationTraits
 		    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
 		    /// \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.
 		    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
 		    /// \brief Instantiates a \c PredMap.
-		    ///
 		    ///
 		    /// This function instantiates a \ref PredMap.
 		    /// \param g is the digraph to which we would like to define the
 		    /// \ref PredMap.
 		    static PredMap *createPredMap(const GR &g) {
 		      return new PredMap(g);
+		    }
 		    /// \brief The type of the map that stores the distances of the nodes.
 		    ///
 		    /// The type of the map that stores the distances of the nodes.
 		    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		    typedef typename GR::template NodeMap<Value> DistMap;
 		    /// \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.
 		    static DistMap *createDistMap(const GR &g) {
 		      return new DistMap(g);
+		    }
 		    ///The type of the shortest paths.
 		    ///The type of the shortest paths.
 		    ///It must meet the \ref concepts::Path "Path" concept.
 		    typedef lemon::Path<Digraph> Path;
 		  };
 		  /// \brief Default traits class used by BellmanFordWizard.
 		  ///
 		  /// Default traits class used by BellmanFordWizard.
 		  /// \tparam GR The type of the digraph.
 		  /// \tparam LEN The type of the length map.
 		  template <typename GR, typename LEN>
-		  class BellmanFordWizardBase
 		  class BellmanFordWizardBase
 		    : public BellmanFordWizardDefaultTraits<GR, LEN> {
 		    typedef BellmanFordWizardDefaultTraits<GR, LEN> Base;
 		  protected:
 		    // Type of the nodes in the digraph.
 		    typedef typename Base::Digraph::Node Node;
 		    // Pointer to the underlying digraph.
@@ -952,36 +952,36 @@
 		    void *_dist;
 		    //Pointer to the shortest path to the target node.
 		    void *_path;
 		    //Pointer to the distance of the target node.
 		    void *_di;
 		    public:
 		    /// Constructor.
 		    /// This constructor does not require parameters, it initiates
 		    /// all of the attributes to default values \c 0.
 		    BellmanFordWizardBase() :
 		      _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(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.
 		  ///
 		  /// This auxiliary class is created to implement the
 		  /// \ref bellmanFord() "function-type interface" of the
 		  /// \ref BellmanFord "Bellman-Ford" algorithm.
 		  /// It does not have own \ref run() method, it uses the
 		  /// functions and features of the plain \ref BellmanFord.
@@ -996,48 +996,48 @@
 		    typedef TR Base;
 		    typedef typename TR::Digraph Digraph;
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt ArcIt;
 		    typedef typename TR::LengthMap LengthMap;
 		    typedef typename LengthMap::Value Value;
 		    typedef typename TR::PredMap PredMap;
 		    typedef typename TR::DistMap DistMap;
 		    typedef typename TR::Path Path;
 		  public:
 		    /// Constructor.
 		    BellmanFordWizard() : TR() {}
 		    /// \brief Constructor that requires parameters.
 		    ///
 		    /// Constructor that requires parameters.
 		    /// These parameters will be the default values for the traits class.
 		    /// \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 Copy constructor
 		    BellmanFordWizard(const TR &b) : TR(b) {}
 		    ~BellmanFordWizard() {}
 		    /// \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));
 		      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
 		      bf.run(s);
+		    }
 		    /// \brief Runs the Bellman-Ford algorithm to find the shortest path
 		    /// between \c s and \c t.
@@ -1062,35 +1062,35 @@
+		    }
 		    template<class T>
 		    struct SetPredMapBase : public Base {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &) { return 0; };
 		      SetPredMapBase(const TR &b) : TR(b) {}
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// the predecessor map.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// the map that stores the predecessor arcs of the nodes.
 		    template<class T>
 		    BellmanFordWizard<SetPredMapBase<T> > predMap(const T &t) {
 		      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
 		      return BellmanFordWizard<SetPredMapBase<T> >(*this);
+		    }
 		    template<class T>
 		    struct SetDistMapBase : public Base {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &) { return 0; };
 		      SetDistMapBase(const TR &b) : TR(b) {}
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// the distance map.
 		    ///
 		    /// \ref named-templ-param "Named parameter" for setting
 		    /// the map that stores the distances of the nodes calculated
 		    /// by the algorithm.
 		    template<class T>
 		    BellmanFordWizard<SetDistMapBase<T> > distMap(const T &t) {
@@ -1121,45 +1121,45 @@
 		    ///
 		    /// \ref named-func-param "Named parameter" for getting
 		    /// the distance of the target node.
 		    BellmanFordWizard dist(const Value &d)
+		    {
 		      Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
 		      return *this;
+		    }
 		  };
 		  /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
 		  /// algorithm.
 		  ///
 		  /// \ingroup shortest_path
 		  /// Function type interface for the \ref BellmanFord "Bellman-Ford"
 		  /// 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.
 		  /// \code
 		  ///   // Compute shortest path from node s to each node
 		  ///   bellmanFord(g,length).predMap(preds).distMap(dists).run(s);
 		  ///
 		  ///   // Compute shortest path from s to t
 		  ///   bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t);
 		  /// \endcode
 		  /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
 		  /// to the end of the parameter list.
 		  /// \sa BellmanFordWizard
 		  /// \sa BellmanFord
 		  template<typename GR, typename LEN>
 		  BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
 		  bellmanFord(const GR& digraph,
-			      const LEN& length)
+		              const LEN& length)
+		  {
 		    return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);
+		  }
 		} //END OF NAMESPACE LEMON
 		#endif

lemon/bfs.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -77,17 +77,18 @@
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///This function instantiates a \ref ReachedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
@@ -266,17 +267,18 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ReachedMap type.
 		    ///
 		    ///\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> > {
 		      typedef Bfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
@@ -867,17 +869,18 @@
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
@@ -1260,17 +1263,18 @@
 		  struct BfsVisitDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the map that indicates which nodes are reached.
 		    ///
 		    /// 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;
 		    /// \brief Instantiates a ReachedMap.
 		    ///
 		    /// This function instantiates a ReachedMap.
 		    /// \param digraph is the digraph, to which
 		    /// we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {

lemon/binomial_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -253,17 +253,17 @@
 		    /// This function decreases the priority of an item to the given value.
 		    /// \param item The item.
 		    /// \param value The priority.
 		    /// \pre \e item must be stored in the heap with priority at least \e value.
 		    void decrease (Item item, const Prio& value) {
 		      int i=_iim[item];
 		      int p=_data[i].parent;
 		      _data[i].prio=value;
 		      while( p!=-1 && _comp(value, _data[p].prio) ) {
 		        _data[i].name=_data[p].name;
 		        _data[i].prio=_data[p].prio;
 		        _data[p].name=item;
 		        _data[p].prio=value;
 		        _iim[_data[i].name]=i;
 		        i=p;
 		        p=_data[p].parent;
@@ -317,17 +317,17 @@
 		        _iim[i] = st;
 		        break;
 		      case IN_HEAP:
 		        break;
+		      }
+		    }
 		  private:
 		    // Find the minimum of the roots
 		    int findMin() {
 		      if( _head!=-1 ) {
 		        int min_loc=_head, min_val=_data[_head].prio;
 		        for( int x=_data[_head].right_neighbor; x!=-1;
 		             x=_data[x].right_neighbor ) {
 		          if( _comp( _data[x].prio,min_val ) ) {
 		            min_val=_data[x].prio;
@@ -345,17 +345,17 @@
 		      if( _data[a].right_neighbor==-1 &&
 		          _data[a].degree<=_data[_head].degree ) {
 		        _data[a].right_neighbor=_head;
 		        _head=a;
 		      } else {
 		        interleave(a);
+		      }
 		      if( _data[_head].right_neighbor==-1 ) return;
 		      int x=_head;
 		      int x_prev=-1, x_next=_data[x].right_neighbor;
 		      while( x_next!=-1 ) {
 		        if( _data[x].degree!=_data[x_next].degree ||
 		            ( _data[x_next].right_neighbor!=-1 &&
 		              _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
 		          x_prev=x;
 		          x=x_next;
@@ -379,30 +379,30 @@
+		      }
+		    }
 		    // Interleave the elements of the given list into the list of the roots
 		    void interleave(int a) {
 		      int p=_head, q=a;
 		      int curr=_data.size();
 		      _data.push_back(Store());
 		      while( p!=-1 || q!=-1 ) {
 		        if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
 		          _data[curr].right_neighbor=p;
 		          curr=p;
 		          p=_data[p].right_neighbor;
+		        }
 		        else {
 		          _data[curr].right_neighbor=q;
 		          curr=q;
 		          q=_data[q].right_neighbor;
+		        }
+		      }
 		      _head=_data.back().right_neighbor;
 		      _data.pop_back();
+		    }
 		    // Lace node a under node b
 		    void fuse(int a, int b) {
 		      _data[a].parent=b;
 		      _data[a].right_neighbor=_data[b].child;

lemon/bits/array_map.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -65,17 +65,17 @@
 		    // The map type.
 		    typedef ArrayMap Map;
 		    // The notifier type.
 		    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
 		  private:
 		    // The MapBase of the Map which imlements the core regisitry function.
 		    typedef typename Notifier::ObserverBase Parent;
 		    typedef std::allocator<Value> Allocator;
 		  public:
 		    // \brief Graph initialized map constructor.

lemon/bits/default_map.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -152,17 +152,17 @@
 		  // DefaultMap class
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class DefaultMap
 		    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
 		    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
 		  public:
 		    typedef DefaultMap<_Graph, _Item, _Value> Map;
 		    typedef typename Parent::GraphType GraphType;
 		    typedef typename Parent::Value Value;
 		    explicit DefaultMap(const GraphType& graph) : Parent(graph) {}
 		    DefaultMap(const GraphType& graph, const Value& value)
 		      : Parent(graph, value) {}
 		    DefaultMap& operator=(const DefaultMap& cmap) {

lemon/bits/edge_set_extender.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -58,21 +58,21 @@
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    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;
+		    }
 		    // Alteration notifier extensions
 		    // The arc observer registry.
 		    typedef AlterationNotifier<ArcSetExtender, Arc> ArcNotifier;
@@ -86,105 +86,105 @@
 		    // Gives back the arc alteration notifier.
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    // Iterable extensions
-		    class NodeIt : public Node {
 		    class NodeIt : public Node {
 		      const Digraph* digraph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
-			_graph.first(static_cast<Node&>(*this));
+		        _graph.first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Digraph& _graph, const Node& node)
 			: Node(node), digraph(&_graph) {}
 		      NodeIt(const Digraph& _graph, const Node& node)
 		        : Node(node), digraph(&_graph) {}
 		      NodeIt& operator++() {
 			digraph->next(*this);
-			return *this;
+		      NodeIt& operator++() {
 		        digraph->next(*this);
 		        return *this;
+		      }
 		    };
-		    class ArcIt : public Arc {
 		    class ArcIt : public Arc {
 		      const Digraph* digraph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
-			_graph.first(static_cast<Arc&>(*this));
+		        _graph.first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Digraph& _graph, const Arc& e) :
 			Arc(e), digraph(&_graph) { }
 		      ArcIt(const Digraph& _graph, const Arc& e) :
 		        Arc(e), digraph(&_graph) { }
 		      ArcIt& operator++() {
 			digraph->next(*this);
-			return *this;
+		      ArcIt& operator++() {
 		        digraph->next(*this);
 		        return *this;
+		      }
 		    };
-		    class OutArcIt : public Arc {
 		    class OutArcIt : public Arc {
 		      const Digraph* digraph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Digraph& _graph, const Node& node)
 			: digraph(&_graph) {
-			_graph.firstOut(*this, node);
+		      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(const Digraph& _graph, const Arc& arc)
 		        : Arc(arc), digraph(&_graph) {}
 		      OutArcIt& operator++() {
 			digraph->nextOut(*this);
-			return *this;
+		      OutArcIt& operator++() {
 		        digraph->nextOut(*this);
 		        return *this;
+		      }
 		    };
-		    class InArcIt : public Arc {
 		    class InArcIt : public Arc {
 		      const Digraph* digraph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Digraph& _graph, const Node& node)
 			: digraph(&_graph) {
-			_graph.firstIn(*this, node);
+		      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(const Digraph& _graph, const Arc& arc) :
 		        Arc(arc), digraph(&_graph) {}
 		      InArcIt& operator++() {
 			digraph->nextIn(*this);
-			return *this;
+		      InArcIt& operator++() {
 		        digraph->nextIn(*this);
 		        return *this;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &e) const {
@@ -210,49 +210,49 @@
 		    // iterator
 		    Node runningNode(const InArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
+		    }
 		    using Parent::first;
 		    // 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);
+		      }
 		      template <typename CMap>
 		      ArcMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
-			return *this;
+		        return *this;
+		      }
 		    };
 		    // Alteration extension
 		    Arc addArc(const Node& from, const Node& to) {
 		      Arc arc = Parent::addArc(from, to);
 		      notifier(Arc()).add(arc);
 		      return arc;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      Parent::clear();
+		    }
 		    void erase(const Arc& arc) {
 		      notifier(Arc()).erase(arc);
 		      Parent::erase(arc);
@@ -305,21 +305,21 @@
+		    }
 		    Edge fromId(int id, Edge) const {
 		      return Parent::edgeFromId(id);
+		    }
 		    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;
+		    }
 		    Arc oppositeArc(const Arc &e) const {
 		      return Parent::direct(e, !Parent::direction(e));
+		    }
 		    using Parent::direct;
 		    Arc direct(const Edge &e, const Node &s) const {
@@ -333,164 +333,164 @@
 		  protected:
 		    mutable ArcNotifier arc_notifier;
 		    mutable EdgeNotifier edge_notifier;
 		  public:
 		    using Parent::notifier;
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    EdgeNotifier& notifier(Edge) const {
 		      return edge_notifier;
+		    }
-		    class NodeIt : public Node {
 		    class NodeIt : public Node {
 		      const Graph* graph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-			_graph.first(static_cast<Node&>(*this));
+		        _graph.first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Graph& _graph, const Node& node)
 			: Node(node), graph(&_graph) {}
 		      NodeIt(const Graph& _graph, const Node& node)
 		        : Node(node), graph(&_graph) {}
 		      NodeIt& operator++() {
 			graph->next(*this);
-			return *this;
+		      NodeIt& operator++() {
 		        graph->next(*this);
 		        return *this;
+		      }
 		    };
-		    class ArcIt : public Arc {
 		    class ArcIt : public Arc {
 		      const Graph* graph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Graph& _graph) : graph(&_graph) {
-			_graph.first(static_cast<Arc&>(*this));
+		        _graph.first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Graph& _graph, const Arc& e) :
 			Arc(e), graph(&_graph) { }
 		      ArcIt(const Graph& _graph, const Arc& e) :
 		        Arc(e), graph(&_graph) { }
 		      ArcIt& operator++() {
 			graph->next(*this);
-			return *this;
+		      ArcIt& operator++() {
 		        graph->next(*this);
 		        return *this;
+		      }
 		    };
-		    class OutArcIt : public Arc {
 		    class OutArcIt : public Arc {
 		      const Graph* graph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Graph& _graph, const Node& node)
 			: graph(&_graph) {
-			_graph.firstOut(*this, node);
+		      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(const Graph& _graph, const Arc& arc)
 		        : Arc(arc), graph(&_graph) {}
 		      OutArcIt& operator++() {
 			graph->nextOut(*this);
-			return *this;
+		      OutArcIt& operator++() {
 		        graph->nextOut(*this);
 		        return *this;
+		      }
 		    };
-		    class InArcIt : public Arc {
 		    class InArcIt : public Arc {
 		      const Graph* graph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Graph& _graph, const Node& node)
 			: graph(&_graph) {
-			_graph.firstIn(*this, node);
+		      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(const Graph& _graph, const Arc& arc) :
 		        Arc(arc), graph(&_graph) {}
 		      InArcIt& operator++() {
 			graph->nextIn(*this);
-			return *this;
+		      InArcIt& operator++() {
 		        graph->nextIn(*this);
 		        return *this;
+		      }
 		    };
-		    class EdgeIt : public Parent::Edge {
 		    class EdgeIt : public Parent::Edge {
 		      const Graph* graph;
 		    public:
 		      EdgeIt() { }
 		      EdgeIt(Invalid i) : Edge(i) { }
 		      explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-			_graph.first(static_cast<Edge&>(*this));
+		        _graph.first(static_cast<Edge&>(*this));
+		      }
 		      EdgeIt(const Graph& _graph, const Edge& e) :
 			Edge(e), graph(&_graph) { }
 		      EdgeIt(const Graph& _graph, const Edge& e) :
 		        Edge(e), graph(&_graph) { }
 		      EdgeIt& operator++() {
 			graph->next(*this);
-			return *this;
+		      EdgeIt& operator++() {
 		        graph->next(*this);
 		        return *this;
+		      }
 		    };
 		    class IncEdgeIt : public Parent::Edge {
 		      friend class EdgeSetExtender;
 		      const Graph* graph;
 		      bool direction;
 		    public:
 		      IncEdgeIt() { }
 		      IncEdgeIt(Invalid i) : Edge(i), direction(false) { }
 		      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;
+		      }
 		    };
 		    // \brief Base node of the iterator
 		    //
 		    // Returns the base node (ie. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &e) const {
 		      return Parent::source(static_cast<const Arc&>(e));
@@ -527,76 +527,76 @@
 		    //
 		    // Returns the running node of the iterator
 		    Node runningNode(const IncEdgeIt &e) const {
 		      return e.direction ? v(e) : u(e);
+		    }
 		    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);
+		      }
 		      template <typename 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) {}
 		      explicit EdgeMap(const Graph& _g)
 		        : Parent(_g) {}
 		      EdgeMap(const Graph& _g, const _Value& _v)
 			: Parent(_g, _v) {}
 		      EdgeMap(const Graph& _g, const _Value& _v)
 		        : Parent(_g, _v) {}
 		      EdgeMap& operator=(const EdgeMap& cmap) {
-			return operator=<EdgeMap>(cmap);
+		        return operator=<EdgeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      EdgeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
-			return *this;
+		        return *this;
+		      }
 		    };
 		    // Alteration extension
 		    Edge addEdge(const Node& from, const Node& to) {
 		      Edge edge = Parent::addEdge(from, to);
 		      notifier(Edge()).add(edge);
 		      std::vector<Arc> arcs;
 		      arcs.push_back(Parent::direct(edge, true));
 		      arcs.push_back(Parent::direct(edge, false));
 		      notifier(Arc()).add(arcs);
 		      return edge;
+		    }
 		    void clear() {
 		      notifier(Arc()).clear();
 		      notifier(Edge()).clear();
 		      Parent::clear();
+		    }
 		    void erase(const Edge& edge) {
 		      std::vector<Arc> arcs;
@@ -612,14 +612,14 @@
 		      arc_notifier.setContainer(*this);
 		      edge_notifier.setContainer(*this);
+		    }
 		    ~EdgeSetExtender() {
 		      edge_notifier.clear();
 		      arc_notifier.clear();
+		    }
 		  };
+		}
 		#endif

lemon/bits/solver_bits.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/bits/windows.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -91,17 +91,17 @@
 		    std::string getWinFormattedDate()
+		    {
 		      std::ostringstream os;
 		#ifdef WIN32
 		      SYSTEMTIME time;
 		      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,
 		                        ("HH':'mm':'ss"), buf2, 9) &&
 		          GetDateFormat(MY_LOCALE, 0, &time,
 		                        ("yyyy"), buf3, 5)) {
 		        os << buf1 << ' ' << buf2 << ' ' << buf3;
+		      }
 		      else os << "unknown";

lemon/bucket_heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -379,17 +379,17 @@
 		  /// structure. It does not provide some functionality, but it is
 		  /// faster and simpler than BucketHeap. The main difference is
 		  /// that BucketHeap stores a doubly-linked list for each key while
 		  /// this class stores only simply-linked lists. It supports erasing
 		  /// only for the item having minimum priority and it does not support
 		  /// key increasing and decreasing.
 		  ///
 		  /// 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.
 		  ///
 		  /// \tparam IM A read-writable item map with \c int values, used
 		  /// internally to handle the cross references.
 		  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
 		  /// The default is \e min-heap. If this parameter is set to \c false,
 		  /// then the comparison is reversed, so the top(), prio() and pop()
 		  /// functions deal with the item having maximum priority instead of the

lemon/capacity_scaling.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -128,17 +128,17 @@
 		      OPTIMAL,
 		      /// The digraph contains an arc of negative cost and infinite
 		      /// upper bound. It means that the objective function is unbounded
 		      /// on that arc, however, note that it could actually be bounded
 		      /// over the feasible flows, but this algroithm cannot handle
 		      /// these cases.
 		      UNBOUNDED
 		    };
 		  private:
 		    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		    typedef std::vector<int> IntVector;
 		    typedef std::vector<Value> ValueVector;
 		    typedef std::vector<Cost> CostVector;
 		    typedef std::vector<char> BoolVector;
@@ -179,17 +179,17 @@
 		    IntVector _excess_nodes;
 		    IntVector _deficit_nodes;
 		    Value _delta;
 		    int _factor;
 		    IntVector _pred;
 		  public:
 		    /// \brief Constant for infinite upper bounds (capacities).
 		    ///
 		    /// Constant for infinite upper bounds (capacities).
 		    /// It is \c std::numeric_limits<Value>::infinity() if available,
 		    /// \c std::numeric_limits<Value>::max() otherwise.
 		    const Value INF;
 		  private:
@@ -206,20 +206,20 @@
 		      bool _geq;
 		      const IntVector &_first_out;
 		      const IntVector &_target;
 		      const CostVector &_cost;
 		      const ValueVector &_res_cap;
 		      const ValueVector &_excess;
 		      CostVector &_pi;
 		      IntVector &_pred;
 		      IntVector _proc_nodes;
 		      CostVector _dist;
 		    public:
 		      ResidualDijkstra(CapacityScaling& cs) :
 		        _node_num(cs._node_num), _geq(cs._sum_supply < 0),
 		        _first_out(cs._first_out), _target(cs._target), _cost(cs._cost),
 		        _res_cap(cs._res_cap), _excess(cs._excess), _pi(cs._pi),
 		        _pred(cs._pred), _dist(cs._node_num)
 		      {}
@@ -434,17 +434,17 @@
 		    CapacityScaling& stSupply(const Node& s, const Node& t, Value k) {
 		      for (int i = 0; i != _node_num; ++i) {
 		        _supply[i] = 0;
+		      }
 		      _supply[_node_id[s]] =  k;
 		      _supply[_node_id[t]] = -k;
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Execution control
 		    /// The algorithm can be executed using \ref run().
 		    /// @{
 		    /// \brief Run the algorithm.
@@ -570,17 +570,17 @@
 		      _source.resize(_res_arc_num);
 		      _target.resize(_res_arc_num);
 		      _reverse.resize(_res_arc_num);
 		      _lower.resize(_res_arc_num);
 		      _upper.resize(_res_arc_num);
 		      _cost.resize(_res_arc_num);
 		      _supply.resize(_node_num);
 		      _res_cap.resize(_res_arc_num);
 		      _pi.resize(_node_num);
 		      _excess.resize(_node_num);
 		      _pred.resize(_node_num);
 		      // Copy the graph
 		      int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1;
 		      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
@@ -614,17 +614,17 @@
 		      _first_out[i] = j;
 		      _first_out[_node_num] = k;
 		      for (ArcIt a(_graph); a != INVALID; ++a) {
 		        int fi = _arc_idf[a];
 		        int bi = _arc_idb[a];
 		        _reverse[fi] = bi;
 		        _reverse[bi] = fi;
+		      }
 		      // Reset parameters
 		      resetParams();
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Query Functions
@@ -723,17 +723,17 @@
 		      if (_node_num <= 1) return INFEASIBLE;
 		      // Check the sum of supply values
 		      _sum_supply = 0;
 		      for (int i = 0; i != _root; ++i) {
 		        _sum_supply += _supply[i];
+		      }
 		      if (_sum_supply > 0) return INFEASIBLE;
 		      // Initialize vectors
 		      for (int i = 0; i != _root; ++i) {
 		        _pi[i] = 0;
 		        _excess[i] = _supply[i];
+		      }
 		      // Remove non-zero lower bounds
 		      const Value MAX = std::numeric_limits<Value>::max();
@@ -771,17 +771,17 @@
 		            if (rc >= MAX) return UNBOUNDED;
 		            _excess[i] -= rc;
 		            _excess[_target[j]] += rc;
 		            _res_cap[j] = 0;
 		            _res_cap[_reverse[j]] += rc;
+		          }
+		        }
+		      }
 		      // Handle GEQ supply type
 		      if (_sum_supply < 0) {
 		        _pi[_root] = 0;
 		        _excess[_root] = -_sum_supply;
 		        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
 		          int ra = _reverse[a];
 		          _res_cap[a] = -_sum_supply + 1;
 		          _res_cap[ra] = 0;
@@ -839,19 +839,19 @@
+		        }
+		      }
 		      // Shift potentials if necessary
 		      Cost pr = _pi[_root];
 		      if (_sum_supply < 0 || pr > 0) {
 		        for (int i = 0; i != _node_num; ++i) {
 		          _pi[i] -= pr;
+		        }
+		        }
+		      }
 		      return pt;
+		    }
 		    // Execute the capacity scaling algorithm
 		    ProblemType startWithScaling() {
 		      // Perform capacity scaling phases
 		      int s, t;
 		      ResidualDijkstra _dijkstra(*this);

lemon/cbc.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
@@ -116,15 +116,15 @@

    virtual void _clear();

    virtual void _messageLevel(MessageLevel level);
    void _applyMessageLevel();

    int _message_level;

    


  };

}

#endif

lemon/circulation.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -54,18 +54,18 @@
 		    ///
 		    /// The type of the map that stores the upper bounds (capacities)
 		    /// on the arcs.
 		    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef UM UpperMap;
 		    /// \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;
 		    /// \brief The type of the flow and supply values.
 		    typedef typename SupplyMap::Value Value;
 		    /// \brief The type of the map that stores the flow values.
 		    ///
@@ -136,27 +136,27 @@
 		     supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with
 		     \f$-sup(u)\f$ demand.
 		     A feasible circulation is an \f$f: A\rightarrow\mathbf{R}\f$
 		     solution of the following problem.
 		     \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu)
 		     \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
 		     of the expressions on the left-hand side of the inequalities is zero).
 		     It means that the total demand must be greater or equal to the total
 		     supply and all the supplies have to be carried out from the supply nodes,
 		     but there could be demands that are not satisfied.
 		     If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand
 		     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
 		     have to be satisfied while there could be supplies that are not used),
 		     then you could easily transform the problem to the above form by reversing
 		     the direction of the arcs and taking the negative of the supply values
 		     (e.g. using \ref ReverseDigraph and \ref NegMap adaptors).
 		     This algorithm either calculates a feasible circulation, or provides
@@ -332,17 +332,17 @@
 		  public:
 		    /// Constructor.
 		    /// The constructor of the class.
 		    ///
 		    /// \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.
 		    Circulation(const Digraph &graph, const LowerMap &lower,
 		                const UpperMap &upper, const SupplyMap &supply)
 		      : _g(graph), _lo(&lower), _up(&upper), _supply(&supply),
 		        _flow(NULL), _local_flow(false), _level(NULL), _local_level(false),
 		        _excess(NULL) {}

lemon/clp.cc

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/clp.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -133,17 +133,17 @@
 		    virtual VarStatus _getRowStatus(int i) const;
 		    virtual ProblemType _getPrimalType() const;
 		    virtual ProblemType _getDualType() const;
 		    virtual void _clear();
 		    virtual void _messageLevel(MessageLevel);
 		  public:
 		    ///Solves LP with primal simplex method.
 		    SolveExitStatus solvePrimal();
 		    ///Solves LP with dual simplex method.
 		    SolveExitStatus solveDual();

lemon/concepts/digraph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -429,17 +429,17 @@
 		        /// Constructor
 		        explicit NodeMap(const Digraph&) { }
 		        /// Constructor with given initial value
 		        NodeMap(const Digraph&, T) { }
 		      private:
 		        ///Copy constructor
-		        NodeMap(const NodeMap& nm) :
 		        NodeMap(const NodeMap& nm) :
 		          ReferenceMap<Node, T, T&, const T&>(nm) { }
 		        ///Assignment operator
 		        template <typename CMap>
 		        NodeMap& operator=(const CMap&) {
 		          checkConcept<ReadMap<Node, T>, CMap>();
 		          return *this;
+		        }
 		      };

lemon/concepts/graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -38,17 +38,17 @@
 		    /// This class describes the common interface of all undirected
 		    /// graphs.
 		    ///
 		    /// Like all concept classes, it only provides an interface
 		    /// without any sensible implementation. So any general algorithm for
 		    /// undirected graphs should compile with this class, but it will not
 		    /// 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
 		    /// "directed graphs", since each edge can also be regarded as two
 		    /// oppositely directed arcs.
 		    /// Undirected graphs provide an Edge type for the undirected edges and
 		    /// an Arc type for the directed arcs. The Arc type is convertible to
 		    /// Edge or inherited from it, i.e. the corresponding edge can be
 		    /// obtained from an arc.
@@ -80,17 +80,17 @@
 		    public:
 		      /// Default constructor.
 		      Graph() {}
 		      /// \brief Undirected graphs should be tagged with \c UndirectedTag.
 		      ///
 		      /// Undirected graphs should be tagged with \c UndirectedTag.
-		      ///
 		      ///
 		      /// This tag helps the \c enable_if technics to make compile time
 		      /// specializations for undirected graphs.
 		      typedef True UndirectedTag;
 		      /// The node type of the graph
 		      /// This class identifies a node of the graph. It also serves
 		      /// as a base class of the node iterators,
@@ -355,17 +355,17 @@
 		        /// Artificial ordering operator.
 		        ///
 		        /// \note This operator only has to define some strict ordering of
 		        /// the arcs; this order has nothing to do with the iteration
 		        /// ordering of the arcs.
 		        bool operator<(Arc) const { return false; }
 		        /// Converison to \c Edge
 		        /// Converison to \c Edge.
 		        ///
 		        operator Edge() const { return Edge(); }
 		      };
 		      /// Iterator class for the arcs.
 		      /// This iterator goes through each directed arc of the graph.

lemon/concepts/graph_components.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -33,17 +33,17 @@
 		    /// \brief Concept class for \c Node, \c Arc and \c Edge types.
 		    ///
 		    /// This class describes the concept of \c Node, \c Arc and \c Edge
 		    /// subtypes of digraph and graph types.
 		    ///
 		    /// \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'.
 		#ifndef DOXYGEN
 		    template <char sel = '0'>
 		#endif
 		    class GraphItem {
 		    public:
 		      /// \brief Default constructor.
@@ -84,17 +84,17 @@
 		      /// \brief Inequality operator.
 		      ///
 		      /// Inequality operator.
 		      bool operator!=(const GraphItem&) const { return false; }
 		      /// \brief Ordering operator.
 		      ///
 		      /// 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).
 		      ///
 		      /// \note This operator only has to define some strict ordering of
 		      /// the items; this order has nothing to do with the iteration
 		      /// ordering of the items.
 		      bool operator<(const GraphItem&) const { return false; }
 		      template<typename _GraphItem>
@@ -117,17 +117,17 @@
 		        const _GraphItem &ib;
 		      };
 		    };
 		    /// \brief Base skeleton class for directed graphs.
 		    ///
 		    /// 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 {
 		    public:
 		      typedef BaseDigraphComponent Digraph;
 		      /// \brief Node class of the digraph.
 		      ///
@@ -421,17 +421,17 @@
+		        }
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \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>
 		    class GraphItemIt : public Item {
 		    public:
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor.
 		      /// \warning The default constructor is not required to set
@@ -461,17 +461,17 @@
 		      /// Assignment operator for the iterator.
 		      GraphItemIt& operator=(const GraphItemIt&) { return *this; }
 		      /// \brief Increment the iterator.
 		      ///
 		      /// This operator increments the iterator, i.e. assigns it to the
 		      /// next item.
 		      GraphItemIt& operator++() { return *this; }
 		      /// \brief Equality operator
 		      ///
 		      /// Equality operator.
 		      /// Two iterators are equal if and only if they point to the
 		      /// same object or both are invalid.
 		      bool operator==(const GraphItemIt&) const { return true;}
 		      /// \brief Inequality operator
@@ -496,25 +496,25 @@
 		          Item bi = it1;
 		          bi = it2;
+		        }
 		        const GR& g;
 		      };
 		    };
-		    /// \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,
 		              typename Item = typename GR::Arc,
 		              typename Base = typename GR::Node,
 		              char sel = '0'>
 		    class GraphIncIt : public Item {
 		    public:
 		      /// \brief Default constructor.
@@ -525,20 +525,20 @@
 		      /// as uninitialized.
 		      GraphIncIt() {}
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy constructor.
 		      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 Constructor for conversion from \c INVALID.
 		      ///
 		      /// Constructor for conversion from \c INVALID.
 		      /// It initializes the iterator to be invalid.
 		      /// \sa Invalid for more details.
@@ -799,26 +799,26 @@
 		      /// \brief Return the next edge.
 		      ///
 		      /// This function gives back the next edge in the iteration order.
 		      void next(Edge&) const {}
 		      /// \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 {}
 		      /// \brief Gives back the next of the edges from the
 		      /// 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 {}
 		      using IterableDigraphComponent<Base>::baseNode;
 		      using IterableDigraphComponent<Base>::runningNode;
 		      /// @}
@@ -985,17 +985,17 @@
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Concept class for standard graph maps.
 		    ///
 		    /// 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.
 		    template <typename GR, typename K, typename V>
 		    class GraphMap : public ReferenceMap<K, V, V&, const V&> {
 		      typedef ReferenceMap<K, V, V&, const V&> Parent;
 		    public:
@@ -1040,17 +1040,17 @@
 		    public:
 		      template<typename _Map>
 		      struct Constraints {
 		        void constraints() {
 		          checkConcept
 		            <ReferenceMap<Key, Value, Value&, const Value&>, _Map>();
 		          _Map m1(g);
 		          _Map m2(g,t);
 		          // Copy constructor
 		          // _Map m3(m);
 		          // Assignment operator
 		          // ReadMap<Key, Value> cmap;
 		          // m3 = cmap;
 		          ignore_unused_variable_warning(m1);
@@ -1063,17 +1063,17 @@
 		        const typename GraphMap::Value &t;
 		      };
 		    };
 		    /// \brief Skeleton class for mappable directed graphs.
 		    ///
 		    /// 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.
 		    template <typename BAS = BaseDigraphComponent>
 		    class MappableDigraphComponent : public BAS  {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
@@ -1200,17 +1200,17 @@
 		        const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for mappable undirected graphs.
 		    ///
 		    /// 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.
 		    template <typename BAS = BaseGraphComponent>
 		    class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Edge Edge;
@@ -1285,17 +1285,17 @@
 		        const _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for extendable directed graphs.
 		    ///
 		    /// 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.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ExtendableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
@@ -1329,17 +1329,17 @@
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for extendable undirected graphs.
 		    ///
 		    /// 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.
 		    template <typename BAS = BaseGraphComponent>
 		    class ExtendableGraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
@@ -1373,30 +1373,30 @@
 		        _Graph& graph;
 		      };
 		    };
 		    /// \brief Skeleton class for erasable directed graphs.
 		    ///
 		    /// 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.
 		    template <typename BAS = BaseDigraphComponent>
 		    class ErasableDigraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;
 		      typedef typename Base::Arc Arc;
 		      /// \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&) {}
 		      /// \brief Erase an arc from the digraph.
 		      ///
 		      /// This function erases the given arc from the digraph.
 		      void erase(const Arc&) {}
@@ -1412,17 +1412,17 @@
 		        _Digraph& digraph;
 		      };
 		    };
 		    /// \brief Skeleton class for erasable undirected graphs.
 		    ///
 		    /// 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.
 		    template <typename BAS = BaseGraphComponent>
 		    class ErasableGraphComponent : public BAS {
 		    public:
 		      typedef BAS Base;
 		      typedef typename Base::Node Node;

lemon/concepts/heap.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -87,31 +87,31 @@
 		      /// \param map A map that assigns \c int values to keys of type
 		      /// \c Item. It is used internally by the heap implementations to
 		      /// handle the cross references. The assigned value must be
 		      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
 		#ifdef DOXYGEN
 		      explicit Heap(ItemIntMap &map) {}
 		#else
 		      explicit Heap(ItemIntMap&) {}
-		#endif
 		#endif
 		      /// \brief Constructor.
 		      ///
 		      /// Constructor.
 		      /// \param map A map that assigns \c int values to keys of type
 		      /// \c Item. It is used internally by the heap implementations to
 		      /// handle the cross references. The assigned value must be
 		      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
 		      /// \param comp The function object used for comparing the priorities.
 		#ifdef DOXYGEN
 		      explicit Heap(ItemIntMap &map, const CMP &comp) {}
 		#else
 		      explicit Heap(ItemIntMap&, const CMP&) {}
-		#endif
 		#endif
 		      /// \brief The number of items stored in the heap.
 		      ///
 		      /// This function returns the number of items stored in the heap.
 		      int size() const { return 0; }
 		      /// \brief Check if the heap is empty.
 		      ///
@@ -133,17 +133,17 @@
 		      /// given priority.
 		      /// \param i The item to insert.
 		      /// \param p The priority of the item.
 		      /// \pre \e i must not be stored in the heap.
 		#ifdef DOXYGEN
 		      void push(const Item &i, const Prio &p) {}
 		#else
 		      void push(const Item&, const Prio&) {}
-		#endif
 		#endif
 		      /// \brief Return the item having minimum priority.
 		      ///
 		      /// This function returns the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Item top() const { return Item(); }
 		      /// \brief The minimum priority.
@@ -163,94 +163,94 @@
 		      /// This function removes the given item from the heap if it is
 		      /// already stored.
 		      /// \param i The item to delete.
 		      /// \pre \e i must be in the heap.
 		#ifdef DOXYGEN
 		      void erase(const Item &i) {}
 		#else
 		      void erase(const Item&) {}
-		#endif
 		#endif
 		      /// \brief The priority of the given item.
 		      ///
 		      /// This function returns the priority of the given item.
 		      /// \param i The item.
 		      /// \pre \e i must be in the heap.
 		#ifdef DOXYGEN
 		      Prio operator[](const Item &i) const {}
 		#else
 		      Prio operator[](const Item&) const { return Prio(); }
-		#endif
 		#endif
 		      /// \brief Set the priority of an item or insert it, if it is
 		      /// not stored in the heap.
 		      ///
 		      /// This method sets the priority of the given item if it is
 		      /// already stored in the heap. Otherwise it inserts the given
 		      /// item into the heap with the given priority.
 		      ///
 		      /// \param i The item.
 		      /// \param p The priority.
 		#ifdef DOXYGEN
 		      void set(const Item &i, const Prio &p) {}
 		#else
 		      void set(const Item&, const Prio&) {}
-		#endif
 		#endif
 		      /// \brief Decrease the priority of an item to the given value.
 		      ///
 		      /// This function decreases the priority of an item to the given value.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      /// \pre \e i must be stored in the heap with priority at least \e p.
 		#ifdef DOXYGEN
 		      void decrease(const Item &i, const Prio &p) {}
 		#else
 		      void decrease(const Item&, const Prio&) {}
-		#endif
 		#endif
 		      /// \brief Increase the priority of an item to the given value.
 		      ///
 		      /// This function increases the priority of an item to the given value.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      /// \pre \e i must be stored in the heap with priority at most \e p.
 		#ifdef DOXYGEN
 		      void increase(const Item &i, const Prio &p) {}
 		#else
 		      void increase(const Item&, const Prio&) {}
-		#endif
 		#endif
 		      /// \brief Return the state of an item.
 		      ///
 		      /// This method returns \c PRE_HEAP if the given item has never
 		      /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
 		      /// and \c POST_HEAP otherwise.
 		      /// In the latter case it is possible that the item will get back
 		      /// to the heap again.
 		      /// \param i The item.
 		#ifdef DOXYGEN
 		      State state(const Item &i) const {}
 		#else
 		      State state(const Item&) const { return PRE_HEAP; }
-		#endif
 		#endif
 		      /// \brief Set the state of an item in the heap.
 		      ///
 		      /// This function sets the state of the given item in the heap.
 		      /// It can be used to manually clear the heap when it is important
 		      /// to achive better time complexity.
 		      /// \param i The item.
 		      /// \param st The state. It should not be \c IN_HEAP.
 		#ifdef DOXYGEN
 		      void state(const Item& i, State st) {}
 		#else
 		      void state(const Item&, State) {}
-		#endif
 		#endif
 		      template <typename _Heap>
 		      struct Constraints {
 		      public:
 		        void constraints() {
 		          typedef typename _Heap::Item OwnItem;
 		          typedef typename _Heap::Prio OwnPrio;

lemon/connectivity.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -253,17 +253,17 @@
 		  /// \brief Check whether a directed graph is strongly connected.
 		  ///
 		  /// This function checks whether the given directed graph is strongly
 		  /// connected, i.e. any two nodes of the digraph are
 		  /// connected with directed paths in both direction.
 		  ///
 		  /// \return \c true if the digraph is strongly connected.
 		  /// \note By definition, the empty digraph is strongly connected.
-		  ///
 		  ///
 		  /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
 		  /// \see connected()
 		  template <typename Digraph>
 		  bool stronglyConnected(const Digraph& digraph) {
 		    checkConcept<concepts::Digraph, Digraph>();
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
@@ -305,17 +305,17 @@
+		      }
+		    }
 		    return true;
+		  }
 		  /// \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
 		  ///
 		  /// This function counts the number of strongly connected components of
 		  /// the given directed graph.
 		  ///
 		  /// The strongly connected components are the classes of an
 		  /// equivalence relation on the nodes of a digraph. Two nodes are in
 		  /// the same class if they are connected with directed paths in both
@@ -739,31 +739,31 @@
 		  template <typename Graph>
 		  int countBiNodeConnectedComponents(const Graph& graph);
 		  /// \ingroup graph_properties
 		  ///
 		  /// \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.
 		  ///
 		  /// \return \c true if the graph bi-node-connected.
 		  /// \note By definition, the empty graph is bi-node-connected.
 		  ///
 		  /// \see countBiNodeConnectedComponents(), biNodeConnectedComponents()
 		  template <typename Graph>
 		  bool biNodeConnected(const Graph& graph) {
 		    return countBiNodeConnectedComponents(graph) <= 1;
+		  }
 		  /// \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.
 		  ///
 		  /// This function counts the number of bi-node-connected components of
 		  /// the given undirected graph.
 		  ///
 		  /// The bi-node-connected components are the classes of an equivalence
 		  /// relation on the edges of a undirected graph. Two edges are in the
 		  /// same class if they are on same circle.
@@ -807,17 +807,17 @@
 		  /// same class if they are on same circle.
 		  ///
 		  /// \image html node_biconnected_components.png
 		  /// \image latex node_biconnected_components.eps "bi-node-connected components" width=\textwidth
 		  ///
 		  /// \param graph The 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.
 		  ///
 		  /// \see biNodeConnected(), countBiNodeConnectedComponents()
 		  template <typename Graph, typename EdgeMap>
 		  int biNodeConnectedComponents(const Graph& graph,
 		                                EdgeMap& compMap) {
 		    checkConcept<concepts::Graph, Graph>();
@@ -853,17 +853,17 @@
 		  ///
 		  /// The bi-node-connected components are the classes of an equivalence
 		  /// relation on the edges of a undirected graph. Two edges are in the
 		  /// same class if they are on same circle.
 		  /// The bi-node-connected components are separted by the cut nodes of
 		  /// the 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
 		  /// other nodes.
 		  /// \return The number of the cut nodes.
 		  ///
 		  /// \see biNodeConnected(), biNodeConnectedComponents()
 		  template <typename Graph, typename NodeMap>
 		  int biNodeConnectedCutNodes(const Graph& graph, NodeMap& cutMap) {
@@ -1080,17 +1080,17 @@
 		  template <typename Graph>
 		  int countBiEdgeConnectedComponents(const Graph& graph);
 		  /// \ingroup graph_properties
 		  ///
 		  /// \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.
 		  ///
 		  /// \return \c true if the graph is bi-edge-connected.
 		  /// \note By definition, the empty graph is bi-edge-connected.
 		  ///
 		  /// \see countBiEdgeConnectedComponents(), biEdgeConnectedComponents()
 		  template <typename Graph>
@@ -1187,17 +1187,17 @@
 		    return compNum;
+		  }
 		  /// \ingroup graph_properties
 		  ///
 		  /// \brief Find the bi-edge-connected cut edges in an undirected graph.
 		  ///
 		  /// 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
 		  /// relation on the nodes of an undirected graph. Two nodes are in the
 		  /// same class if they are connected with at least two edge-disjoint
 		  /// paths.
 		  /// The bi-edge-connected components are separted by the cut edges of
 		  /// the components.
 		  ///
@@ -1344,17 +1344,17 @@
 		  /// \brief Sort the nodes of a DAG into topolgical order.
 		  ///
 		  /// This function sorts the nodes of the given acyclic digraph (DAG)
 		  /// into topolgical order and also checks whether the given digraph
 		  /// is DAG.
 		  ///
 		  /// \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.
 		  /// \return \c false if the digraph is not DAG.
 		  ///
 		  /// \see dag(), topologicalSort()
 		  template <typename Digraph, typename NodeMap>
 		  bool checkedTopologicalSort(const Digraph& digraph, NodeMap& order) {
 		    using namespace _connectivity_bits;

lemon/core.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -1234,17 +1234,18 @@
 		  public:
 		    /// The Digraph type
 		    typedef GR Digraph;
 		  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;
 		    public:
 		      AutoNodeMap(const GR& digraph) : Parent(digraph, INVALID) {}
 		      virtual void add(const Node& node) {
 		        Parent::add(node);
@@ -1273,17 +1274,17 @@
 		    public:
 		      ArcLess(const Digraph &_g) : g(_g) {}
 		      bool operator()(Arc a,Arc b) const
+		      {
 		        return g.target(a)<g.target(b);
+		      }
 		    };
-		  protected:
 		  protected:
 		    const Digraph &_g;
 		    AutoNodeMap _head;
 		    typename Digraph::template ArcMap<Arc> _parent;
 		    typename Digraph::template ArcMap<Arc> _left;
 		    typename Digraph::template ArcMap<Arc> _right;
 		  public:

lemon/cost_scaling.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -87,17 +87,17 @@
 		  /// @{
 		  /// \brief Implementation of the Cost Scaling algorithm for
 		  /// finding a \ref min_cost_flow "minimum cost flow".
 		  ///
 		  /// \ref CostScaling implements a cost scaling algorithm that performs
 		  /// 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
 		  /// "preflow push-relabel" algorithm for the maximum flow problem.
 		  ///
 		  /// Most of the parameters of the problem (except for the digraph)
 		  /// can be given using separate functions, and the algorithm can be
 		  /// executed using the \ref run() function. If some parameters are not
 		  /// specified, then default values will be used.
@@ -184,17 +184,17 @@
 		    /// function with the proper parameter.
 		    enum Method {
 		      /// Local push operations are used, i.e. flow is moved only on one
 		      /// admissible arc at once.
 		      PUSH,
 		      /// Augment operations are used, i.e. flow is moved on admissible
 		      /// 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
 		      /// as a combined version of the previous two operations.
 		      PARTIAL_AUGMENT
 		    };
 		  private:
@@ -203,33 +203,33 @@
 		    typedef std::vector<int> IntVector;
 		    typedef std::vector<Value> ValueVector;
 		    typedef std::vector<Cost> CostVector;
 		    typedef std::vector<LargeCost> LargeCostVector;
 		    typedef std::vector<char> BoolVector;
 		    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
 		  private:
 		    template <typename KT, typename VT>
 		    class StaticVectorMap {
 		    public:
 		      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)];
+		      }
 		      Value& operator[](const Key& key) {
 		        return _v[StaticDigraph::id(key)];
+		      }
 		      void set(const Key& key, const Value& val) {
 		        _v[StaticDigraph::id(key)] = val;
+		      }
 		    private:
 		      std::vector<Value>& _v;
 		    };
@@ -278,27 +278,27 @@
 		    LargeCost _epsilon;
 		    int _alpha;
 		    IntVector _buckets;
 		    IntVector _bucket_next;
 		    IntVector _bucket_prev;
 		    IntVector _rank;
 		    int _max_rank;
 		    // Data for a StaticDigraph structure
 		    typedef std::pair<int, int> IntPair;
 		    StaticDigraph _sgr;
 		    std::vector<IntPair> _arc_vec;
 		    std::vector<LargeCost> _cost_vec;
 		    LargeCostArcMap _cost_map;
 		    LargeCostNodeMap _pi_map;
 		  public:
 		    /// \brief Constant for infinite upper bounds (capacities).
 		    ///
 		    /// Constant for infinite upper bounds (capacities).
 		    /// It is \c std::numeric_limits<Value>::infinity() if available,
 		    /// \c std::numeric_limits<Value>::max() otherwise.
 		    const Value INF;
 		  public:
@@ -343,17 +343,17 @@
 		          std::numeric_limits<Value>::infinity() :
 		          std::numeric_limits<Value>::max())
+		    {
 		      // Check the number types
 		      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
 		        "The flow type of CostScaling must be signed");
 		      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
 		        "The cost type of CostScaling must be signed");
 		      // Reset data structures
 		      reset();
+		    }
 		    /// \name Parameters
 		    /// The parameters of the algorithm can be specified using these
 		    /// functions.
@@ -459,17 +459,17 @@
 		    CostScaling& stSupply(const Node& s, const Node& t, Value k) {
 		      for (int i = 0; i != _res_node_num; ++i) {
 		        _supply[i] = 0;
+		      }
 		      _supply[_node_id[s]] =  k;
 		      _supply[_node_id[t]] = -k;
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Execution control
 		    /// The algorithm can be executed using \ref run().
 		    /// @{
 		    /// \brief Run the algorithm.
@@ -561,17 +561,17 @@
 		        _upper[j] = INF;
 		        _scost[j] = _forward[j] ? 1 : -1;
+		      }
 		      for (int j = limit; j != _res_arc_num; ++j) {
 		        _lower[j] = 0;
 		        _upper[j] = INF;
 		        _scost[j] = 0;
 		        _scost[_reverse[j]] = 0;
+		      }
+		      }
 		      _have_lower = false;
 		      return *this;
+		    }
 		    /// \brief Reset all the parameters that have been given before.
 		    ///
 		    /// This function resets all the paramaters that have been given
 		    /// before using functions \ref lowerMap(), \ref upperMap(),
@@ -596,17 +596,17 @@
 		      _source.resize(_res_arc_num);
 		      _target.resize(_res_arc_num);
 		      _reverse.resize(_res_arc_num);
 		      _lower.resize(_res_arc_num);
 		      _upper.resize(_res_arc_num);
 		      _scost.resize(_res_arc_num);
 		      _supply.resize(_res_node_num);
 		      _res_cap.resize(_res_arc_num);
 		      _cost.resize(_res_arc_num);
 		      _pi.resize(_res_node_num);
 		      _excess.resize(_res_node_num);
 		      _next_out.resize(_res_node_num);
 		      _arc_vec.reserve(_res_arc_num);
 		      _cost_vec.reserve(_res_arc_num);
@@ -644,17 +644,17 @@
 		      _first_out[i] = j;
 		      _first_out[_res_node_num] = k;
 		      for (ArcIt a(_graph); a != INVALID; ++a) {
 		        int fi = _arc_idf[a];
 		        int bi = _arc_idb[a];
 		        _reverse[fi] = bi;
 		        _reverse[bi] = fi;
+		      }
 		      // Reset parameters
 		      resetParams();
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Query Functions
@@ -753,24 +753,24 @@
 		      if (_res_node_num <= 1) return INFEASIBLE;
 		      // Check the sum of supply values
 		      _sum_supply = 0;
 		      for (int i = 0; i != _root; ++i) {
 		        _sum_supply += _supply[i];
+		      }
 		      if (_sum_supply > 0) return INFEASIBLE;
 		      // Initialize vectors
 		      for (int i = 0; i != _res_node_num; ++i) {
 		        _pi[i] = 0;
 		        _excess[i] = _supply[i];
+		      }
 		      // Remove infinite upper bounds and check negative arcs
 		      const Value MAX = std::numeric_limits<Value>::max();
 		      int last_out;
 		      if (_have_lower) {
 		        for (int i = 0; i != _root; ++i) {
 		          last_out = _first_out[i+1];
 		          for (int j = _first_out[i]; j != last_out; ++j) {
 		            if (_forward[j]) {
@@ -880,32 +880,32 @@
 		        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
 		          int ra = _reverse[a];
 		          _res_cap[a] = 0;
 		          _res_cap[ra] = 0;
 		          _cost[a] = 0;
 		          _cost[ra] = 0;
+		        }
+		      }
 		      return OPTIMAL;
+		    }
 		    // Execute the algorithm and transform the results
 		    void start(Method method) {
 		      // Maximum path length for partial augment
 		      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_next.resize(_res_node_num + 1);
 		      _bucket_prev.resize(_res_node_num + 1);
 		      _rank.resize(_res_node_num + 1);
 		      // Execute the algorithm
 		      switch (method) {
 		        case PUSH:
 		          startPush();
 		          break;
 		        case AUGMENT:
 		          startAugment();
 		          break;
@@ -934,17 +934,17 @@
 		      // Handle non-zero lower bounds
 		      if (_have_lower) {
 		        int limit = _first_out[_root];
 		        for (int j = 0; j != limit; ++j) {
 		          if (!_forward[j]) _res_cap[j] += _lower[j];
+		        }
+		      }
+		    }
 		    // Initialize a cost scaling phase
 		    void initPhase() {
 		      // Saturate arcs not satisfying the optimality condition
 		      for (int u = 0; u != _res_node_num; ++u) {
 		        int last_out = _first_out[u+1];
 		        LargeCost pi_u = _pi[u];
 		        for (int a = _first_out[u]; a != last_out; ++a) {
 		          int v = _target[a];
@@ -952,28 +952,28 @@
 		            Value delta = _res_cap[a];
 		            _excess[u] -= delta;
 		            _excess[v] += delta;
 		            _res_cap[a] = 0;
 		            _res_cap[_reverse[a]] += delta;
+		          }
+		        }
+		      }
 		      // Find active nodes (i.e. nodes with positive excess)
 		      for (int u = 0; u != _res_node_num; ++u) {
 		        if (_excess[u] > 0) _active_nodes.push_back(u);
+		      }
 		      // Initialize the next arcs
 		      for (int u = 0; u != _res_node_num; ++u) {
 		        _next_out[u] = _first_out[u];
+		      }
+		    }
 		    // Early termination heuristic
 		    bool earlyTermination() {
 		      const double EARLY_TERM_FACTOR = 3.0;
 		      // Build a static residual graph
 		      _arc_vec.clear();
 		      _cost_vec.clear();
 		      for (int j = 0; j != _res_arc_num; ++j) {
@@ -993,17 +993,17 @@
 		        done = bf.processNextWeakRound();
+		      }
 		      return done;
+		    }
 		    // Global potential update heuristic
 		    void globalUpdate() {
 		      int bucket_end = _root + 1;
 		      // Initialize buckets
 		      for (int r = 0; r != _max_rank; ++r) {
 		        _buckets[r] = bucket_end;
+		      }
 		      Value total_excess = 0;
 		      for (int i = 0; i != _res_node_num; ++i) {
 		        if (_excess[i] < 0) {
 		          _rank[i] = 0;
@@ -1019,47 +1019,47 @@
 		      // Search the buckets
 		      int r = 0;
 		      for ( ; r != _max_rank; ++r) {
 		        while (_buckets[r] != bucket_end) {
 		          // Remove the first node from the current bucket
 		          int u = _buckets[r];
 		          _buckets[r] = _bucket_next[u];
 		          // Search the incomming arcs of u
 		          LargeCost pi_u = _pi[u];
 		          int last_out = _first_out[u+1];
 		          for (int a = _first_out[u]; a != last_out; ++a) {
 		            int ra = _reverse[a];
 		            if (_res_cap[ra] > 0) {
 		              int v = _source[ra];
 		              int old_rank_v = _rank[v];
 		              if (r < old_rank_v) {
 		                // Compute the new rank of v
 		                LargeCost nrc = (_cost[ra] + _pi[v] - pi_u) / _epsilon;
 		                int new_rank_v = old_rank_v;
 		                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) {
 		                    if (_buckets[old_rank_v] == v) {
 		                      _buckets[old_rank_v] = _bucket_next[v];
 		                    } else {
 		                      _bucket_next[_bucket_prev[v]] = _bucket_next[v];
 		                      _bucket_prev[_bucket_next[v]] = _bucket_prev[v];
+		                    }
+		                  }
 		                  // Insert v to its new bucket
 		                  _bucket_next[v] = _buckets[new_rank_v];
 		                  _bucket_prev[_buckets[new_rank_v]] = v;
 		                  _buckets[new_rank_v] = v;
+		                }
+		              }
+		            }
+		          }
@@ -1067,17 +1067,17 @@
 		          // Finish search if there are no more active nodes
 		          if (_excess[u] > 0) {
 		            total_excess -= _excess[u];
 		            if (total_excess <= 0) break;
+		          }
+		        }
 		        if (total_excess <= 0) break;
+		      }
 		      // Relabel nodes
 		      for (int u = 0; u != _res_node_num; ++u) {
 		        int k = std::min(_rank[u], r);
 		        if (k > 0) {
 		          _pi[u] -= _epsilon * k;
 		          _next_out[u] = _first_out[u];
+		        }
+		      }
@@ -1087,32 +1087,32 @@
 		    void startAugment(int max_length = std::numeric_limits<int>::max()) {
 		      // Paramters for heuristics
 		      const int EARLY_TERM_EPSILON_LIMIT = 1000;
 		      const double GLOBAL_UPDATE_FACTOR = 3.0;
 		      const int global_update_freq = int(GLOBAL_UPDATE_FACTOR *
 		        (_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;
 		      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
 : _epsilon / _alpha )
+		      {
 		        // Early termination heuristic
 		        if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {
 		          if (earlyTermination()) break;
+		        }
 		        // Initialize current phase
 		        initPhase();
 		        // Perform partial augment and relabel operations
 		        while (true) {
 		          // Select an active node (FIFO selection)
 		          while (_active_nodes.size() > 0 &&
 		                 _excess[_active_nodes.front()] <= 0) {
 		            _active_nodes.pop_front();
+		          }
 		          if (_active_nodes.size() == 0) break;
@@ -1191,57 +1191,57 @@
 		      const int EARLY_TERM_EPSILON_LIMIT = 1000;
 		      const double GLOBAL_UPDATE_FACTOR = 2.0;
 		      const int global_update_freq = int(GLOBAL_UPDATE_FACTOR *
 		        (_res_node_num + _sup_node_num * _sup_node_num));
 		      int next_update_limit = global_update_freq;
 		      int relabel_cnt = 0;
 		      // Perform cost scaling phases
 		      BoolVector hyper(_res_node_num, false);
 		      LargeCostVector hyper_cost(_res_node_num);
 		      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
 : _epsilon / _alpha )
+		      {
 		        // Early termination heuristic
 		        if (_epsilon <= EARLY_TERM_EPSILON_LIMIT) {
 		          if (earlyTermination()) break;
+		        }
 		        // Initialize current phase
 		        initPhase();
 		        // Perform push and relabel operations
 		        while (_active_nodes.size() > 0) {
 		          LargeCost min_red_cost, rc, pi_n;
 		          Value delta;
 		          int n, t, a, last_out = _res_arc_num;
 		        next_node:
 		          // Select an active node (FIFO selection)
 		          n = _active_nodes.front();
 		          last_out = _first_out[n+1];
 		          pi_n = _pi[n];
 		          // Perform push operations if there are admissible arcs
 		          if (_excess[n] > 0) {
 		            for (a = _next_out[n]; a != last_out; ++a) {
 		              if (_res_cap[a] > 0 &&
 		                  _cost[a] + pi_n - _pi[_target[a]] < 0) {
 		                delta = std::min(_res_cap[a], _excess[n]);
 		                t = _target[a];
 		                // Push-look-ahead heuristic
 		                Value ahead = -_excess[t];
 		                int last_out_t = _first_out[t+1];
 		                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];
 		                  if (ahead >= delta) break;
+		                }
 		                if (ahead < 0) ahead = 0;
 		                // Push flow along the arc
 		                if (ahead < delta && !hyper[t]) {
@@ -1282,25 +1282,25 @@
 		                min_red_cost = rc;
+		              }
+		            }
 		            _pi[n] -= min_red_cost + _epsilon;
 		            _next_out[n] = _first_out[n];
 		            hyper[n] = false;
 		            ++relabel_cnt;
+		          }
 		          // Remove nodes that are not active nor hyper
 		        remove_nodes:
 		          while ( _active_nodes.size() > 0 &&
 		                  _excess[_active_nodes.front()] <= 0 &&
 		                  !hyper[_active_nodes.front()] ) {
 		            _active_nodes.pop_front();
+		          }
 		          // Global update heuristic
 		          if (relabel_cnt >= next_update_limit) {
 		            globalUpdate();
 		            for (int u = 0; u != _res_node_num; ++u)
 		              hyper[u] = false;
 		            next_update_limit += global_update_freq;
+		          }
+		        }

lemon/cplex.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -106,17 +106,17 @@
 		  int CplexBase::_addRow() {
 		    int i = CPXgetnumrows(cplexEnv(), _prob);
 		    const double ub = INF;
 		    const char s = 'L';
 		    CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
 		    return i;
+		  }
-		  int CplexBase::_addRow(Value lb, ExprIterator b,
 		  int CplexBase::_addRow(Value lb, ExprIterator b,
 		                         ExprIterator e, Value ub) {
 		    int i = CPXgetnumrows(cplexEnv(), _prob);
 		    if (lb == -INF) {
 		      const char s = 'L';
 		      CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
 		    } else if (ub == INF) {
 		      const char s = 'G';
 		      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
@@ -484,17 +484,17 @@
 		    case MESSAGE_NORMAL:
 		    case MESSAGE_VERBOSE:
 		      _message_enabled = true;
 		      break;
+		    }
+		  }
 		  void CplexBase::_applyMessageLevel() {
-		    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
 		    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
 		                   _message_enabled ? CPX_ON : CPX_OFF);
+		  }
 		  // CplexLp members
 		  CplexLp::CplexLp()
 		    : LpBase(), LpSolver(), CplexBase() {}

lemon/cycle_canceling.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -137,42 +137,42 @@
 		      /// It is faster both in theory and in practice, its running time
 		      /// complexity is O(n<sup>2</sup>m<sup>2</sup>log(n)).
 		      CANCEL_AND_TIGHTEN
 		    };
 		  private:
 		    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		    typedef std::vector<int> IntVector;
 		    typedef std::vector<double> DoubleVector;
 		    typedef std::vector<Value> ValueVector;
 		    typedef std::vector<Cost> CostVector;
 		    typedef std::vector<char> BoolVector;
 		    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
 		  private:
 		    template <typename KT, typename VT>
 		    class StaticVectorMap {
 		    public:
 		      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)];
+		      }
 		      Value& operator[](const Key& key) {
 		        return _v[StaticDigraph::id(key)];
+		      }
 		      void set(const Key& key, const Value& val) {
 		        _v[StaticDigraph::id(key)] = val;
+		      }
 		    private:
 		      std::vector<Value>& _v;
 		    };
@@ -216,19 +216,19 @@
 		    // Data for a StaticDigraph structure
 		    typedef std::pair<int, int> IntPair;
 		    StaticDigraph _sgr;
 		    std::vector<IntPair> _arc_vec;
 		    std::vector<Cost> _cost_vec;
 		    IntVector _id_vec;
 		    CostArcMap _cost_map;
 		    CostNodeMap _pi_map;
 		  public:
 		    /// \brief Constant for infinite upper bounds (capacities).
 		    ///
 		    /// Constant for infinite upper bounds (capacities).
 		    /// It is \c std::numeric_limits<Value>::infinity() if available,
 		    /// \c std::numeric_limits<Value>::max() otherwise.
 		    const Value INF;
 		  public:
@@ -361,17 +361,17 @@
 		    CycleCanceling& stSupply(const Node& s, const Node& t, Value k) {
 		      for (int i = 0; i != _res_node_num; ++i) {
 		        _supply[i] = 0;
+		      }
 		      _supply[_node_id[s]] =  k;
 		      _supply[_node_id[t]] = -k;
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Execution control
 		    /// The algorithm can be executed using \ref run().
 		    /// @{
 		    /// \brief Run the algorithm.
@@ -461,17 +461,17 @@
 		        _upper[j] = INF;
 		        _cost[j] = _forward[j] ? 1 : -1;
+		      }
 		      for (int j = limit; j != _res_arc_num; ++j) {
 		        _lower[j] = 0;
 		        _upper[j] = INF;
 		        _cost[j] = 0;
 		        _cost[_reverse[j]] = 0;
+		      }
+		      }
 		      _have_lower = false;
 		      return *this;
+		    }
 		    /// \brief Reset the internal data structures and all the parameters
 		    /// that have been given before.
 		    ///
 		    /// This function resets the internal data structures and all the
@@ -503,17 +503,17 @@
 		      _source.resize(_res_arc_num);
 		      _target.resize(_res_arc_num);
 		      _reverse.resize(_res_arc_num);
 		      _lower.resize(_res_arc_num);
 		      _upper.resize(_res_arc_num);
 		      _cost.resize(_res_arc_num);
 		      _supply.resize(_res_node_num);
 		      _res_cap.resize(_res_arc_num);
 		      _pi.resize(_res_node_num);
 		      _arc_vec.reserve(_res_arc_num);
 		      _cost_vec.reserve(_res_arc_num);
 		      _id_vec.reserve(_res_arc_num);
 		      // Copy the graph
@@ -549,17 +549,17 @@
 		      _first_out[i] = j;
 		      _first_out[_res_node_num] = k;
 		      for (ArcIt a(_graph); a != INVALID; ++a) {
 		        int fi = _arc_idf[a];
 		        int bi = _arc_idb[a];
 		        _reverse[fi] = bi;
 		        _reverse[bi] = fi;
+		      }
 		      // Reset parameters
 		      resetParams();
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Query Functions
@@ -658,24 +658,24 @@
 		      if (_res_node_num <= 1) return INFEASIBLE;
 		      // Check the sum of supply values
 		      _sum_supply = 0;
 		      for (int i = 0; i != _root; ++i) {
 		        _sum_supply += _supply[i];
+		      }
 		      if (_sum_supply > 0) return INFEASIBLE;
 		      // Initialize vectors
 		      for (int i = 0; i != _res_node_num; ++i) {
 		        _pi[i] = 0;
+		      }
 		      ValueVector excess(_supply);
 		      // Remove infinite upper bounds and check negative arcs
 		      const Value MAX = std::numeric_limits<Value>::max();
 		      int last_out;
 		      if (_have_lower) {
 		        for (int i = 0; i != _root; ++i) {
 		          last_out = _first_out[i+1];
 		          for (int j = _first_out[i]; j != last_out; ++j) {
 		            if (_forward[j]) {
@@ -765,20 +765,20 @@
 		        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
 		          int ra = _reverse[a];
 		          _res_cap[a] = 1;
 		          _res_cap[ra] = 0;
 		          _cost[a] = 0;
 		          _cost[ra] = 0;
+		        }
+		      }
 		      return OPTIMAL;
+		    }
 		    // Build a StaticDigraph structure containing the current
 		    // residual network
 		    void buildResidualNetwork() {
 		      _arc_vec.clear();
 		      _cost_vec.clear();
 		      _id_vec.clear();
 		      for (int j = 0; j != _res_arc_num; ++j) {
 		        if (_res_cap[j] > 0) {
@@ -824,24 +824,24 @@
+		      }
+		    }
 		    // Execute the "Simple Cycle Canceling" method
 		    void startSimpleCycleCanceling() {
 		      // Constants for computing the iteration limits
 		      const int BF_FIRST_LIMIT  = 2;
 		      const double BF_LIMIT_FACTOR = 1.5;
 		      typedef StaticVectorMap<StaticDigraph::Arc, Value> FilterMap;
 		      typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;
 		      typedef StaticVectorMap<StaticDigraph::Node, StaticDigraph::Arc> PredMap;
 		      typedef typename BellmanFord<ResDigraph, CostArcMap>
 		        ::template SetDistMap<CostNodeMap>
 		        ::template SetPredMap<PredMap>::Create BF;
 		      // Build the residual network
 		      _arc_vec.clear();
 		      _cost_vec.clear();
 		      for (int j = 0; j != _res_arc_num; ++j) {
 		        _arc_vec.push_back(IntPair(_source[j], _target[j]));
 		        _cost_vec.push_back(_cost[j]);
+		      }
 		      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
@@ -921,17 +921,17 @@
+		    }
 		    // Execute the "Minimum Mean Cycle Canceling" method
 		    void startMinMeanCycleCanceling() {
 		      typedef SimplePath<StaticDigraph> SPath;
 		      typedef typename SPath::ArcIt SPathArcIt;
 		      typedef typename HowardMmc<StaticDigraph, CostArcMap>
 		        ::template SetPath<SPath>::Create MMC;
 		      SPath cycle;
 		      MMC mmc(_sgr, _cost_map);
 		      mmc.cycle(cycle);
 		      buildResidualNetwork();
 		      while (mmc.findCycleMean() && mmc.cycleCost() < 0) {
 		        // Find the cycle
 		        mmc.findCycle();
@@ -944,17 +944,17 @@
 		        // Augment along the cycle
 		        for (SPathArcIt a(cycle); a != INVALID; ++a) {
 		          int j = _id_vec[_sgr.id(a)];
 		          _res_cap[j] -= delta;
 		          _res_cap[_reverse[j]] += delta;
+		        }
-		        // Rebuild the residual network
 		        // Rebuild the residual network
 		        buildResidualNetwork();
+		      }
+		    }
 		    // Execute the "Cancel And Tighten" method
 		    void startCancelAndTighten() {
 		      // Constants for the min mean cycle computations
 		      const double LIMIT_FACTOR = 1.0;
@@ -1138,29 +1138,29 @@
 		          // Set epsilon to the minimum cycle mean
 		          buildResidualNetwork();
 		          MMC mmc(_sgr, _cost_map);
 		          mmc.findCycleMean();
 		          epsilon = -mmc.cycleMean();
 		          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) {
 		            _cost_vec[i] = cycle_size * _cost_vec[i] - cycle_cost;
+		          }
 		          BF bf(_sgr, _cost_map);
 		          bf.distMap(_pi_map);
 		          bf.init(0);
 		          bf.start();
 		          for (int u = 0; u != _res_node_num; ++u) {
 		            pi[u] = static_cast<double>(_pi[u]) / cycle_size;
+		          }
 		          iter = limit;
+		        }
+		      }
+		    }
 		  }; //class CycleCanceling
 		  ///@}

lemon/dfs.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -77,17 +77,18 @@
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///This function instantiates a \ref ReachedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
@@ -265,17 +266,18 @@
 		        return 0; // ignore warnings
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///\c ReachedMap type.
 		    ///
 		    ///\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> > {
 		      typedef Dfs< Digraph, SetReachedMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct SetProcessedMapTraits : public Traits {
 		      typedef T ProcessedMap;
@@ -797,17 +799,18 @@
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///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.
 		    ///This function instantiates a ReachedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &g)
+		    {
@@ -1202,17 +1205,18 @@
 		  struct DfsVisitDefaultTraits {
 		    /// \brief The type of the digraph the algorithm runs on.
 		    typedef GR Digraph;
 		    /// \brief The type of the map that indicates which nodes are reached.
 		    ///
 		    /// 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;
 		    /// \brief Instantiates a ReachedMap.
 		    ///
 		    /// This function instantiates a ReachedMap.
 		    /// \param digraph is the digraph, to which
 		    /// we would like to define the ReachedMap.
 		    static ReachedMap *createReachedMap(const Digraph &digraph) {

lemon/dijkstra.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/dimacs.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -56,17 +56,17 @@
 		    int lineShift;
 		    ///Constructor. It sets the type to \c NONE.
 		    DimacsDescriptor() : type(NONE) {}
 		  };
 		  ///Discover the type of a DIMACS file
 		  ///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.
 		  DimacsDescriptor dimacsType(std::istream& is)
+		  {
 		    DimacsDescriptor r;
 		    std::string problem,str;
 		    char c;
 		    r.lineShift=0;
@@ -207,17 +207,17 @@
 		      nodes[k] = g.addNode();
+		    }
 		    typedef typename CapacityMap::Value Capacity;
 		    if(infty==0)
 		      infty = std::numeric_limits<Capacity>::has_infinity ?
 		        std::numeric_limits<Capacity>::infinity() :
 		        std::numeric_limits<Capacity>::max();
 		    while (is >> c) {
 		      switch (c) {
 		      case 'c': // comment line
 		        getline(is, str);
 		        break;
 		      case 'n': // node definition line
 		        if (desc.type==DimacsDescriptor::SP) { // shortest path problem
 		          is >> i;
@@ -232,17 +232,17 @@
+		        }
 		        break;
 		      case 'a': // arc definition line
 		        if (desc.type==DimacsDescriptor::SP) {
 		          is >> i >> j >> _cap;
 		          getline(is, str);
 		          e = g.addArc(nodes[i], nodes[j]);
 		          capacity.set(e, _cap);
+		        }
+		        }
 		        else if (desc.type==DimacsDescriptor::MAX) {
 		          is >> i >> j >> _cap;
 		          getline(is, str);
 		          e = g.addArc(nodes[i], nodes[j]);
 		          if (_cap >= 0)
 		            capacity.set(e, _cap);
 		          else
 		            capacity.set(e, infty);
@@ -357,21 +357,21 @@
+		  }
 		  template<typename Graph>
 		  typename disable_if<lemon::UndirectedTagIndicator<Graph>,void>::type
 		  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,
 		              dummy<1> = 1)
+		  {
 		    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
 		  ///   p mat
 		  /// \endcode
 		  /// At the beginning, \c g is cleared by \c g.clear().
 		  ///
 		  /// If the file type was previously evaluated by dimacsType(), then
 		  /// the descriptor struct should be given by the \c dest parameter.
@@ -387,17 +387,17 @@
 		    std::vector<typename Graph::Node> nodes;
 		    char c;
 		    int i, j;
 		    std::string str;
 		    nodes.resize(desc.nodeNum + 1);
 		    for (int k = 1; k <= desc.nodeNum; ++k) {
 		      nodes[k] = g.addNode();
+		    }
 		    while (is >> c) {
 		      switch (c) {
 		      case 'c': // comment line
 		        getline(is, str);
 		        break;
 		      case 'n': // node definition line
 		        break;
 		      case 'a': // arc definition line

lemon/edge_set.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/euler.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -21,32 +21,32 @@
 		#include<lemon/core.h>
 		#include<lemon/adaptors.h>
 		#include<lemon/connectivity.h>
 		#include <list>
 		/// \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.
 		///
 		///This file provides Euler tour iterators and a function to check
 		///if a (di)graph is \e Eulerian.
 		namespace lemon {
 		  ///Euler tour iterator for digraphs.
 		  /// \ingroup graph_prop
 		  ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
 		  ///graph (if there exists) and it converts to the \c Arc type of the digraph.
 		  ///
 		  ///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.
 		  ///\code
 		  ///  std::vector<ListDigraph::Arc> et;
 		  ///  for(DiEulerIt<ListDigraph> e(g); e!=INVALID; ++e)
 		  ///    et.push_back(e);
 		  ///\endcode
 		  ///If \c g has no Euler tour, then the resulted walk will not be closed
@@ -133,26 +133,26 @@
 		  ///Euler tour iterator for graphs.
 		  /// \ingroup graph_properties
 		  ///This iterator provides an Euler tour (Eulerian circuit) of an
 		  ///\e undirected graph (if there exists) and it converts to the \c Arc
 		  ///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
 		  ///Euler tour of \c g.
 		  ///\code
 		  ///  for(EulerIt<ListGraph> e(g); e!=INVALID; ++e) {
 		  ///    std::cout << g.id(Edge(e)) << std::eol;
 		  ///  }
 		  ///\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.)
 		  ///
 		  ///If \c g has no Euler tour, then the resulted walk will not be closed
 		  ///or not contain all edges.
 		  template<typename GR>
 		  class EulerIt
+		  {
@@ -228,17 +228,17 @@
+		      }
 		      return *this;
+		    }
 		    ///Postfix incrementation
 		    /// 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)
+		    {
 		      Arc e=*this;
 		      ++(*this);
 		      return e;
+		    }
 		  };

lemon/fractional_matching.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
@@ -2004,17 +2004,17 @@
          } break;
        }
      }
      return true;
    }

    /// \brief Run the algorithm.
    ///
    /// This method runs the \c %MaxWeightedPerfectFractionalMatching 
    /// This method runs the \c %MaxWeightedPerfectFractionalMatching
    /// algorithm.
    ///
    /// \note mwfm.run() is just a shortcut of the following code.
    /// \code
    ///   mwpfm.init();
    ///   mwpfm.start();
    /// \endcode
    bool run() {

lemon/full_graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -198,26 +198,26 @@
 		      Parent::notifier(Node()).clear();
 		      construct(n);
 		      Parent::notifier(Node()).build();
 		      Parent::notifier(Arc()).build();
+		    }
 		    /// \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>.
 		    /// The index of a node is the same as its ID.
 		    /// \sa index()
 		    Node operator()(int ix) const { return Parent::operator()(ix); }
 		    /// \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>.
 		    /// The index of a node is the same as its ID.
 		    /// \sa operator()()
 		    static int index(const Node& node) { return Parent::index(node); }
 		    /// \brief Returns the arc connecting the given nodes.
 		    ///
@@ -577,26 +577,26 @@
 		      construct(n);
 		      Parent::notifier(Node()).build();
 		      Parent::notifier(Edge()).build();
 		      Parent::notifier(Arc()).build();
+		    }
 		    /// \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>.
 		    /// The index of a node is the same as its ID.
 		    /// \sa index()
 		    Node operator()(int ix) const { return Parent::operator()(ix); }
 		    /// \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>.
 		    /// The index of a node is the same as its ID.
 		    /// \sa operator()()
 		    static int index(const Node& node) { return Parent::index(node); }
 		    /// \brief Returns the arc connecting the given nodes.
 		    ///

lemon/glpk.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -54,30 +54,30 @@
+		  }
 		  int GlpkBase::_addRow() {
 		    int i = glp_add_rows(lp, 1);
 		    glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0);
 		    return i;
+		  }
-		  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);
 		    if (lo == -INF) {
 		      if (up == INF) {
 		        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
 		      } 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 {
 		        glp_set_row_bnds(lp, i, GLP_FX, lo, up);
+		      }
+		    }
 		    std::vector<int> indexes;
 		    std::vector<Value> values;

lemon/glpk.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -25,26 +25,26 @@
 		#include <lemon/lp_base.h>
 		namespace lemon {
 		  namespace _solver_bits {
 		    class VoidPtr {
 		    private:
-		      void *_ptr;
 		      void *_ptr;
 		    public:
 		      VoidPtr() : _ptr(0) {}
 		      template <typename T>
 		      VoidPtr(T* ptr) : _ptr(reinterpret_cast<void*>(ptr)) {}
 		      template <typename T>
 		      VoidPtr& operator=(T* ptr) {
 		        _ptr = reinterpret_cast<void*>(ptr);
 		      VoidPtr& operator=(T* ptr) {
 		        _ptr = reinterpret_cast<void*>(ptr);
 		        return *this;
+		      }
 		      template <typename T>
 		      operator T*() const { return reinterpret_cast<T*>(_ptr); }
 		    };
+		  }
@@ -119,23 +119,23 @@
 		    static void freeEnv();
 		    struct FreeEnvHelper {
 		      ~FreeEnvHelper() {
 		        freeEnv();
+		      }
 		    };
 		    static FreeEnvHelper freeEnvHelper;
 		  protected:
 		    int _message_level;
 		  public:
 		    ///Pointer to the underlying GLPK data structure.
 		    _solver_bits::VoidPtr lpx() {return lp;}
 		    ///Const pointer to the underlying GLPK data structure.
 		    _solver_bits::VoidPtr lpx() const {return lp;}
 		    ///Returns the constraint identifier understood by GLPK.

lemon/gomory_hu.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -22,197 +22,197 @@
 		#include <limits>
 		#include <lemon/core.h>
 		#include <lemon/preflow.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		/// \ingroup min_cut
-		/// \file
 		/// \file
 		/// \brief Gomory-Hu cut tree in graphs.
 		namespace lemon {
 		  /// \ingroup min_cut
 		  ///
 		  /// \brief Gomory-Hu cut tree algorithm
 		  ///
 		  /// 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
 		  /// this edge from the tree determine the corresponding minimum cut.
 		  /// 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
 		  /// time complexity. It calculates a rooted Gomory-Hu tree.
 		  /// The structure of the tree and the edge weights can be
 		  /// obtained using \c predNode(), \c predValue() and \c rootDist().
 		  /// The functions \c minCutMap() and \c minCutValue() calculate
 		  /// the minimum cut and the minimum cut value between any two nodes
 		  /// in the graph. You can also list (iterate on) the nodes and the
 		  /// edges of the cuts using \c MinCutNodeIt and \c MinCutEdgeIt.
 		  ///
 		  /// \tparam GR The type of the undirected graph the algorithm runs on.
 		  /// \tparam CAP The type of the edge map containing the capacities.
 		  /// The default map type is \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 		#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 {
 		  public:
 		    /// The graph type of the algorithm
 		    typedef GR Graph;
 		    /// The capacity map type of the algorithm
 		    typedef CAP Capacity;
 		    /// The value type of capacities
 		    typedef typename Capacity::Value Value;
 		  private:
 		    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		    const Graph& _graph;
 		    const Capacity& _capacity;
 		    Node _root;
 		    typename Graph::template NodeMap<Node>* _pred;
 		    typename Graph::template NodeMap<Value>* _weight;
 		    typename Graph::template NodeMap<int>* _order;
 		    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:
 		    /// \brief Constructor
 		    ///
 		    /// Constructor.
 		    /// \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>();
+		    }
 		    /// \brief Destructor
 		    ///
 		    /// Destructor.
 		    ~GomoryHu() {
 		      destroyStructures();
+		    }
 		  private:
 		    // Initialize the internal data structures
 		    void init() {
 		      createStructures();
 		      _root = NodeIt(_graph);
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
 		        (*_pred)[n] = _root;
 		        (*_order)[n] = -1;
+		      }
 		      (*_pred)[_root] = INVALID;
-		      (*_weight)[_root] = std::numeric_limits<Value>::max();
 		      (*_weight)[_root] = std::numeric_limits<Value>::max();
+		    }
 		    // Start the algorithm
 		    void start() {
 		      Preflow<Graph, Capacity> fa(_graph, _capacity, _root, INVALID);
 		      for (NodeIt n(_graph); n != INVALID; ++n) {
-			if (n == _root) continue;
+		        if (n == _root) continue;
 			Node pn = (*_pred)[n];
 			fa.source(n);
-			fa.target(pn);
+		        Node pn = (*_pred)[n];
 		        fa.source(n);
 		        fa.target(pn);
-			fa.runMinCut();
+		        fa.runMinCut();
-			(*_weight)[n] = fa.flowValue();
+		        (*_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 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();
+		        }
+		      }
 		      (*_order)[_root] = 0;
 		      int index = 1;
 		      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();
+		        }
+		      }
+		    }
 		  public:
 		    ///\name Execution Control
 		    ///@{
 		    /// \brief Run the Gomory-Hu algorithm.
 		    ///
 		    /// This function runs the Gomory-Hu algorithm.
 		    void run() {
 		      init();
 		      start();
+		    }
 		    /// @}
 		    ///\name Query Functions
 		    ///The results of the algorithm can be obtained using these
 		    ///functions.\n
 		    ///\ref run() should be called before using them.\n
 		    ///See also \ref MinCutNodeIt and \ref MinCutEdgeIt.
@@ -227,17 +227,17 @@
 		    /// \pre \ref run() must be called before using this function.
 		    Node predNode(const Node& node) const {
 		      return (*_pred)[node];
+		    }
 		    /// \brief Return the weight of the predecessor edge in the
 		    /// 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.
 		    ///
 		    /// \pre \ref run() must be called before using this function.
 		    Value predValue(const Node& node) const {
 		      return (*_weight)[node];
+		    }
@@ -249,34 +249,34 @@
 		    /// \pre \ref run() must be called before using this function.
 		    int rootDist(const Node& node) const {
 		      return (*_order)[node];
+		    }
 		    /// \brief Return the minimum cut value between two nodes
 		    ///
 		    /// 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
 		    /// paths to the ancestor.
 		    ///
 		    /// \pre \ref run() must be called before using this function.
 		    Value minCutValue(const Node& s, const Node& t) const {
 		      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;
+		    }
 		    /// \brief Return the minimum cut between two nodes
 		    ///
 		    /// This function returns the minimum cut between the nodes \c s and \c t
 		    /// in the \c cutMap parameter by setting the nodes in the component of
@@ -297,64 +297,64 @@
 		    Value minCutMap(const Node& s,
 		                    const Node& t,
 		                    CutMap& cutMap
 		                    ) const {
 		      Node sn = s, tn = t;
 		      bool s_root=false;
 		      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];
+		        }
+		      }
 		      typename Graph::template NodeMap<bool> reached(_graph, false);
 		      reached[_root] = true;
 		      cutMap.set(_root, !s_root);
 		      reached[rn] = true;
 		      cutMap.set(rn, s_root);
 		      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;
+		    }
 		    ///@}
 		    friend class MinCutNodeIt;
 		    /// 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
 		    /// and call its \ref GomoryHu::run() "run()" method.
 		    ///
 		    /// This example counts the nodes in the minimum cut separating \c s from
 		    /// \c t.
 		    /// \code
 		    /// GomoryHu<Graph> gom(g, capacities);
@@ -437,21 +437,21 @@
 		      /// expect.
 		      typename Graph::Node operator++(int)
+		      {
 		        typename Graph::Node n=*this;
 		        ++(*this);
 		        return n;
+		      }
 		    };
 		    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
 		    /// and call its \ref GomoryHu::run() "run()" method.
 		    ///
 		    /// This example computes the value of the minimum cut separating \c s from
 		    /// \c t.
 		    /// \code
 		    /// GomoryHu<Graph> gom(g, capacities);
@@ -474,17 +474,17 @@
 		        ++_arc_it;
 		        while(_node_it!=INVALID && _arc_it==INVALID)
+		          {
 		            for(++_node_it;_node_it!=INVALID&&!_cut[_node_it];++_node_it) {}
 		            if(_node_it!=INVALID)
 		              _arc_it=typename Graph::OutArcIt(_graph,_node_it);
+		          }
+		      }
 		    public:
 		      /// Constructor
 		      /// Constructor.
 		      ///
 		      MinCutEdgeIt(GomoryHu const &gomory,
 		                   ///< The GomoryHu class. You must call its
 		                   ///  run() method
@@ -543,17 +543,17 @@
 		      ///
 		      MinCutEdgeIt &operator++()
+		      {
 		        step();
 		        while(_arc_it!=INVALID && _cut[_graph.target(_arc_it)]) step();
 		        return *this;
+		      }
 		      /// Postfix incrementation
 		      /// Postfix incrementation.
 		      ///
 		      /// \warning This incrementation
 		      /// returns an \c Arc, not a \c MinCutEdgeIt, as one may expect.
 		      typename Graph::Arc operator++(int)
+		      {
 		        typename Graph::Arc e=*this;
 		        ++(*this);

lemon/graph_to_eps.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/hao_orlin.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -26,44 +26,44 @@
 		#include <lemon/maps.h>
 		#include <lemon/core.h>
 		#include <lemon/tolerance.h>
 		/// \file
 		/// \ingroup min_cut
 		/// \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.
 		namespace lemon {
 		  /// \ingroup min_cut
 		  ///
 		  /// \brief 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
 		  /// minimum cut with \f$ source \f$ on the source-side (i.e. a set
 		  /// \f$ X\subsetneq V \f$ with \f$ source \in X \f$ and minimal outgoing
 		  /// capacity) and in the second phase it determines a minimum cut
 		  /// with \f$ source \f$ on the sink-side (i.e. a set
 		  /// \f$ X\subsetneq V \f$ with \f$ source \notin X \f$ and minimal outgoing
 		  /// capacity). Obviously, the smaller of these two cuts will be a
 		  /// minimum cut of \f$ D \f$. The algorithm is a modified
 		  /// preflow push-relabel algorithm. Our implementation calculates
 		  /// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the
 		  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. The
 		  /// purpose of such algorithm is e.g. testing network reliability.
 		  ///
 		  /// 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.
 		  ///
 		  /// \tparam GR The type of the digraph the algorithm runs on.
 		  /// \tparam CAP The type of the arc map containing the capacities,
 		  /// which can be any numreric type. The default map type is
 		  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 		  /// \tparam TOL Tolerance class for handling inexact computations. The
 		  /// default tolerance type is \ref Tolerance "Tolerance<CAP::Value>".
@@ -71,17 +71,17 @@
 		  template <typename GR, typename CAP, typename TOL>
 		#else
 		  template <typename GR,
 		            typename CAP = typename GR::template ArcMap<int>,
 		            typename TOL = Tolerance<typename CAP::Value> >
 		#endif
 		  class HaoOrlin {
 		  public:
 		    /// The digraph type of the algorithm
 		    typedef GR Digraph;
 		    /// The capacity map type of the algorithm
 		    typedef CAP CapacityMap;
 		    /// The tolerance type of the algorithm
 		    typedef TOL Tolerance;
 		  private:
@@ -859,17 +859,17 @@
 		    /// algorithm.
 		    void init() {
 		      init(NodeIt(_graph));
+		    }
 		    /// \brief Initialize the internal data structures.
 		    ///
 		    /// 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.
 		    void init(const Node& source) {
 		      _source = source;
 		      _node_num = countNodes(_graph);
 		      _first.resize(_node_num);
@@ -939,40 +939,40 @@
 		    void run() {
 		      init();
 		      calculateOut();
 		      calculateIn();
+		    }
 		    /// \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().
 		    void run(const Node& s) {
 		      init(s);
 		      calculateOut();
 		      calculateIn();
+		    }
 		    /// @}
 		    /// \name Query Functions
 		    /// 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.
 		    /// @{
 		    /// \brief Return the value of the minimum cut.
 		    ///
 		    /// 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 _min_cut;
+		    }
 		    /// \brief Return a minimum cut.
 		    ///
@@ -981,17 +981,17 @@
 		    /// with minimal outgoing capacity (i.e. \c cutMap will be \c true exactly
 		    /// for the nodes of \f$ X \f$).
 		    ///
 		    /// \param cutMap A \ref concepts::WriteMap "writable" node map with
 		    /// \c bool (or convertible) value type.
 		    ///
 		    /// \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>
 		    Value minCutMap(CutMap& cutMap) const {
 		      for (NodeIt it(_graph); it != INVALID; ++it) {
 		        cutMap.set(it, (*_min_cut_map)[it]);
+		      }
 		      return _min_cut;
+		    }

lemon/hartmann_orlin_mmc.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -338,24 +338,24 @@
 		    /// This function finds the minimum mean cost of the directed
 		    /// cycles in the digraph.
 		    ///
 		    /// \return \c true if a directed cycle exists in the digraph.
 		    bool findCycleMean() {
 		      // Initialization and find strongly connected components
 		      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;
 		          _best_cost = _curr_cost;
 		          _best_size = _curr_size;
 		          _best_node = _curr_node;
 		          _best_level = _curr_level;
+		        }
+		      }
@@ -498,17 +498,17 @@
+		    }
 		    // Initialize path data for the current component
 		    bool initComponent(int comp) {
 		      _nodes = &(_comp_nodes[comp]);
 		      int n = _nodes->size();
 		      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));
+		      }
 		      return true;
+		    }
 		    // Process all rounds of computing path data for the current component.
 		    // _data[v][k] is the cost of a shortest directed walk from the root
@@ -571,27 +571,27 @@
 		          v = _gr.target(e);
 		          d = _data[u][k-1].dist + _cost[e];
 		          if (_tolerance.less(d, _data[v][k].dist)) {
 		            _data[v][k] = PathData(d, e);
+		          }
+		        }
+		      }
+		    }
 		    // Check early termination
 		    bool checkTermination(int k) {
 		      typedef std::pair<int, int> Pair;
 		      typename GR::template NodeMap<Pair> level(_gr, Pair(-1, 0));
 		      typename GR::template NodeMap<LargeCost> pi(_gr);
 		      int n = _nodes->size();
 		      LargeCost cost;
 		      int size;
 		      Node u;
 		      // Search for cycles that are already found
 		      _curr_found = false;
 		      for (int i = 0; i < n; ++i) {
 		        u = (*_nodes)[i];
 		        if (_data[u][k].dist == INF) continue;
 		        for (int j = k; j >= 0; --j) {
 		          if (level[u].first == i && level[u].second > 0) {
 		            // A cycle is found
@@ -602,18 +602,18 @@
 		              _curr_size = size;
 		              _curr_node = u;
 		              _curr_level = level[u].second;
 		              _curr_found = true;
+		            }
+		          }
 		          level[u] = Pair(i, j);
 		          if (j != 0) {
 			    u = _gr.source(_data[u][j].pred);
+			  }
 		            u = _gr.source(_data[u][j].pred);
+		          }
+		        }
+		      }
 		      // If at least one cycle is found, check the optimality condition
 		      LargeCost d;
 		      if (_curr_found && k < n) {
 		        // Find node potentials
 		        for (int i = 0; i < n; ++i) {

lemon/howard_mmc.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -116,17 +116,17 @@
 		#else
 		  template < typename GR,
 		             typename CM = typename GR::template ArcMap<int>,
 		             typename TR = HowardMmcDefaultTraits<GR, CM> >
 		#endif
 		  class HowardMmc
+		  {
 		  public:
 		    /// The type of the digraph
 		    typedef typename TR::Digraph Digraph;
 		    /// The type of the cost map
 		    typedef typename TR::CostMap CostMap;
 		    /// The type of the arc costs
 		    typedef typename TR::Cost Cost;
 		    /// \brief The large cost type
@@ -147,17 +147,17 @@
 		    typedef typename TR::Path Path;
 		    /// The \ref HowardMmcDefaultTraits "traits class" of the algorithm
 		    typedef TR Traits;
 		  private:
 		    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 		    // The digraph the algorithm runs on
 		    const Digraph &_gr;
 		    // The cost of the arcs
 		    const CostMap &_cost;
 		    // Data for the found cycles
 		    bool _curr_found, _best_found;
 		    LargeCost _curr_cost, _best_cost;
@@ -174,28 +174,28 @@
 		    typename Digraph::template NodeMap<LargeCost> _dist;
 		    // Data for storing the strongly connected components
 		    int _comp_num;
 		    typename Digraph::template NodeMap<int> _comp;
 		    std::vector<std::vector<Node> > _comp_nodes;
 		    std::vector<Node>* _nodes;
 		    typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;
 		    // Queue used for BFS search
 		    std::vector<Node> _queue;
 		    int _qfront, _qback;
 		    Tolerance _tolerance;
 		    // Infinite constant
 		    const LargeCost INF;
 		  public:
 		    /// \name Named Template Parameters
 		    /// @{
 		    template <typename T>
 		    struct SetLargeCostTraits : public Traits {
 		      typedef T LargeCost;
 		      typedef lemon::Tolerance<T> Tolerance;
 		    };
@@ -223,17 +223,17 @@
 		    /// type of the found cycles.
 		    /// It must conform to the \ref lemon::concepts::Path "Path" concept
 		    /// and it must have an \c addBack() function.
 		    template <typename T>
 		    struct SetPath
 		      : public HowardMmc<GR, CM, SetPathTraits<T> > {
 		      typedef HowardMmc<GR, CM, SetPathTraits<T> > Create;
 		    };
 		    /// @}
 		  protected:
 		    HowardMmc() {}
 		  public:
@@ -329,17 +329,17 @@
 		    /// This function finds the minimum mean cost of the directed
 		    /// cycles in the digraph.
 		    ///
 		    /// \return \c true if a directed cycle exists in the digraph.
 		    bool findCycleMean() {
 		      // Initialize and find strongly connected components
 		      init();
 		      findComponents();
 		      // Find the minimum cycle mean in the components
 		      for (int comp = 0; comp < _comp_num; ++comp) {
 		        // Find the minimum mean cycle in the current component
 		        if (!buildPolicyGraph(comp)) continue;
 		        while (true) {
 		          findPolicyCycle();
 		          if (!computeNodeDistances()) break;
+		        }
@@ -440,17 +440,17 @@
 		        _cycle_path = new Path;
+		      }
 		      _queue.resize(countNodes(_gr));
 		      _best_found = false;
 		      _best_cost = 0;
 		      _best_size = 1;
 		      _cycle_path->clear();
+		    }
 		    // Find strongly connected components and initialize _comp_nodes
 		    // and _in_arcs
 		    void findComponents() {
 		      _comp_num = stronglyConnectedComponents(_gr, _comp);
 		      _comp_nodes.resize(_comp_num);
 		      if (_comp_num == 1) {
 		        _comp_nodes[0].clear();
 		        for (NodeIt n(_gr); n != INVALID; ++n) {

lemon/karp_mmc.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -186,17 +186,17 @@
 		    bool _local_path;
 		    // Node map for storing path data
 		    PathDataNodeMap _data;
 		    // The processed nodes in the last round
 		    std::vector<Node> _process;
 		    Tolerance _tolerance;
 		    // Infinite constant
 		    const LargeCost INF;
 		  public:
 		    /// \name Named Template Parameters
 		    /// @{
@@ -334,17 +334,17 @@
 		    /// This function finds the minimum mean cost of the directed
 		    /// cycles in the digraph.
 		    ///
 		    /// \return \c true if a directed cycle exists in the digraph.
 		    bool findCycleMean() {
 		      // Initialization and find strongly connected components
 		      init();
 		      findComponents();
 		      // Find the minimum cycle mean in the components
 		      for (int comp = 0; comp < _comp_num; ++comp) {
 		        if (!initComponent(comp)) continue;
 		        processRounds();
 		        updateMinMean();
+		      }
 		      return (_cycle_node != INVALID);
+		    }
@@ -484,17 +484,17 @@
+		    }
 		    // Initialize path data for the current component
 		    bool initComponent(int comp) {
 		      _nodes = &(_comp_nodes[comp]);
 		      int n = _nodes->size();
 		      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));
+		      }
 		      return true;
+		    }
 		    // Process all rounds of computing path data for the current component.
 		    // _data[v][k] is the cost of a shortest directed walk from the root

lemon/lgf_reader.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -557,17 +557,17 @@
+		    }
 		  private:
 		    template <typename TDGR>
 		    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>
 		    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, const char *fn);
 		    DigraphReader(DigraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _digraph(other._digraph),
 		        _use_nodes(other._use_nodes), _use_arcs(other._use_arcs),
 		        _skip_nodes(other._skip_nodes), _skip_arcs(other._skip_arcs) {
@@ -1182,24 +1182,24 @@
 		        throw FormatError("Section @attributes not found");
+		      }
+		    }
 		    /// @}
 		  };
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief Return a \ref DigraphReader class
 		  ///
 		  /// 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
 		  /// digraph, i.e. a digraph with a \e capacity map on the arcs and
 		  /// \e source and \e target nodes. This digraph can be read with the
 		  /// following code:
 		  ///
 		  ///\code
 		  ///ListDigraph digraph;
@@ -1244,17 +1244,17 @@
 		  template <typename TDGR>
 		  DigraphReader<TDGR> digraphReader(TDGR& digraph, const char* fn) {
 		    DigraphReader<TDGR> tmp(digraph, fn);
 		    return tmp;
+		  }
 		  template <typename GR>
 		  class GraphReader;
 		  template <typename TGR>
 		  GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
 		  template <typename TGR>
 		  GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
 		  template <typename TGR>
 		  GraphReader<TGR> graphReader(TGR& graph, const char *fn);
 		  /// \ingroup lemon_io
@@ -1381,17 +1381,17 @@
+		      }
+		    }
 		  private:
 		    template <typename TGR>
 		    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);
 		    GraphReader(GraphReader& other)
 		      : _is(other._is), local_is(other.local_is), _graph(other._graph),
 		        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
 		        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
@@ -2058,19 +2058,19 @@
 		    /// @}
 		  };
 		  /// \ingroup lemon_io
 		  ///
 		  /// \brief Return a \ref GraphReader class
 		  ///
-		  /// This function just returns a \ref GraphReader class.
 		  /// This function just returns a \ref GraphReader class.
 		  ///
-		  /// With this function a graph can be read from an
 		  /// 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
 		  /// graph, i.e. a graph with a \e weight map on the edges. This
 		  /// graph can be read with the following code:
 		  ///
 		  ///\code
 		  ///ListGraph graph;
 		  ///ListGraph::EdgeMap<int> weight(graph);

lemon/lgf_writer.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -346,17 +346,17 @@
 		    };
+		  }
 		  template <typename DGR>
 		  class DigraphWriter;
 		  template <typename TDGR>
-		  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 		  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 		                                   std::ostream& os = std::cout);
 		  template <typename TDGR>
 		  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const std::string& fn);
 		  template <typename TDGR>
 		  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, const char* fn);
@@ -499,17 +499,17 @@
 		      if (local_os) {
 		        delete _os;
+		      }
+		    }
 		  private:
 		    template <typename TDGR>
-		    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 		    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 		                                             std::ostream& os);
 		    template <typename TDGR>
 		    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 		                                             const std::string& fn);
 		    template <typename TDGR>
 		    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
 		                                             const char *fn);
@@ -912,17 +912,17 @@
 		    /// @}
 		  };
 		  /// \ingroup lemon_io
 		  ///
 		  /// \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
 		  /// stream in \ref lgf-format "LGF" format with several maps and
 		  /// attributes. For example, with the following code a network flow
 		  /// problem can be written to the standard output, i.e. a digraph
 		  /// with a \e capacity map on the arcs and \e source and \e target
 		  /// nodes:
 		  ///
@@ -952,17 +952,17 @@
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
 		  /// \relates DigraphWriter
 		  /// \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);
 		    return tmp;
+		  }
 		  /// \brief Return a \ref DigraphWriter class
 		  ///
 		  /// This function just returns a \ref DigraphWriter class.
@@ -1096,21 +1096,21 @@
+		      }
+		    }
 		  private:
 		    template <typename TGR>
 		    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),
 		        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 		      other._os = 0;
 		      other.local_os = false;
 		      _node_index.swap(other._node_index);
@@ -1551,17 +1551,17 @@
 		    /// @}
 		  };
 		  /// \ingroup lemon_io
 		  ///
 		  /// \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
 		  /// stream in \ref lgf-format "LGF" format with several maps and
 		  /// attributes. For example, with the following code a weighted
 		  /// matching problem can be written to the standard output, i.e. a
 		  /// graph with a \e weight map on the edges:
 		  ///
 		  ///\code

lemon/list_graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -441,17 +441,17 @@
 		    ///incident arcs, they are joined to node \c u.
 		    ///If the last parameter \c r is \c true (this is the default value),
 		    ///then the newly created loops are removed.
 		    ///
 		    ///\note The moved arcs are joined to node \c u using changeSource()
 		    ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
 		    ///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.
 		    ///
 		    ///\warning This functionality cannot be used together with the Snapshot
 		    ///feature.
 		    void contract(Node u, Node v, bool r = true)
+		    {
 		      for(OutArcIt e(*this,v);e!=INVALID;) {
 		        OutArcIt f=e;
@@ -547,17 +547,17 @@
 		    /// \brief Class to make a snapshot of the digraph and restore
 		    /// it later.
 		    ///
 		    /// Class to make a snapshot of the digraph and restore it later.
 		    ///
 		    /// The newly added nodes and arcs can be removed 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 arcs again using
 		    /// another Snapshot instance.
 		    ///
 		    /// \warning Node and arc deletions and other modifications (e.g.
 		    /// reversing, contracting, splitting arcs or nodes) cannot be
 		    /// restored. These events invalidate the snapshot.
 		    /// However, the arcs and nodes that were added to the digraph after
 		    /// making the current snapshot can be removed without invalidating it.
@@ -1302,17 +1302,17 @@
 		    /// Node \c b is removed, but instead of deleting
 		    /// its incident edges, they are joined to node \c a.
 		    /// If the last parameter \c r is \c true (this is the default value),
 		    /// then the newly created loops are removed.
 		    ///
 		    /// \note The moved edges are joined to node \c a using changeU()
 		    /// 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.
 		    ///
 		    ///\warning This functionality cannot be used together with the
 		    ///Snapshot feature.
 		    void contract(Node a, Node b, bool r = true) {
 		      for(IncEdgeIt e(*this, b); e!=INVALID;) {
 		        IncEdgeIt f = e; ++f;
 		        if (r && runningNode(e) == a) {
@@ -1359,17 +1359,17 @@
 		    /// \brief Class to make a snapshot of the graph and restore
 		    /// it later.
 		    ///
 		    /// Class to make a snapshot of the graph and restore it later.
 		    ///
 		    /// The newly added nodes and edges can be removed
 		    /// 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.
 		    ///
 		    /// \warning Node and edge deletions and other modifications
 		    /// (e.g. changing the end-nodes of edges or contracting nodes)
 		    /// cannot be restored. These events invalidate the snapshot.
 		    /// However, the edges and nodes that were added to the graph after
 		    /// making the current snapshot can be removed without invalidating it.

lemon/lp.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -79,15 +79,15 @@
 		  typedef CplexLp Lp;
 		# define LEMON_DEFAULT_MIP CPLEX
 		  typedef CplexMip Mip;
 		#elif LEMON_HAVE_SOPLEX
 		# define DEFAULT_LP SOPLEX
 		  typedef SoplexLp Lp;
 		#elif LEMON_HAVE_CLP
 		# define DEFAULT_LP CLP
-		  typedef ClpLp Lp;
 		  typedef ClpLp Lp;
 		#endif
 		#endif
 		} //namespace lemon
 		#endif //LEMON_LP_H

lemon/lp_base.cc

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/lp_base.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -77,17 +77,17 @@
 		      MESSAGE_ERROR,
 		      /// Warnings.
 		      MESSAGE_WARNING,
 		      /// Normal output.
 		      MESSAGE_NORMAL,
 		      /// Verbose output.
 		      MESSAGE_VERBOSE
 		    };
 		    ///The floating point type used by the solver
 		    typedef double Value;
 		    ///The infinity constant
 		    static const Value INF;
 		    ///The not a number constant
 		    static const Value NaN;
@@ -109,24 +109,24 @@
 		      friend class LpBase;
 		    protected:
 		      int _id;
 		      explicit Col(int id) : _id(id) {}
 		    public:
 		      typedef Value ExprValue;
 		      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
 		      /// Two \ref Col "Col"s are equal if and only if they point to
 		      /// the same LP column or both are invalid.
 		      bool operator==(Col c) const  {return _id == c._id;}
 		      /// Inequality operator
@@ -151,35 +151,35 @@
 		    ///\code
 		    /// int count=0;
 		    /// for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
 		    ///\endcode
 		    class ColIt : public Col {
 		      const LpBase *_solver;
 		    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.
 		      ///
 		      ColIt(const LpBase &solver) : _solver(&solver)
+		      {
 		        _solver->cols.firstItem(_id);
+		      }
 		      /// 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.
 		      ///
 		      ColIt &operator++()
+		      {
 		        _solver->cols.nextItem(_id);
 		        return *this;
+		      }
 		    };
@@ -204,32 +204,32 @@
 		      friend class LpBase;
 		    protected:
 		      int _id;
 		      explicit Row(int id) : _id(id) {}
 		    public:
 		      typedef Value ExprValue;
 		      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
 		      /// Two \ref Row "Row"s are equal if and only if they point to
 		      /// the same LP row or both are invalid.
 		      bool operator==(Row r) const  {return _id == r._id;}
 		      /// Inequality operator
 		      /// \sa operator==(Row r)
 		      ///
 		      bool operator!=(Row r) const  {return _id != r._id;}
 		      /// Artificial ordering operator.
 		      /// To allow the use of this object in std::map or similar
 		      /// associative container we require this.
 		      ///
@@ -246,35 +246,35 @@
 		    ///\code
 		    /// int count=0;
 		    /// for (LpBase::RowIt c(lp); c!=INVALID; ++c) ++count;
 		    ///\endcode
 		    class RowIt : public Row {
 		      const LpBase *_solver;
 		    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.
 		      ///
 		      RowIt(const LpBase &solver) : _solver(&solver)
+		      {
 		        _solver->rows.firstItem(_id);
+		      }
 		      /// 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.
 		      ///
 		      RowIt &operator++()
+		      {
 		        _solver->rows.nextItem(_id);
 		        return *this;
+		      }
 		    };
@@ -342,17 +342,17 @@
 		    protected:
 		      Value const_comp;
 		      std::map<int, Value> comps;
 		    public:
 		      typedef True SolverExpr;
 		      /// Default constructor
 		      /// Construct an empty expression, the coefficients and
 		      /// the constant component are initialized to zero.
 		      Expr() : const_comp(0) {}
 		      /// Construct an expression from a column
 		      /// Construct an expression, which has a term with \c c variable
 		      /// and 1.0 coefficient.
 		      Expr(const Col &c) : const_comp(0) {
@@ -443,93 +443,93 @@
 		        for (std::map<int, Value>::iterator it=comps.begin();
 		             it!=comps.end(); ++it)
 		          it->second/=c;
 		        const_comp/=c;
 		        return *this;
+		      }
 		      ///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;
 		      ///for(LpBase::Expr::CoeffIt i(e);i!=INVALID;++i)
 		      ///  s+= *i * primal(i);
 		      ///\endcode
 		      class CoeffIt {
 		      private:
 		        std::map<int, Value>::iterator _it, _end;
 		      public:
 		        /// Sets the iterator to the first term
 		        /// Sets the iterator to the first term of the expression.
 		        ///
 		        CoeffIt(Expr& e)
 		          : _it(e.comps.begin()), _end(e.comps.end()){}
 		        /// Convert the iterator to the column of the term
 		        operator Col() const {
 		          return colFromId(_it->first);
+		        }
 		        /// Returns the coefficient of the term
 		        Value& operator*() { return _it->second; }
 		        /// Returns the coefficient of the term
 		        const Value& operator*() const { return _it->second; }
 		        /// Next term
 		        /// Assign the iterator to the next term.
 		        ///
 		        CoeffIt& operator++() { ++_it; return *this; }
 		        /// Equality operator
 		        bool operator==(Invalid) const { return _it == _end; }
 		        /// Inequality operator
 		        bool operator!=(Invalid) const { return _it != _end; }
 		      };
 		      /// 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;
 		      ///for(LpBase::Expr::ConstCoeffIt i(e);i!=INVALID;++i)
 		      ///  s+=*i * primal(i);
 		      ///\endcode
 		      class ConstCoeffIt {
 		      private:
 		        std::map<int, Value>::const_iterator _it, _end;
 		      public:
 		        /// Sets the iterator to the first term
 		        /// Sets the iterator to the first term of the expression.
 		        ///
 		        ConstCoeffIt(const Expr& e)
 		          : _it(e.comps.begin()), _end(e.comps.end()){}
 		        /// Convert the iterator to the column of the term
 		        operator Col() const {
 		          return colFromId(_it->first);
+		        }
 		        /// Returns the coefficient of the term
 		        const Value& operator*() const { return _it->second; }
 		        /// Next term
 		        /// Assign the iterator to the next term.
 		        ///
 		        ConstCoeffIt& operator++() { ++_it; return *this; }
 		        /// Equality operator
 		        bool operator==(Invalid) const { return _it == _end; }
 		        /// Inequality operator
 		        bool operator!=(Invalid) const { return _it != _end; }
@@ -668,17 +668,17 @@
 		      typedef LpBase::Value Value;
 		    protected:
 		      std::map<int, Value> comps;
 		    public:
 		      typedef True SolverExpr;
 		      /// Default constructor
 		      /// Construct an empty expression, the coefficients are
 		      /// initialized to zero.
 		      DualExpr() {}
 		      /// Construct an expression from a row
 		      /// Construct an expression, which has a term with \c r dual
 		      /// variable and 1.0 coefficient.
 		      DualExpr(const Row &r) {
@@ -703,17 +703,17 @@
 		        if (v != 0.0) {
 		          typedef std::map<int, Value>::value_type pair_type;
 		          comps.insert(pair_type(id(r), v));
 		        } else {
 		          comps.erase(id(r));
+		        }
+		      }
 		      /// \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();
 		        while (it != comps.end()) {
 		          std::map<int, Value>::iterator jt=it;
 		          ++jt;
 		          if (std::fabs((*it).second) <= epsilon) comps.erase(it);
 		          it=jt;
+		        }
@@ -752,33 +752,33 @@
 		      DualExpr &operator/=(const Value &v) {
 		        for (std::map<int, Value>::iterator it=comps.begin();
 		             it!=comps.end(); ++it)
 		          it->second/=v;
 		        return *this;
+		      }
 		      ///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;
 		      ///for(LpBase::DualExpr::CoeffIt i(e);i!=INVALID;++i)
 		      ///  s+= *i * dual(i);
 		      ///\endcode
 		      class CoeffIt {
 		      private:
 		        std::map<int, Value>::iterator _it, _end;
 		      public:
 		        /// Sets the iterator to the first term
 		        /// Sets the iterator to the first term of the expression.
 		        ///
 		        CoeffIt(DualExpr& e)
 		          : _it(e.comps.begin()), _end(e.comps.end()){}
 		        /// Convert the iterator to the row of the term
 		        operator Row() const {
 		          return rowFromId(_it->first);
@@ -786,60 +786,60 @@
 		        /// Returns the coefficient of the term
 		        Value& operator*() { return _it->second; }
 		        /// Returns the coefficient of the term
 		        const Value& operator*() const { return _it->second; }
 		        /// Next term
 		        /// Assign the iterator to the next term.
 		        ///
 		        CoeffIt& operator++() { ++_it; return *this; }
 		        /// Equality operator
 		        bool operator==(Invalid) const { return _it == _end; }
 		        /// Inequality operator
 		        bool operator!=(Invalid) const { return _it != _end; }
 		      };
 		      ///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;
 		      ///for(LpBase::DualExpr::ConstCoeffIt i(e);i!=INVALID;++i)
 		      ///  s+= *i * dual(i);
 		      ///\endcode
 		      class ConstCoeffIt {
 		      private:
 		        std::map<int, Value>::const_iterator _it, _end;
 		      public:
 		        /// Sets the iterator to the first term
 		        /// Sets the iterator to the first term of the expression.
 		        ///
 		        ConstCoeffIt(const DualExpr& e)
 		          : _it(e.comps.begin()), _end(e.comps.end()){}
 		        /// Convert the iterator to the row of the term
 		        operator Row() const {
 		          return rowFromId(_it->first);
+		        }
 		        /// Returns the coefficient of the term
 		        const Value& operator*() const { return _it->second; }
 		        /// Next term
 		        /// Assign the iterator to the next term.
 		        ///
 		        ConstCoeffIt& operator++() { ++_it; return *this; }
 		        /// Equality operator
 		        bool operator==(Invalid) const { return _it == _end; }
 		        /// Inequality operator
 		        bool operator!=(Invalid) const { return _it != _end; }
@@ -1224,17 +1224,17 @@
 		    ///Add a new row (i.e a new constraint) to the LP
 		    ///\param c is a linear expression (see \ref Constr)
 		    ///\return The created row.
 		    Row addRow(const Constr &c) {
 		      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),
 		                                c.upperBounded()?c.upperBound()-*c.expr():INF));
 		      return r;
+		    }
 		    ///Erase a column (i.e a variable) from the LP
 		    ///\param c is the column to be deleted
@@ -1812,20 +1812,20 @@
 		      OPTIMAL = 3,
 		      /// = 4. The cost function is unbounded.
 		      UNBOUNDED = 4
 		    };
 		    ///The basis status of variables
 		    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
 		      UPPER,
 		      /// The variable is non-basic and fixed
 		      FIXED
 		    };
 		  protected:
@@ -1894,17 +1894,17 @@
 		    Value primal(const Expr& e) const {
 		      double res = *e;
 		      for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
 		        res += *c * primal(c);
+		      }
 		      return res;
+		    }
 		    /// 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
 		    /// negative objective value in case of minimization, and positive
 		    /// objective value for maximization. If there is such solution,
 		    /// that proofs the unsolvability of the dual problem, and if a
 		    /// feasible primal solution exists, then the unboundness of
 		    /// primal problem.
 		    ///
@@ -1928,17 +1928,17 @@
 		      double res = 0.0;
 		      for (DualExpr::ConstCoeffIt r(e); r != INVALID; ++r) {
 		        res += *r * dual(r);
+		      }
 		      return res;
+		    }
 		    /// 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
 		    /// coefficients in the primal problem), and we looking for a
 		    /// ositive objective value. If there is such solution, that
 		    /// proofs the unsolvability of the primal problem, and if a
 		    /// feasible dual solution exists, then the unboundness of
 		    /// dual problem.
 		    ///
@@ -2070,17 +2070,17 @@
 		    Value sol(const Expr& e) const {
 		      double res = *e;
 		      for (Expr::ConstCoeffIt c(e); c != INVALID; ++c) {
 		        res += *c * sol(c);
+		      }
 		      return res;
+		    }
 		    ///The value of the objective function
 		    ///\return
 		    ///- \ref INF or -\ref INF means either infeasibility or unboundedness
 		    /// of the problem, depending on whether we minimize or maximize.
 		    ///- \ref NaN if no primal solution is found.
 		    ///- The (finite) objective value if an optimal solution is found.
 		    Value solValue() const { return _getSolValue()+obj_const_comp;}
 		    ///@}

lemon/lp_skeleton.cc

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/lp_skeleton.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -18,23 +18,23 @@
 		#ifndef LEMON_LP_SKELETON_H
 		#define LEMON_LP_SKELETON_H
 		#include <lemon/lp_base.h>
 		///\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.
 		namespace lemon {
 		  ///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.
 		  class SkeletonSolverBase : public virtual LpBase {
 		    int col_num,row_num;
 		  protected:
 		    SkeletonSolverBase()

lemon/maps.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -228,17 +228,17 @@
 		  /// \brief Map for storing values for integer keys from the range
 		  /// <tt>[0..size-1]</tt>.
 		  ///
 		  /// This map is essentially a wrapper for \c std::vector. It assigns
 		  /// values to integer keys from the range <tt>[0..size-1]</tt>.
 		  /// It can be used together with some data structures, e.g.
 		  /// 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()
 		  /// function.
 		  template <typename V>
 		  class RangeMap : public MapBase<int, V> {
 		    template <typename V1>
 		    friend class RangeMap;
 		  private:
@@ -1911,21 +1911,21 @@
 		  /// \brief General cross reference graph map type.
 		  /// This class provides simple invertable graph maps.
 		  /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)
 		  /// and if a key is set to a new value, then stores it in the inverse map.
 		  /// The graph items can be accessed by their values either using
 		  /// \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
 		  /// it does not have \c InverseMap.
 		  ///
 		  /// This type is not reference map, so it cannot be modified with
 		  /// the subscript operator.
 		  ///
 		  /// \tparam GR The graph type.
@@ -1997,17 +1997,17 @@
 		      /// \e
 		      bool operator==(ValueIt jt) const { return it == jt.it; }
 		      /// \e
 		      bool operator!=(ValueIt jt) const { return it != jt.it; }
 		    private:
 		      typename Container::const_iterator it;
 		    };
 		    /// Alias for \c ValueIt
 		    typedef ValueIt ValueIterator;
 		    /// \brief Returns an iterator to the first value.
 		    ///
 		    /// Returns an STL compatible iterator to the
 		    /// first value of the map. The values of the
 		    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
@@ -2056,17 +2056,17 @@
 		    /// This function gives back an item that is assigned to
 		    /// the given value or \c INVALID if no such item exists.
 		    /// If there are more items with the same associated value,
 		    /// only one of them is returned.
 		    Key operator()(const Value& val) const {
 		      typename Container::const_iterator it = _inv_map.find(val);
 		      return it != _inv_map.end() ? it->second : INVALID;
+		    }
 		    /// \brief Returns the number of items with the given value.
 		    ///
 		    /// This function returns the number of items with the given value
 		    /// associated with it.
 		    int count(const Value &val) const {
 		      return _inv_map.count(val);
+		    }
@@ -2373,17 +2373,17 @@
 		  /// \brief Returns a \c RangeIdMap class.
 		  ///
 		  /// This function just returns an \c RangeIdMap class.
 		  /// \relates RangeIdMap
 		  template <typename K, typename GR>
 		  inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {
 		    return RangeIdMap<GR, K>(graph);
+		  }
 		  /// \brief Dynamic iterable \c bool map.
 		  ///
 		  /// This class provides a special graph map type which can store a
 		  /// \c bool value for graph items (\c Node, \c Arc or \c Edge).
 		  /// For both \c true and \c false values it is possible to iterate on
 		  /// the keys mapped to the value.
 		  ///
 		  /// This type is a reference map, so it can be modified with the
@@ -2633,17 +2633,17 @@
 		      /// \brief Creates an iterator with a value.
 		      ///
 		      /// Creates an iterator with a value. It iterates on the
 		      /// keys mapped to the given value.
 		      /// \param map The IterableBoolMap.
 		      /// \param value The value.
 		      ItemIt(const IterableBoolMap& map, bool value)
-		        : Parent(value ?
 		        : Parent(value ?
 		                 (map._sep > 0 ?
 		                  map._array[map._sep - 1] : INVALID) :
 		                 (map._sep < int(map._array.size()) ?
 		                  map._array.back() : INVALID)), _map(&map) {}
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the iterator to be invalid.
@@ -3781,37 +3781,37 @@
 		  /// \param from The map from which the values have to be copied.
 		  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
 		  /// \param to The map to which the values have to be copied.
 		  /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
 		  template <typename GR, typename From, typename To>
 		  void mapCopy(const GR& gr, const From& from, To& to) {
 		    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
 		  /// and their \c Value types must be comparable using \c %operator==().
 		  ///
 		  /// \param gr The graph for which the maps are defined.
 		  /// \param map1 The first map.
 		  /// \param map2 The second map.
 		  template <typename GR, typename Map1, typename Map2>
 		  bool mapCompare(const GR& gr, const Map1& map1, const Map2& map2) {
 		    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;
+		    }
 		    return true;
+		  }
 		  /// \brief Return an item having minimum value of a graph map.
 		  ///

lemon/matching.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -1618,17 +1618,17 @@
+		      }
 		      for (EdgeIt e(_graph); e != INVALID; ++e) {
 		        (*_delta3_index)[e] = _delta3->PRE_HEAP;
+		      }
 		      for (int i = 0; i < _blossom_num; ++i) {
 		        (*_delta2_index)[i] = _delta2->PRE_HEAP;
 		        (*_delta4_index)[i] = _delta4->PRE_HEAP;
+		      }
 		      _unmatched = _node_num;
 		      _delta1->clear();
 		      _delta2->clear();
 		      _delta3->clear();
 		      _delta4->clear();
 		      _blossom_set->clear();
 		      _tree_set->clear();
@@ -1673,17 +1673,17 @@
 		    ///
 		    /// This function initializes the algorithm with a fractional
 		    /// matching. This initialization is also called jumpstart heuristic.
 		    void fractionalInit() {
 		      createStructures();
 		      _blossom_node_list.clear();
 		      _blossom_potential.clear();
 		      if (_fractional == 0) {
 		        _fractional = new FractionalMatching(_graph, _weight, false);
+		      }
 		      _fractional->run();
 		      for (ArcIt e(_graph); e != INVALID; ++e) {
 		        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
+		      }
@@ -1745,27 +1745,27 @@
 		          std::vector<int> subblossoms(num);
 		          subblossoms[--num] = _blossom_set->find(n);
 		          _delta1->push(n, _fractional->nodeValue(n));
 		          v = _graph.target(_fractional->matching(n));
 		          while (n != v) {
 		            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].pred = INVALID;
 		          (*_blossom_data)[surface].next = INVALID;
 		          (*_blossom_data)[surface].pot = 0;
 		          (*_blossom_data)[surface].offset = 0;
 		          _tree_set->insert(surface);
 		          ++_unmatched;
+		        }
+		      }
 		      for (EdgeIt e(_graph); e != INVALID; ++e) {
 		        int si = (*_node_index)[_graph.u(e)];
 		        int sb = _blossom_set->find(_graph.u(e));
@@ -1805,17 +1805,17 @@
 		                it->second = e;
+		              }
 		            } else {
 		              (*_node_data)[ni].heap.push(e, rw);
 		              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
+		            }
+		          }
+		        }
 		        if (!(*_node_data)[ni].heap.empty()) {
 		          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
 		          _delta2->push(nb, _blossom_set->classPrio(nb));
+		        }
+		      }
+		    }
 		    /// \brief Start the algorithm
@@ -2264,17 +2264,17 @@
 		    BinHeap<Value, IntEdgeMap> *_delta3;
 		    IntIntMap *_delta4_index;
 		    BinHeap<Value, IntIntMap> *_delta4;
 		    Value _delta_sum;
 		    int _unmatched;
-		    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
 		    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
 		    FractionalMatching;
 		    FractionalMatching *_fractional;
 		    void createStructures() {
 		      _node_num = countNodes(_graph);
 		      _blossom_num = _node_num * 3 / 2;
 		      if (!_matching) {
@@ -3090,17 +3090,17 @@
 		    ///
 		    /// This function initializes the algorithm with a fractional
 		    /// matching. This initialization is also called jumpstart heuristic.
 		    void fractionalInit() {
 		      createStructures();
 		      _blossom_node_list.clear();
 		      _blossom_potential.clear();
 		      if (_fractional == 0) {
 		        _fractional = new FractionalMatching(_graph, _weight, false);
+		      }
 		      if (!_fractional->run()) {
 		        _unmatched = -1;
 		        return;
+		      }
@@ -3156,27 +3156,27 @@
 		        if (num % 2 == 1) {
 		          std::vector<int> subblossoms(num);
 		          subblossoms[--num] = _blossom_set->find(n);
 		          v = _graph.target(_fractional->matching(n));
 		          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].pred = INVALID;
 		          (*_blossom_data)[surface].next = INVALID;
 		          (*_blossom_data)[surface].pot = 0;
 		          (*_blossom_data)[surface].offset = 0;
 		          _tree_set->insert(surface);
 		          ++_unmatched;
+		        }
+		      }
 		      for (EdgeIt e(_graph); e != INVALID; ++e) {
 		        int si = (*_node_index)[_graph.u(e)];
 		        int sb = _blossom_set->find(_graph.u(e));
@@ -3216,17 +3216,17 @@
 		                it->second = e;
+		              }
 		            } else {
 		              (*_node_data)[ni].heap.push(e, rw);
 		              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
+		            }
+		          }
+		        }
 		        if (!(*_node_data)[ni].heap.empty()) {
 		          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
 		          _delta2->push(nb, _blossom_set->classPrio(nb));
+		        }
+		      }
+		    }
 		    /// \brief Start the algorithm

lemon/math.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
@@ -51,17 +51,17 @@
  /// pi/4
  const long double PI_4    = 0.7853981633974483096156608458198757L;
  /// sqrt(2)
  const long double SQRT2   = 1.4142135623730950488016887242096981L;
  /// 1/sqrt(2)
  const long double SQRT1_2 = 0.7071067811865475244008443621048490L;

  ///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
  ///provided by all compilers.
  inline bool isNaN(double v)
    {
      return v!=v;
    }


lemon/min_cost_arborescence.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -123,18 +123,18 @@
 		            typename TR =
 		              MinCostArborescenceDefaultTraits<GR, CM> >
 		#else
 		  template <typename GR, typename CM, typename TR>
 		#endif
 		  class MinCostArborescence {
 		  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.
 		    typedef typename Traits::Digraph Digraph;
 		    /// The type of the map that stores the arc costs.
 		    typedef typename Traits::CostMap CostMap;
 		    ///The type of the costs of the arcs.
 		    typedef typename Traits::Value Value;
 		    ///The type of the predecessor map.
@@ -431,17 +431,17 @@
+		      }
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for
 		    /// setting \c PredMap type
 		    ///
 		    /// \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>
 		    struct SetPredMap
 		      : public MinCostArborescence<Digraph, CostMap, SetPredMapTraits<T> > {
 		    };
 		    /// @}

lemon/network_simplex.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -92,17 +92,17 @@
 		      /// bounded), and the algorithm has found optimal flow and node
 		      /// potentials (primal and dual solutions).
 		      OPTIMAL,
 		      /// The objective function of the problem is unbounded, i.e.
 		      /// there is a directed cycle having negative total cost and
 		      /// infinite upper bound.
 		      UNBOUNDED
 		    };
 		    /// \brief Constants for selecting the type of the supply constraints.
 		    ///
 		    /// Enum type containing constants for selecting the supply type,
 		    /// i.e. the direction of the inequalities in the supply/demand
 		    /// constraints of the \ref min_cost_flow "minimum cost flow problem".
 		    ///
 		    /// The default supply type is \c GEQ, the \c LEQ type can be
 		    /// selected using \ref supplyType().
@@ -110,17 +110,17 @@
 		    enum SupplyType {
 		      /// This option means that there are <em>"greater or equal"</em>
 		      /// supply/demand constraints in the definition of the problem.
 		      GEQ,
 		      /// This option means that there are <em>"less or equal"</em>
 		      /// supply/demand constraints in the definition of the problem.
 		      LEQ
 		    };
 		    /// \brief Constants for selecting the pivot rule.
 		    ///
 		    /// Enum type containing constants for selecting the pivot rule for
 		    /// the \ref run() function.
 		    ///
 		    /// \ref NetworkSimplex provides five different pivot rule
 		    /// implementations that significantly affect the running time
 		    /// of the algorithm.
@@ -153,17 +153,17 @@
 		      CANDIDATE_LIST,
 		      /// The \e Altering \e Candidate \e List pivot rule.
 		      /// It is a modified version of the Candidate List method.
 		      /// It keeps only the several best eligible arcs from the former
 		      /// candidate list and extends this list in every iteration.
 		      ALTERING_LIST
 		    };
 		  private:
 		    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		    typedef std::vector<int> IntVector;
 		    typedef std::vector<Value> ValueVector;
 		    typedef std::vector<Cost> CostVector;
 		    typedef std::vector<char> BoolVector;
@@ -222,21 +222,21 @@
 		    StateVector _state;
 		    int _root;
 		    // Temporary data used in the current pivot iteration
 		    int in_arc, join, u_in, v_in, u_out, v_out;
 		    int first, second, right, last;
 		    int stem, par_stem, new_stem;
 		    Value delta;
 		    const Value MAX;
 		  public:
 		    /// \brief Constant for infinite upper bounds (capacities).
 		    ///
 		    /// Constant for infinite upper bounds (capacities).
 		    /// It is \c std::numeric_limits<Value>::infinity() if available,
 		    /// \c std::numeric_limits<Value>::max() otherwise.
 		    const Value INF;
 		  private:
@@ -493,18 +493,18 @@
 		            if (c < min) {
 		              min = c;
 		              _in_arc = e;
+		            }
 		            if (_curr_length == _list_length) goto search_end;
+		          }
+		        }
 		        if (_curr_length == 0) return false;
 		      search_end:
 		      search_end:
 		        _minor_count = 1;
 		        _next_arc = e;
 		        return true;
+		      }
 		    }; //class CandidateListPivotRule
@@ -603,17 +603,17 @@
+		          }
 		          if (--cnt == 0) {
 		            if (_curr_length > limit) goto search_end;
 		            limit = 0;
 		            cnt = _block_size;
+		          }
+		        }
 		        if (_curr_length == 0) return false;
 		      search_end:
 		        // Make heap of the candidate list (approximating a partial sort)
 		        make_heap( _candidates.begin(), _candidates.begin() + _curr_length,
 		                   _sort_func );
 		        // Pop the first element of the heap
 		        _in_arc = _candidates[0];
@@ -629,32 +629,32 @@
 		  public:
 		    /// \brief Constructor.
 		    ///
 		    /// The constructor of the class.
 		    ///
 		    /// \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.
 		    NetworkSimplex(const GR& graph, bool arc_mixing = false) :
 		      _graph(graph), _node_id(graph), _arc_id(graph),
 		      _arc_mixing(arc_mixing),
 		      MAX(std::numeric_limits<Value>::max()),
 		      INF(std::numeric_limits<Value>::has_infinity ?
 		          std::numeric_limits<Value>::infinity() : MAX)
+		    {
 		      // Check the number types
 		      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
 		        "The flow type of NetworkSimplex must be signed");
 		      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
 		        "The cost type of NetworkSimplex must be signed");
 		      // Reset data structures
 		      reset();
+		    }
 		    /// \name Parameters
 		    /// The parameters of the algorithm can be specified using these
 		    /// functions.
@@ -758,17 +758,17 @@
 		    NetworkSimplex& stSupply(const Node& s, const Node& t, Value k) {
 		      for (int i = 0; i != _node_num; ++i) {
 		        _supply[i] = 0;
+		      }
 		      _supply[_node_id[s]] =  k;
 		      _supply[_node_id[t]] = -k;
 		      return *this;
+		    }
 		    /// \brief Set the type of the supply constraints.
 		    ///
 		    /// This function sets the type of the supply/demand constraints.
 		    /// If it is not used before calling \ref run(), the \ref GEQ supply
 		    /// type will be used.
 		    ///
 		    /// For more information, see \ref SupplyType.
 		    ///
@@ -784,17 +784,17 @@
 		    /// The algorithm can be executed using \ref run().
 		    /// @{
 		    /// \brief Run the algorithm.
 		    ///
 		    /// 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,
 		    /// \code
 		    ///   NetworkSimplex<ListDigraph> ns(graph);
 		    ///   ns.lowerMap(lower).upperMap(upper).costMap(cost)
 		    ///     .supplyMap(sup).run();
 		    /// \endcode
 		    ///
@@ -939,22 +939,22 @@
 		        // Store the arcs in the original order
 		        int i = 0;
 		        for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
 		          _arc_id[a] = i;
 		          _source[i] = _node_id[_graph.source(a)];
 		          _target[i] = _node_id[_graph.target(a)];
+		        }
+		      }
 		      // Reset parameters
 		      resetParams();
 		      return *this;
+		    }
 		    /// @}
 		    /// \name Query Functions
 		    /// The results of the algorithm can be obtained using these
 		    /// functions.\n
 		    /// The \ref run() function must be called before using them.
 		    /// @{
@@ -1084,17 +1084,17 @@
 		        ART_COST = (ART_COST + 1) * _node_num;
+		      }
 		      // Initialize arc maps
 		      for (int i = 0; i != _arc_num; ++i) {
 		        _flow[i] = 0;
 		        _state[i] = STATE_LOWER;
+		      }
 		      // Set data for the artificial root node
 		      _root = _node_num;
 		      _parent[_root] = -1;
 		      _pred[_root] = -1;
 		      _thread[_root] = 0;
 		      _rev_thread[0] = _root;
 		      _succ_num[_root] = _node_num + 1;
 		      _last_succ[_root] = _root - 1;
@@ -1258,17 +1258,17 @@
 		          delta = d;
 		          u_out = u;
 		          result = 1;
+		        }
+		      }
 		      // Search the cycle along the path form the second node to the root
 		      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) {
 		          delta = d;
 		          u_out = u;
 		          result = 2;
+		        }
+		      }
@@ -1562,34 +1562,34 @@
 		        bool change = findLeavingArc();
 		        if (delta >= MAX) return UNBOUNDED;
 		        changeFlow(change);
 		        if (change) {
 		          updateTreeStructure();
 		          updatePotential();
+		        }
+		      }
 		      // Check feasibility
 		      for (int e = _search_arc_num; e != _all_arc_num; ++e) {
 		        if (_flow[e] != 0) return INFEASIBLE;
+		      }
 		      // Transform the solution and the supply map to the original form
 		      if (_have_lower) {
 		        for (int i = 0; i != _arc_num; ++i) {
 		          Value c = _lower[i];
 		          if (c != 0) {
 		            _flow[i] += c;
 		            _supply[_source[i]] += c;
 		            _supply[_target[i]] -= c;
+		          }
+		        }
+		      }
 		      // Shift potentials to meet the requirements of the GEQ/LEQ type
 		      // optimality conditions
 		      if (_sum_supply == 0) {
 		        if (_stype == GEQ) {
 		          Cost max_pot = std::numeric_limits<Cost>::min();
 		          for (int i = 0; i != _node_num; ++i) {
 		            if (_pi[i] > max_pot) max_pot = _pi[i];
+		          }

lemon/path.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -961,30 +961,30 @@
 		    template <typename From, typename To>
 		    struct PathCopySelectorBackward<From, To, true> {
 		      static void copy(const From& from, To& to) {
 		        to.clear();
 		        to.buildRev(from);
+		      }
 		    };
 		    template <typename From, typename To,
 		              bool revEnable = RevPathTagIndicator<From>::value>
 		    struct PathCopySelector {
 		      static void copy(const From& from, To& to) {
 		        PathCopySelectorForward<From, To>::copy(from, to);
+		      }
+		      }
 		    };
 		    template <typename From, typename To>
 		    struct PathCopySelector<From, To, true> {
 		      static void copy(const From& from, To& to) {
 		        PathCopySelectorBackward<From, To>::copy(from, to);
+		      }
+		      }
 		    };
+		  }
 		  /// \brief Make a copy of a path.
 		  ///
 		  /// This function makes a copy of a path.

lemon/planarity.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -135,27 +135,27 @@
 		    template <typename Graph>
 		    struct ArcListNode {
 		      typename Graph::Arc prev, next;
 		    };
 		    template <typename Graph>
 		    class PlanarityChecking {
 		    private:
 		      TEMPLATE_GRAPH_TYPEDEFS(Graph);
 		      const Graph& _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;
 		      typedef typename Graph::template NodeMap<int> LowMap;
 		      typedef typename Graph::template NodeMap<int> AncestorMap;
 		      typedef _planarity_bits::NodeDataNode<Graph> NodeDataNode;
 		      typedef std::vector<NodeDataNode> NodeData;
@@ -216,17 +216,17 @@
 		            if (order_map[source] < order_map[target] && !tree_map[e]) {
 		              embed_arc[target] = true;
 		              walkUp(target, source, i, pred_map, low_map,
 		                     order_map, order_list, node_data, merge_roots);
+		            }
+		          }
 		          for (typename MergeRoots::Value::iterator it =
-		                 merge_roots[node].begin();
 		                 merge_roots[node].begin();
 		               it != merge_roots[node].end(); ++it) {
 		            int rn = *it;
 		            walkDown(rn, i, node_data, order_list, child_lists,
 		                     ancestor_map, low_map, embed_arc, merge_roots);
+		          }
 		          merge_roots[node].clear();
 		          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
@@ -427,17 +427,17 @@
 		              int xn = node_data[rn].next;
 		              Node xnode = order_list[xn];
 		              int yn = node_data[rn].prev;
 		              Node ynode = order_list[yn];
 		              bool rd;
-		              if (!external(xnode, rorder, child_lists,
 		              if (!external(xnode, rorder, child_lists,
 		                            ancestor_map, low_map)) {
 		                rd = true;
 		              } else if (!external(ynode, rorder, child_lists,
 		                                   ancestor_map, low_map)) {
 		                rd = false;
 		              } else if (pertinent(xnode, embed_arc, merge_roots)) {
 		                rd = true;
 		              } else {

lemon/preflow.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/smart_graph.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -181,17 +181,17 @@
 		  typedef DigraphExtender<SmartDigraphBase> ExtendedSmartDigraphBase;
 		  ///\ingroup graphs
 		  ///
 		  ///\brief A smart directed graph class.
 		  ///
 		  ///\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).
 		  ///
 		  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
 		  ///and it also provides some additional functionalities.
 		  ///Most of its member functions and nested classes are documented
 		  ///only in the concept class.
 		  ///
 		  ///This class provides constant time counting for nodes and arcs.
@@ -330,17 +330,17 @@
 		    ///Class to make a snapshot of the digraph and to restore it later.
 		    ///Class to make a snapshot of the digraph and to restore it later.
 		    ///
 		    ///The newly added nodes and arcs can be removed using the
 		    ///restore() function. This is the only way for deleting nodes and/or
 		    ///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.
 		    ///
 		    ///\warning Node splitting cannot be restored.
 		    ///\warning The validity of the snapshot is not stored due to
 		    ///performance reasons. If you do not use the snapshot correctly,
 		    ///it can cause broken program, invalid or not restored state of
 		    ///the digraph or no change.
@@ -609,17 +609,17 @@
 		  typedef GraphExtender<SmartGraphBase> ExtendedSmartGraphBase;
 		  /// \ingroup graphs
 		  ///
 		  /// \brief A smart undirected graph class.
 		  ///
 		  /// \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).
 		  ///
 		  /// This type fully conforms to the \ref concepts::Graph "Graph concept"
 		  /// and it also provides some additional functionalities.
 		  /// Most of its member functions and nested classes are documented
 		  /// only in the concept class.
 		  ///
 		  /// This class provides constant time counting for nodes, edges and arcs.
@@ -756,17 +756,17 @@
 		    ///Class to make a snapshot of the graph and to restore it later.
 		    ///Class to make a snapshot of the graph and to restore it later.
 		    ///
 		    ///The newly added nodes and edges can be removed using the
 		    ///restore() function. This is the only way for deleting nodes and/or
 		    ///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.
 		    ///
 		    ///\warning The validity of the snapshot is not stored due to
 		    ///performance reasons. If you do not use the snapshot correctly,
 		    ///it can cause broken program, invalid or not restored state of
 		    ///the graph or no change.
 		    class Snapshot

lemon/soplex.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -282,17 +282,17 @@
 		  SoplexLp::Value SoplexLp::_getObjCoeff(int i) const {
 		    return soplex->obj(i);
+		  }
 		  SoplexLp::SolveExitStatus SoplexLp::_solve() {
 		    _clear_temporals();
 		    _applyMessageLevel();
 		    soplex::SPxSolver::Status status = soplex->solve();
 		    switch (status) {
 		    case soplex::SPxSolver::OPTIMAL:
 		    case soplex::SPxSolver::INFEASIBLE:
 		    case soplex::SPxSolver::UNBOUNDED:

lemon/soplex.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

lemon/static_graph.h

Show inline comments

 		/* -*- 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -26,22 +26,22 @@
 		#include <lemon/core.h>
 		#include <lemon/bits/graph_extender.h>
 		namespace lemon {
 		  class StaticDigraphBase {
 		  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) {
 		        delete[] node_first_out;
 		        delete[] node_first_in;
 		        delete[] arc_source;
 		        delete[] arc_target;
 		        delete[] arc_next_out;
 		        delete[] arc_next_in;
@@ -57,17 +57,17 @@
 		      Node() {}
 		      Node (Invalid) : id(-1) {}
 		      bool operator==(const Node& node) const { return id == node.id; }
 		      bool operator!=(const Node& node) const { return id != node.id; }
 		      bool operator<(const Node& node) const { return id < node.id; }
 		    };
 		    class Arc {
-		      friend class StaticDigraphBase;
 		      friend class StaticDigraphBase;
 		    protected:
 		      int id;
 		      Arc(int _id) : id(_id) {}
 		    public:
 		      Arc() { }
 		      Arc (Invalid) : id(-1) {}
 		      bool operator==(const Arc& arc) const { return id == arc.id; }
 		      bool operator!=(const Arc& arc) const { return id != arc.id; }
@@ -78,18 +78,18 @@
 		    Node target(const Arc& e) const { return Node(arc_target[e.id]); }
 		    void first(Node& n) const { n.id = node_num - 1; }
 		    static void next(Node& n) { --n.id; }
 		    void first(Arc& e) const { e.id = arc_num - 1; }
 		    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;
+		    }
 		    void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; }
 		    void firstIn(Arc& e, const Node& n) const { e.id = node_first_in[n.id]; }
 		    void nextIn(Arc& e) const { e.id = arc_next_in[e.id]; }
 		    static int id(const Node& n) { return n.id; }
@@ -108,45 +108,45 @@
 		  private:
 		    template <typename Digraph, typename NodeRefMap>
 		    class ArcLess {
 		    public:
 		      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 Digraph& digraph;
 		      const NodeRefMap& nodeRef;
 		    };
 		  public:
 		    typedef True BuildTag;
 		    void clear() {
 		      if (built) {
 		        delete[] node_first_out;
 		        delete[] node_first_in;
 		        delete[] arc_source;
 		        delete[] arc_target;
 		        delete[] arc_next_out;
 		        delete[] arc_next_in;
+		      }
 		      built = false;
 		      node_num = 0;
 		      arc_num = 0;
+		    }
 		    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
 		    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
 		      typedef typename Digraph::Node GNode;
 		      typedef typename Digraph::Arc GArc;
 		      built = true;
 		      node_num = countNodes(digraph);
@@ -178,50 +178,50 @@
+		        }
 		        if (!arcs.empty()) {
 		          node_first_out[source] = arc_index;
 		          std::sort(arcs.begin(), arcs.end(), arcLess);
 		          for (typename std::vector<GArc>::iterator it = arcs.begin();
 		               it != arcs.end(); ++it) {
 		            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_in[target] = arc_index;
 		            arc_next_out[arc_index] = arc_index + 1;
 		            ++arc_index;
+		          }
 		          arc_next_out[arc_index - 1] = -1;
 		        } else {
 		          node_first_out[source] = arc_index;
+		        }
+		      }
 		      node_first_out[node_num] = arc_num;
+		    }
 		    template <typename ArcListIterator>
 		    void build(int n, ArcListIterator first, ArcListIterator last) {
 		      built = true;
 		      node_num = n;
 		      arc_num = std::distance(first, last);
 		      node_first_out = new int[node_num + 1];
 		      node_first_in = new int[node_num];
 		      arc_source = new int[arc_num];
 		      arc_target = new int[arc_num];
 		      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) {
 		        node_first_out[i] = arc_index;
 		        for ( ; first != last && (*first).first == i; ++first) {
 		          int j = (*first).second;
 		          LEMON_ASSERT(j >= 0 && j < node_num,
 		            "Wrong arc list for StaticDigraph::build()");
 		          arc_source[arc_index] = i;
@@ -277,36 +277,36 @@
 		  /// values for each arc. Moreover it provides faster item iteration than
 		  /// \ref ListDigraph and \ref SmartDigraph, especially using \c OutArcIt
 		  /// iterators, since its arcs are stored in an appropriate order.
 		  /// However it only provides build() and clear() functions and does not
 		  /// support any other modification of the digraph.
 		  ///
 		  /// 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()
 		  /// "id()" function. A node or arc with a certain index can be obtained
 		  /// using node() or arc().
 		  ///
 		  /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
 		  /// Most of its member functions and nested classes are documented
 		  /// only in the concept class.
 		  ///
 		  /// This class provides constant time counting for nodes and arcs.
 		  ///
 		  /// \sa concepts::Digraph
 		  class StaticDigraph : public ExtendedStaticDigraphBase {
 		  public:
 		    typedef ExtendedStaticDigraphBase Parent;
 		  public:
 		    /// \brief Constructor
 		    ///
 		    /// Default constructor.
 		    StaticDigraph() : Parent() {}
 		    /// \brief The node with the given index.
 		    ///
 		    /// This function returns the node with the given index.
@@ -344,17 +344,17 @@
 		    /// \brief Build the digraph copying another digraph.
 		    ///
 		    /// This function builds the digraph copying another digraph of any
 		    /// kind. It can be called more than once, but in such case, the whole
 		    /// structure and all maps will be cleared and rebuilt.
 		    ///
 		    /// 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.
 		    /// Its key type must be \c Digraph::Node and its value type must be
 		    /// \c StaticDigraph::Node.
 		    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
 		    /// concept.
 		    /// \param arcRef The arc references will be copied into this map.
 		    /// Its key type must be \c Digraph::Arc and its value type must be
@@ -365,17 +365,17 @@
 		    /// \ref NullMap for the last parameter. However the node references
 		    /// are required by the function itself, thus they must be readable
 		    /// from the map.
 		    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
 		    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
 		      if (built) Parent::clear();
 		      Parent::build(digraph, nodeRef, arcRef);
+		    }
 		    /// \brief Build the digraph from an arc list.
 		    ///
 		    /// This function builds the digraph from the given arc list.
 		    /// It can be called more than once, but in such case, the whole
 		    /// structure and all maps will be cleared and rebuilt.
 		    ///
 		    /// The list of the arcs must be given in the range <tt>[begin, end)</tt>
 		    /// specified by STL compatible itartors whose \c value_type must be
@@ -416,42 +416,42 @@
 		      Parent::clear();
+		    }
 		  protected:
 		    using Parent::fastFirstOut;
 		    using Parent::fastNextOut;
 		    using Parent::fastLastOut;
 		  public:
 		    class OutArcIt : public Arc {
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      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(const StaticDigraph& digraph, const Arc& arc) : Arc(arc) {
 		        if (arc != INVALID) {
 		          digraph.fastLastOut(last, digraph.source(arc));
+		        }
+		      }
-		      OutArcIt& operator++() {
 		      OutArcIt& operator++() {
 		        StaticDigraph::fastNextOut(*this);
 		        if (last == *this) *this = INVALID;
-		        return *this;
 		        return *this;
+		      }
 		    private:
 		      Arc last;
 		    };
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(static_cast<const Arc&>(arc));

lemon/suurballe.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -60,17 +60,17 @@
 		    typedef typename GR::template NodeMap<Length> PotentialMap;
 		    /// \brief The path type
 		    ///
 		    /// The type used for storing the found arc-disjoint paths.
 		    /// It must conform to the \ref lemon::concepts::Path "Path" concept
 		    /// 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;
 		    /// \brief The heap type used for internal Dijkstra computations.
 		    ///
 		    /// The type of the heap used for internal Dijkstra computations.
 		    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept
 		    /// and its priority type must be \c Length.
@@ -153,36 +153,36 @@
 		      const Digraph &_graph;
 		      const LengthMap &_length;
 		      const FlowMap &_flow;
 		      PotentialMap &_pi;
 		      PredMap &_pred;
 		      Node _s;
 		      Node _t;
 		      PotentialMap _dist;
 		      std::vector<Node> _proc_nodes;
 		    public:
 		      // Constructor
 		      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.
 		      bool run(int cnt) {
 		        return cnt == 0 ? startFirst() : start();
+		      }
 		    private:
 		      // Execute the algorithm for the first time (the flow and potential
 		      // functions have to be identically zero).
 		      bool startFirst() {
 		        HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
 		        Heap heap(heap_cross_ref);
 		        heap.push(_s, 0);
 		        _pred[_s] = INVALID;
 		        _proc_nodes.clear();
@@ -343,28 +343,28 @@
 		    /// \ref named-templ-param "Named parameter" for setting \c %Path type.
 		    /// It must conform to the \ref lemon::concepts::Path "Path" concept
 		    /// and it must have an \c addBack() function.
 		    template <typename T>
 		    struct SetPath
 		      : public Suurballe<GR, LEN, SetPathTraits<T> > {
 		      typedef Suurballe<GR, LEN, SetPathTraits<T> > Create;
 		    };
 		    template <typename H, typename CR>
 		    struct SetHeapTraits : public Traits {
 		      typedef H Heap;
 		      typedef CR HeapCrossRef;
 		    };
 		    /// \brief \ref named-templ-param "Named parameter" for setting
 		    /// \c Heap and \c HeapCrossRef types.
 		    ///
 		    /// \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"
 		    /// concept and its priority type must be \c Length.
 		    template <typename H,
 		              typename CR = typename Digraph::template NodeMap<int> >
 		    struct SetHeap
 		      : public Suurballe<GR, LEN, SetHeapTraits<H, CR> > {
 		      typedef Suurballe<GR, LEN, SetHeapTraits<H, CR> > Create;
@@ -392,17 +392,17 @@
 		    Node _t;
 		    // Container to store the found paths
 		    std::vector<Path> _paths;
 		    int _path_num;
 		    // The pred arc map
 		    PredMap _pred;
 		    // Data for full init
 		    PotentialMap *_init_dist;
 		    PredMap *_init_pred;
 		    bool _full_init;
 		  protected:
 		    Suurballe() {}
@@ -550,17 +550,17 @@
 		      // Run a full Dijkstra
 		      typename Dijkstra<Digraph, LengthMap>
 		        ::template SetStandardHeap<Heap>
 		        ::template SetDistMap<PotentialMap>
 		        ::template SetPredMap<PredMap>
 		        ::Create dijk(_graph, _length);
 		      dijk.distMap(*_init_dist).predMap(*_init_pred);
 		      dijk.run(s);
 		      _full_init = true;
+		    }
 		    /// \brief Execute the algorithm.
 		    ///
 		    /// This function executes the algorithm.
 		    ///
 		    /// \param t The target node.
@@ -594,31 +594,31 @@
 		    /// \return \c k if there are at least \c k arc-disjoint paths from
 		    /// the source node to the given node \c t in the digraph.
 		    /// Otherwise it returns the number of arc-disjoint paths found.
 		    ///
 		    /// \pre \ref init() must be called before using this function.
 		    int findFlow(const Node& t, int k = 2) {
 		      _t = t;
 		      ResidualDijkstra dijkstra(*this);
 		      // Initialization
 		      for (ArcIt e(_graph); e != INVALID; ++e) {
 		        (*_flow)[e] = 0;
+		      }
 		      if (_full_init) {
 		        for (NodeIt n(_graph); n != INVALID; ++n) {
 		          (*_potential)[n] = (*_init_dist)[n];
+		        }
 		        Node u = _t;
 		        Arc e;
 		        while ((e = (*_init_pred)[u]) != INVALID) {
 		          (*_flow)[e] = 1;
 		          u = _graph.source(e);
+		        }
+		        }
 		        _path_num = 1;
 		      } else {
 		        for (NodeIt n(_graph); n != INVALID; ++n) {
 		          (*_potential)[n] = 0;
+		        }
 		        _path_num = 0;
+		      }

lemon/unionfind.h

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

test/bellman_ford_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -92,30 +92,30 @@
 		    l  = const_bf_test.dist(t);
 		    e  = const_bf_test.predArc(t);
 		    s  = const_bf_test.predNode(t);
 		    b  = const_bf_test.reached(t);
 		    d  = const_bf_test.distMap();
 		    p  = const_bf_test.predMap();
 		    pp = const_bf_test.path(t);
 		    pp = const_bf_test.negativeCycle();
 		    for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
+		  }
+		  {
 		    BF::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,Value> >
 		      ::SetOperationTraits<BellmanFordDefaultOperationTraits<Value> >
 		      ::SetOperationTraits<BellmanFordToleranceOperationTraits<Value, 0> >
 		      ::Create bf_test(gr,length);
 		    LengthMap length_map;
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,Value> dist_map;
 		    bf_test
 		      .lengthMap(length_map)
 		      .predMap(pred_map)
 		      .distMap(dist_map);
 		    bf_test.run(s);
 		    bf_test.run(s,k);
@@ -184,17 +184,17 @@
 		  bf.run(s);
 		  Path<Digraph> p = bf.path(t);
 		  check(bf.reached(t) && bf.dist(t) == -1, "Bellman-Ford found a wrong path.");
 		  check(p.length() == 3, "path() found a wrong path.");
 		  check(checkPath(gr, p), "path() found a wrong path.");
 		  check(pathSource(gr, p) == s, "path() found a wrong path.");
 		  check(pathTarget(gr, p) == t, "path() found a wrong path.");
 		  ListPath<Digraph> path;
 		  Value dist;
 		  bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
 		  check(reached && dist == -1, "Bellman-Ford found a wrong path.");
 		  check(path.length() == 3, "path() found a wrong path.");
 		  check(checkPath(gr, path), "path() found a wrong path.");
 		  check(pathSource(gr, path) == s, "path() found a wrong path.");
@@ -223,50 +223,50 @@
+		  }
+		}
 		void checkBellmanFordNegativeCycle() {
 		  DIGRAPH_TYPEDEFS(SmartDigraph);
 		  SmartDigraph gr;
 		  IntArcMap length(gr);
 		  Node n1 = gr.addNode();
 		  Node n2 = gr.addNode();
 		  Node n3 = gr.addNode();
 		  Node n4 = gr.addNode();
 		  Arc a1 = gr.addArc(n1, n2);
 		  Arc a2 = gr.addArc(n2, n2);
 		  length[a1] = 2;
 		  length[a2] = -1;
+		  {
 		    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
 		    bf.run(n1);
 		    StaticPath<SmartDigraph> p = bf.negativeCycle();
 		    check(p.length() == 1 && p.front() == p.back() && p.front() == a2,
 		          "Wrong negative cycle.");
+		  }
 		  length[a2] = 0;
+		  {
 		    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
 		    bf.run(n1);
 		    check(bf.negativeCycle().empty(),
 		          "Negative cycle should not be found.");
+		  }
 		  length[gr.addArc(n1, n3)] = 5;
 		  length[gr.addArc(n4, n3)] = 1;
 		  length[gr.addArc(n2, n4)] = 2;
 		  length[gr.addArc(n3, n2)] = -4;
+		  {
 		    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
 		    bf.init();
 		    bf.addSource(n1);
 		    for (int i = 0; i < 4; ++i) {
 		      check(bf.negativeCycle().empty(),
 		            "Negative cycle should not be found.");
 		      bf.processNextRound();

test/bfs_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -78,17 +78,17 @@
 		    bfs_test.init();
 		    bfs_test.addSource(s);
 		    n = bfs_test.processNextNode();
 		    n = bfs_test.processNextNode(t, b);
 		    n = bfs_test.processNextNode(nm, n);
 		    n = const_bfs_test.nextNode();
 		    b = const_bfs_test.emptyQueue();
 		    i = const_bfs_test.queueSize();
 		    bfs_test.start();
 		    bfs_test.start(t);
 		    bfs_test.start(nm);
 		    l  = const_bfs_test.dist(t);
 		    e  = const_bfs_test.predArc(t);
 		    s  = const_bfs_test.predNode(t);
 		    b  = const_bfs_test.reached(t);
@@ -99,41 +99,41 @@
+		  {
 		    BType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,int> >
 		      ::SetReachedMap<concepts::ReadWriteMap<Node,bool> >
 		      ::SetStandardProcessedMap
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::Create bfs_test(G);
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,int> dist_map;
 		    concepts::ReadWriteMap<Node,bool> reached_map;
 		    concepts::WriteMap<Node,bool> processed_map;
 		    bfs_test
 		      .predMap(pred_map)
 		      .distMap(dist_map)
 		      .reachedMap(reached_map)
 		      .processedMap(processed_map);
 		    bfs_test.run(s);
 		    bfs_test.run(s,t);
 		    bfs_test.run();
 		    bfs_test.init();
 		    bfs_test.addSource(s);
 		    n = bfs_test.processNextNode();
 		    n = bfs_test.processNextNode(t, b);
 		    n = bfs_test.processNextNode(nm, n);
 		    n = bfs_test.nextNode();
 		    b = bfs_test.emptyQueue();
 		    i = bfs_test.queueSize();
 		    bfs_test.start();
 		    bfs_test.start(t);
 		    bfs_test.start(nm);
 		    l  = bfs_test.dist(t);
 		    e  = bfs_test.predArc(t);
 		    s  = bfs_test.predNode(t);
 		    b  = bfs_test.reached(t);

test/circulation_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -76,38 +76,38 @@
 		  typedef Circulation<Digraph, CapMap, CapMap, SupplyMap>
 		            ::SetFlowMap<FlowMap>
 		            ::SetElevator<Elev>
 		            ::SetStandardElevator<LinkedElev>
 		            ::Create CirculationType;
 		  CirculationType circ_test(g, lcap, ucap, supply);
 		  const CirculationType& const_circ_test = circ_test;
 		  circ_test
 		    .lowerMap(lcap)
 		    .upperMap(ucap)
 		    .supplyMap(supply)
 		    .flowMap(flow);
 		  const CirculationType::Elevator& elev = const_circ_test.elevator();
 		  circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
 		  CirculationType::Tolerance tol = const_circ_test.tolerance();
 		  circ_test.tolerance(tol);
 		  circ_test.init();
 		  circ_test.greedyInit();
 		  circ_test.start();
 		  circ_test.run();
 		  v = const_circ_test.flow(a);
 		  const FlowMap& fm = const_circ_test.flowMap();
 		  b = const_circ_test.barrier(n);
 		  const_circ_test.barrierMap(bar);
 		  ignore_unused_variable_warning(fm);
+		}
 		template <class G, class LM, class UM, class DM>
 		void checkCirculation(const G& g, const LM& lm, const UM& um,
 		                      const DM& dm, bool find)
+		{
 		  Circulation<G, LM, UM, DM> circ(g, lm, um, dm);

test/connectivity_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -24,36 +24,36 @@
 		using namespace lemon;
 		int main()
+		{
 		  typedef ListDigraph Digraph;
 		  typedef Undirector<Digraph> Graph;
+		  {
 		    Digraph d;
 		    Digraph::NodeMap<int> order(d);
 		    Graph g(d);
 		    check(stronglyConnected(d), "The empty digraph is strongly connected");
 		    check(countStronglyConnectedComponents(d) == 0,
 		          "The empty digraph has 0 strongly connected component");
 		    check(connected(g), "The empty graph is connected");
 		    check(countConnectedComponents(g) == 0,
 		          "The empty graph has 0 connected component");
 		    check(biNodeConnected(g), "The empty graph is bi-node-connected");
 		    check(countBiNodeConnectedComponents(g) == 0,
 		          "The empty graph has 0 bi-node-connected component");
 		    check(biEdgeConnected(g), "The empty graph is bi-edge-connected");
 		    check(countBiEdgeConnectedComponents(g) == 0,
 		          "The empty graph has 0 bi-edge-connected component");
 		    check(dag(d), "The empty digraph is DAG.");
 		    check(checkedTopologicalSort(d, order), "The empty digraph is DAG.");
 		    check(loopFree(d), "The empty digraph is loop-free.");
 		    check(parallelFree(d), "The empty digraph is parallel-free.");
 		    check(simpleGraph(d), "The empty digraph is simple.");
 		    check(acyclic(g), "The empty graph is acyclic.");
 		    check(tree(g), "The empty graph is tree.");
@@ -77,17 +77,17 @@
 		          "This graph has 1 connected component");
 		    check(biNodeConnected(g), "This graph is bi-node-connected");
 		    check(countBiNodeConnectedComponents(g) == 0,
 		          "This graph has 0 bi-node-connected component");
 		    check(biEdgeConnected(g), "This graph is bi-edge-connected");
 		    check(countBiEdgeConnectedComponents(g) == 1,
 		          "This graph has 1 bi-edge-connected component");
 		    check(dag(d), "This digraph is DAG.");
 		    check(checkedTopologicalSort(d, order), "This digraph is DAG.");
 		    check(loopFree(d), "This digraph is loop-free.");
 		    check(parallelFree(d), "This digraph is parallel-free.");
 		    check(simpleGraph(d), "This digraph is simple.");
 		    check(acyclic(g), "This graph is acyclic.");
 		    check(tree(g), "This graph is tree.");
@@ -96,24 +96,24 @@
 		    check(parallelFree(g), "This graph is parallel-free.");
 		    check(simpleGraph(g), "This graph is simple.");
+		  }
+		  {
 		    Digraph d;
 		    Digraph::NodeMap<int> order(d);
 		    Graph g(d);
 		    Digraph::Node n1 = d.addNode();
 		    Digraph::Node n2 = d.addNode();
 		    Digraph::Node n3 = d.addNode();
 		    Digraph::Node n4 = d.addNode();
 		    Digraph::Node n5 = d.addNode();
 		    Digraph::Node n6 = d.addNode();
 		    d.addArc(n1, n3);
 		    d.addArc(n3, n2);
 		    d.addArc(n2, n1);
 		    d.addArc(n4, n2);
 		    d.addArc(n4, n3);
 		    d.addArc(n5, n6);
 		    d.addArc(n6, n5);
@@ -131,33 +131,33 @@
 		    check(simpleGraph(d), "This digraph is simple.");
 		    check(!acyclic(g), "This graph is not acyclic.");
 		    check(!tree(g), "This graph is not tree.");
 		    check(!bipartite(g), "This graph is not bipartite.");
 		    check(loopFree(g), "This graph is loop-free.");
 		    check(!parallelFree(g), "This graph is not parallel-free.");
 		    check(!simpleGraph(g), "This graph is not simple.");
 		    d.addArc(n3, n3);
 		    check(!loopFree(d), "This digraph is not loop-free.");
 		    check(!loopFree(g), "This graph is not loop-free.");
 		    check(!simpleGraph(d), "This digraph is not simple.");
 		    d.addArc(n3, n2);
 		    check(!parallelFree(d), "This digraph is not parallel-free.");
+		  }
+		  {
 		    Digraph d;
 		    Digraph::ArcMap<bool> cutarcs(d, false);
 		    Graph g(d);
 		    Digraph::Node n1 = d.addNode();
 		    Digraph::Node n2 = d.addNode();
 		    Digraph::Node n3 = d.addNode();
 		    Digraph::Node n4 = d.addNode();
 		    Digraph::Node n5 = d.addNode();
 		    Digraph::Node n6 = d.addNode();
 		    Digraph::Node n7 = d.addNode();
 		    Digraph::Node n8 = d.addNode();
@@ -167,17 +167,17 @@
 		    d.addArc(n2, n8);
 		    d.addArc(n8, n5);
 		    d.addArc(n6, n4);
 		    d.addArc(n4, n6);
 		    d.addArc(n2, n5);
 		    d.addArc(n1, n8);
 		    d.addArc(n6, n7);
 		    d.addArc(n7, n6);
 		    check(!stronglyConnected(d), "This digraph is not strongly connected");
 		    check(countStronglyConnectedComponents(d) == 3,
 		          "This digraph has 3 strongly connected components");
 		    Digraph::NodeMap<int> scomp1(d);
 		    check(stronglyConnectedComponents(d, scomp1) == 3,
 		          "This digraph has 3 strongly connected components");
 		    check(scomp1[n1] != scomp1[n3] && scomp1[n1] != scomp1[n4] &&
 		          scomp1[n3] != scomp1[n4], "Wrong stronglyConnectedComponents()");
@@ -230,17 +230,17 @@
+		    }
+		  }
+		  {
 		    // DAG example for topological sort from the book New Algorithms
 		    // (T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein)
 		    Digraph d;
 		    Digraph::NodeMap<int> order(d);
 		    Digraph::Node belt = d.addNode();
 		    Digraph::Node trousers = d.addNode();
 		    Digraph::Node necktie = d.addNode();
 		    Digraph::Node coat = d.addNode();
 		    Digraph::Node socks = d.addNode();
 		    Digraph::Node shirt = d.addNode();
 		    Digraph::Node shoe = d.addNode();
 		    Digraph::Node watch = d.addNode();
@@ -250,48 +250,48 @@
 		    d.addArc(pants, shoe);
 		    d.addArc(pants, trousers);
 		    d.addArc(trousers, shoe);
 		    d.addArc(trousers, belt);
 		    d.addArc(belt, coat);
 		    d.addArc(shirt, belt);
 		    d.addArc(shirt, necktie);
 		    d.addArc(necktie, coat);
 		    check(dag(d), "This digraph is DAG.");
 		    topologicalSort(d, order);
 		    for (Digraph::ArcIt a(d); a != INVALID; ++a) {
 		      check(order[d.source(a)] < order[d.target(a)],
 		            "Wrong topologicalSort()");
+		    }
+		  }
+		  {
 		    ListGraph g;
 		    ListGraph::NodeMap<bool> map(g);
 		    ListGraph::Node n1 = g.addNode();
 		    ListGraph::Node n2 = g.addNode();
 		    ListGraph::Node n3 = g.addNode();
 		    ListGraph::Node n4 = g.addNode();
 		    ListGraph::Node n5 = g.addNode();
 		    ListGraph::Node n6 = g.addNode();
 		    ListGraph::Node n7 = g.addNode();
 		    g.addEdge(n1, n3);
 		    g.addEdge(n1, n4);
 		    g.addEdge(n2, n5);
 		    g.addEdge(n3, n6);
 		    g.addEdge(n4, n6);
 		    g.addEdge(n4, n7);
 		    g.addEdge(n5, n7);
 		    check(bipartite(g), "This graph is bipartite");
 		    check(bipartitePartitions(g, map), "This graph is bipartite");
 		    check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7],
 		          "Wrong bipartitePartitions()");
 		    check(map[n3] == map[n4] && map[n3] == map[n5],
 		          "Wrong bipartitePartitions()");
+		  }
 		  return 0;
+		}

test/dfs_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -78,17 +78,17 @@
 		    dfs_test.run();
 		    dfs_test.init();
 		    dfs_test.addSource(s);
 		    e = dfs_test.processNextArc();
 		    e = const_dfs_test.nextArc();
 		    b = const_dfs_test.emptyQueue();
 		    i = const_dfs_test.queueSize();
 		    dfs_test.start();
 		    dfs_test.start(t);
 		    dfs_test.start(am);
 		    l  = const_dfs_test.dist(t);
 		    e  = const_dfs_test.predArc(t);
 		    s  = const_dfs_test.predNode(t);
 		    b  = const_dfs_test.reached(t);
@@ -104,34 +104,34 @@
 		      ::SetStandardProcessedMap
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::Create dfs_test(G);
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,int> dist_map;
 		    concepts::ReadWriteMap<Node,bool> reached_map;
 		    concepts::WriteMap<Node,bool> processed_map;
 		    dfs_test
 		      .predMap(pred_map)
 		      .distMap(dist_map)
 		      .reachedMap(reached_map)
 		      .processedMap(processed_map);
 		    dfs_test.run(s);
 		    dfs_test.run(s,t);
 		    dfs_test.run();
 		    dfs_test.init();
 		    dfs_test.addSource(s);
 		    e = dfs_test.processNextArc();
 		    e = dfs_test.nextArc();
 		    b = dfs_test.emptyQueue();
 		    i = dfs_test.queueSize();
 		    dfs_test.start();
 		    dfs_test.start(t);
 		    dfs_test.start(am);
 		    l  = dfs_test.dist(t);
 		    e  = dfs_test.predArc(t);
 		    s  = dfs_test.predNode(t);
 		    b  = dfs_test.reached(t);

test/digraph_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -387,19 +387,19 @@
 		  check(!g.valid(g.nodeFromId(-1)), "Wrong validity check");
 		  check(!g.valid(g.arcFromId(-1)), "Wrong validity check");
+		}
 		void checkStaticDigraph() {
 		  SmartDigraph g;
 		  SmartDigraph::NodeMap<StaticDigraph::Node> nref(g);
 		  SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g);
 		  StaticDigraph G;
 		  checkGraphNodeList(G, 0);
 		  checkGraphArcList(G, 0);
 		  G.build(g, nref, aref);
 		  checkGraphNodeList(G, 0);
 		  checkGraphArcList(G, 0);
@@ -459,17 +459,17 @@
 		  arcs.push_back(std::make_pair(1,2));
 		  arcs.push_back(std::make_pair(3,0));
 		  arcs.push_back(std::make_pair(3,3));
 		  arcs.push_back(std::make_pair(4,2));
 		  arcs.push_back(std::make_pair(4,3));
 		  arcs.push_back(std::make_pair(4,1));
 		  G.build(6, arcs.begin(), arcs.end());
 		  checkGraphNodeList(G, 6);
 		  checkGraphArcList(G, 9);
 		  checkGraphOutArcList(G, G.node(0), 2);
 		  checkGraphOutArcList(G, G.node(1), 2);
 		  checkGraphOutArcList(G, G.node(2), 0);
 		  checkGraphOutArcList(G, G.node(3), 2);
 		  checkGraphOutArcList(G, G.node(4), 3);
@@ -483,17 +483,17 @@
 		  checkGraphInArcList(G, G.node(5), 0);
 		  checkGraphConArcList(G, 9);
 		  checkNodeIds(G);
 		  checkArcIds(G);
 		  checkGraphNodeMap(G);
 		  checkGraphArcMap(G);
 		  int n = G.nodeNum();
 		  int m = G.arcNum();
 		  check(G.index(G.node(n-1)) == n-1, "Wrong index.");
 		  check(G.index(G.arc(m-1)) == m-1, "Wrong index.");
+		}
 		void checkFullDigraph(int num) {
 		  typedef FullDigraph Digraph;

test/dijkstra_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -80,17 +80,17 @@
 		    dijkstra_test.init();
 		    dijkstra_test.addSource(s);
 		    dijkstra_test.addSource(s, 1);
 		    n = dijkstra_test.processNextNode();
 		    n = const_dijkstra_test.nextNode();
 		    b = const_dijkstra_test.emptyQueue();
 		    i = const_dijkstra_test.queueSize();
 		    dijkstra_test.start();
 		    dijkstra_test.start(t);
 		    dijkstra_test.start(nm);
 		    l  = const_dijkstra_test.dist(t);
 		    e  = const_dijkstra_test.predArc(t);
 		    s  = const_dijkstra_test.predNode(t);
 		    b  = const_dijkstra_test.reached(t);
@@ -104,44 +104,44 @@
 		    DType
 		      ::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
 		      ::SetDistMap<concepts::ReadWriteMap<Node,VType> >
 		      ::SetStandardProcessedMap
 		      ::SetProcessedMap<concepts::WriteMap<Node,bool> >
 		      ::SetOperationTraits<DijkstraDefaultOperationTraits<VType> >
 		      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
 		      ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-		      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
 		      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
 		                concepts::ReadWriteMap<Node,int> >
 		      ::Create dijkstra_test(G,length);
 		    LengthMap length_map;
 		    concepts::ReadWriteMap<Node,Arc> pred_map;
 		    concepts::ReadWriteMap<Node,VType> dist_map;
 		    concepts::WriteMap<Node,bool> processed_map;
 		    concepts::ReadWriteMap<Node,int> heap_cross_ref;
 		    BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
 		    dijkstra_test
 		      .lengthMap(length_map)
 		      .predMap(pred_map)
 		      .distMap(dist_map)
 		      .processedMap(processed_map)
 		      .heap(heap, heap_cross_ref);
 		    dijkstra_test.run(s);
 		    dijkstra_test.run(s,t);
 		    dijkstra_test.addSource(s);
 		    dijkstra_test.addSource(s, 1);
 		    n = dijkstra_test.processNextNode();
 		    n = dijkstra_test.nextNode();
 		    b = dijkstra_test.emptyQueue();
 		    i = dijkstra_test.queueSize();
 		    dijkstra_test.start();
 		    dijkstra_test.start(t);
 		    dijkstra_test.start(nm);
 		    l  = dijkstra_test.dist(t);
 		    e  = dijkstra_test.predArc(t);
 		    s  = dijkstra_test.predNode(t);
 		    b  = dijkstra_test.reached(t);

test/edge_set_test.cc

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,

test/euler_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -80,21 +80,21 @@
 		        "checkEulerIt: Not visited or multiple times visited edge found");
+		  }
+		}
 		int main()
+		{
 		  typedef ListDigraph Digraph;
 		  typedef Undirector<Digraph> Graph;
+		  {
 		    Digraph d;
 		    Graph g(d);
 		    checkDiEulerIt(d);
 		    checkDiEulerIt(g);
 		    checkEulerIt(g);
 		    check(eulerian(d), "This graph is Eulerian");
 		    check(eulerian(g), "This graph is Eulerian");
+		  }
+		  {
@@ -123,17 +123,17 @@
 		    check(eulerian(g), "This graph is Eulerian");
+		  }
+		  {
 		    Digraph d;
 		    Graph g(d);
 		    Digraph::Node n1 = d.addNode();
 		    Digraph::Node n2 = d.addNode();
 		    Digraph::Node n3 = d.addNode();
 		    d.addArc(n1, n2);
 		    d.addArc(n2, n1);
 		    d.addArc(n2, n3);
 		    d.addArc(n3, n2);
 		    checkDiEulerIt(d);
 		    checkDiEulerIt(d, n2);
 		    checkDiEulerIt(g);
@@ -148,17 +148,17 @@
 		    Digraph d;
 		    Graph g(d);
 		    Digraph::Node n1 = d.addNode();
 		    Digraph::Node n2 = d.addNode();
 		    Digraph::Node n3 = d.addNode();
 		    Digraph::Node n4 = d.addNode();
 		    Digraph::Node n5 = d.addNode();
 		    Digraph::Node n6 = d.addNode();
 		    d.addArc(n1, n2);
 		    d.addArc(n2, n4);
 		    d.addArc(n1, n3);
 		    d.addArc(n3, n4);
 		    d.addArc(n4, n1);
 		    d.addArc(n3, n5);
 		    d.addArc(n5, n2);
 		    d.addArc(n4, n6);
@@ -184,17 +184,17 @@
 		    Digraph d;
 		    Graph g(d);
 		    Digraph::Node n0 = d.addNode();
 		    Digraph::Node n1 = d.addNode();
 		    Digraph::Node n2 = d.addNode();
 		    Digraph::Node n3 = d.addNode();
 		    Digraph::Node n4 = d.addNode();
 		    Digraph::Node n5 = d.addNode();
 		    d.addArc(n1, n2);
 		    d.addArc(n2, n3);
 		    d.addArc(n3, n1);
 		    checkDiEulerIt(d);
 		    checkDiEulerIt(d, n2);
 		    checkDiEulerIt(g);
@@ -206,17 +206,17 @@
 		    check(!eulerian(g), "This graph is not Eulerian");
+		  }
+		  {
 		    Digraph d;
 		    Graph g(d);
 		    Digraph::Node n1 = d.addNode();
 		    Digraph::Node n2 = d.addNode();
 		    Digraph::Node n3 = d.addNode();
 		    d.addArc(n1, n2);
 		    d.addArc(n2, n3);
 		    check(!eulerian(d), "This graph is not Eulerian");
 		    check(!eulerian(g), "This graph is not Eulerian");
+		  }
 		  return 0;

test/fractional_matching_test.cc

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
@@ -233,17 +233,17 @@
    } else {
      check(indeg == 0, "Invalid matching");
    }
  }
  check(pv == mfm.matchingSize(), "Wrong matching size");

  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
    check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
          (e == mfm.matching(graph.v(e)) ? 1 : 0) == 
          (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
          mfm.matching(e), "Invalid matching");
  }

  SmartGraph::NodeMap<bool> processed(graph, false);
  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
    if (processed[n]) continue;
    processed[n] = true;
    if (mfm.matching(n) == INVALID) continue;
@@ -287,17 +287,17 @@
          ++indeg;
        }
      }
      check(mfm.matching(n) != INVALID, "Invalid matching");
      check(indeg == 1, "Invalid matching");
    }
    for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
      check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
            (e == mfm.matching(graph.v(e)) ? 1 : 0) == 
            (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
            mfm.matching(e), "Invalid matching");
    }
  } else {
    int anum = 0, bnum = 0;
    SmartGraph::NodeMap<bool> neighbours(graph, false);
    for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
      if (!mfm.barrier(n)) continue;
      ++anum;
@@ -345,17 +345,17 @@
    } else {
      check(mwfm.nodeValue(n) == 0, "Invalid matching");
      check(indeg == 0, "Invalid matching");
    }
  }

  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
    check((e == mwfm.matching(graph.u(e)) ? 1 : 0) +
          (e == mwfm.matching(graph.v(e)) ? 1 : 0) == 
          (e == mwfm.matching(graph.v(e)) ? 1 : 0) ==
          mwfm.matching(e), "Invalid matching");
  }

  int dv = 0;
  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
    dv += mwfm.nodeValue(n);
  }

@@ -405,17 +405,17 @@
    check(mwpfm.matching(n) != INVALID, "Invalid perfect matching");
    check(indeg == 1, "Invalid perfect matching");
    pv += weight[mwpfm.matching(n)];
    SmartGraph::Node o = graph.target(mwpfm.matching(n));
  }

  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
    check((e == mwpfm.matching(graph.u(e)) ? 1 : 0) +
          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) == 
          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) ==
          mwpfm.matching(e), "Invalid matching");
  }

  int dv = 0;
  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
    dv += mwpfm.nodeValue(n);
  }


test/gomory_hu_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2010
 		 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 		 * (Egervary Research Group on Combinatorial Optimization, EGRES).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
 		 * express or implied, and with no claim as to its suitability for any
 		 * purpose.
+		 *
 		 */
 		#include <iostream>
 		#include "test_tools.h"
 		#include <lemon/smart_graph.h>
 		#include <lemon/concepts/graph.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/lgf_reader.h>
 		#include <lemon/gomory_hu.h>
@@ -28,17 +46,17 @@
 		  "2 3  2     1\n"
 		  "0 3  4     5\n"
 		  "0 3  5     10\n"
 		  "0 3  6     7\n"
 		  "4 2  7     1\n"
 		  "@attributes\n"
 		  "source 0\n"
 		  "target 3\n";
 		void checkGomoryHuCompile()
+		{
 		  typedef int Value;
 		  typedef concepts::Graph Graph;
 		  typedef Graph::Node Node;
 		  typedef Graph::Edge Edge;
 		  typedef concepts::ReadMap<Edge, Value> CapMap;
@@ -64,17 +82,17 @@
 		  v = const_gh_test.minCutMap(n, n, cut);
+		}
 		GRAPH_TYPEDEFS(Graph);
 		typedef Graph::EdgeMap<int> IntEdgeMap;
 		typedef Graph::NodeMap<bool> BoolNodeMap;
 		int cutValue(const Graph& graph, const BoolNodeMap& cut,
-			     const IntEdgeMap& capacity) {
+		             const IntEdgeMap& capacity) {
 		  int sum = 0;
 		  for (EdgeIt e(graph); e != INVALID; ++e) {
 		    Node s = graph.u(e);
 		    Node t = graph.v(e);
 		    if (cut[s] != cut[t]) {
 		      sum += capacity[e];
@@ -102,22 +120,22 @@
 		      BoolNodeMap cm(graph);
 		      ght.minCutMap(u, v, cm);
 		      check(pf.flowValue() == ght.minCutValue(u, v), "Wrong cut 1");
 		      check(cm[u] != cm[v], "Wrong cut 2");
 		      check(pf.flowValue() == cutValue(graph, cm, capacity), "Wrong cut 3");
 		      int sum=0;
 		      for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
-		        sum+=capacity[a];
 		        sum+=capacity[a];
 		      check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
 		      sum=0;
 		      for(GomoryHu<Graph>::MinCutNodeIt n(ght, u, v,true);n!=INVALID;++n)
 		        sum++;
 		      for(GomoryHu<Graph>::MinCutNodeIt n(ght, u, v,false);n!=INVALID;++n)
 		        sum++;
 		      check(sum == countNodes(graph), "Problem with MinCutNodeIt");
+		    }
+		  }
 		  return 0;
+		}

test/graph_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -259,17 +259,17 @@
 		  G.addEdge(G.addNode(), G.addNode());
 		  snapshot.restore();
 		  snapshot.save(G);
 		  checkGraphNodeList(G, 4);
 		  checkGraphEdgeList(G, 3);
 		  checkGraphArcList(G, 6);
 		  G.addEdge(G.addNode(), G.addNode());
 		  snapshot.restore();
 		  checkGraphNodeList(G, 4);
 		  checkGraphEdgeList(G, 3);
 		  checkGraphArcList(G, 6);
+		}
@@ -508,17 +508,17 @@
 		void checkHypercubeGraph(int dim) {
 		  GRAPH_TYPEDEFS(HypercubeGraph);
 		  HypercubeGraph G(dim);
 		  check(G.dimension() == dim, "Wrong dimension");
 		  G.resize(dim);
 		  check(G.dimension() == dim, "Wrong dimension");
 		  checkGraphNodeList(G, 1 << dim);
 		  checkGraphEdgeList(G, dim * (1 << (dim-1)));
 		  checkGraphArcList(G, dim * (1 << dim));
 		  Node n = G.nodeFromId(dim);
 		  for (NodeIt n(G); n != INVALID; ++n) {
 		    checkGraphIncEdgeList(G, n, dim);

test/hao_orlin_test.cc

Show inline comments

/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * 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).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 * precise terms see the accompanying LICENSE file.
 *
 * This software is provided "AS IS" with no warranty of any kind,
@@ -78,17 +78,17 @@
  ho_test.run();
  ho_test.run(n);

  v = const_ho_test.minCutValue();
  v = const_ho_test.minCutMap(cut);
}

template <typename Graph, typename CapMap, typename CutMap>
typename CapMap::Value 
typename CapMap::Value
  cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
{
  typename CapMap::Value sum = 0;
  for (typename Graph::ArcIt a(graph); a != INVALID; ++a) {
    if (cut[graph.source(a)] && !cut[graph.target(a)])
      sum += cap[a];
  }
  return sum;
@@ -105,59 +105,59 @@
    .arcMap("cap2", cap2)
    .arcMap("cap3", cap3)
    .run();

  {
    HaoOrlin<SmartDigraph> ho(graph, cap1);
    ho.run();
    ho.minCutMap(cut);
    

    check(ho.minCutValue() == 1, "Wrong cut value");
    check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
  }
  {
    HaoOrlin<SmartDigraph> ho(graph, cap2);
    ho.run();
    ho.minCutMap(cut);

    check(ho.minCutValue() == 1, "Wrong cut value");
    check(ho.minCutValue() == cutValue(graph, cap2, cut), "Wrong cut value");
  }
  {
    HaoOrlin<SmartDigraph> ho(graph, cap3);
    ho.run();
    ho.minCutMap(cut);
    

    check(ho.minCutValue() == 1, "Wrong cut value");
    check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
  }
  

  typedef Undirector<SmartDigraph> UGraph;
  UGraph ugraph(graph);
  

  {
    HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap1);
    ho.run();
    ho.minCutMap(cut);
    

    check(ho.minCutValue() == 2, "Wrong cut value");
    check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value");
  }
  {
    HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap2);
    ho.run();
    ho.minCutMap(cut);
    

    check(ho.minCutValue() == 5, "Wrong cut value");
    check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
  }
  {
    HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap3);
    ho.run();
    ho.minCutMap(cut);
    

    check(ho.minCutValue() == 5, "Wrong cut value");
    check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
  }

  return 0;
}

test/maps_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -220,17 +220,18 @@
+		  {
 		    checkConcept<ReadMap<A,B>, FunctorToMap<F,A,B> >();
 		    checkConcept<ReadMap<A,B>, FunctorToMap<F> >();
 		    FunctorToMap<F> map1;
 		    FunctorToMap<F> map2 = FunctorToMap<F>(F());
 		    B b = functorToMap(F())[A()];
 		    checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
-		    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 		    MapToFunctor<ReadMap<A,B> > map =
 		      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 		    check(functorToMap(&func)[A()] == 3,
 		          "Something is wrong with FunctorToMap");
 		    check(mapToFunctor(constMap<A,int>(2))(A()) == 2,
 		          "Something is wrong with MapToFunctor");
 		    check(mapToFunctor(functorToMap(&func))(A()) == 3 &&
 		          mapToFunctor(functorToMap(&func))[A()] == 3,
 		          "Something is wrong with FunctorToMap or MapToFunctor");
@@ -372,205 +373,205 @@
 		          v1[0]==20 && v1[1]==50 && v1[2]==60 &&
 		          v2[0]==20 && v2[1]==50 && v2[2]==60,
 		          "Something is wrong with LoggerBoolMap");
 		    int i = 0;
 		    for ( LoggerBoolMap<vec::iterator>::Iterator it = map2.begin();
 		          it != map2.end(); ++it )
 		      check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
 		    typedef ListDigraph Graph;
 		    DIGRAPH_TYPEDEFS(Graph);
 		    Graph gr;
 		    Node n0 = gr.addNode();
 		    Node n1 = gr.addNode();
 		    Node n2 = gr.addNode();
 		    Node n3 = gr.addNode();
 		    gr.addArc(n3, n0);
 		    gr.addArc(n3, n2);
 		    gr.addArc(n0, n2);
 		    gr.addArc(n2, n1);
 		    gr.addArc(n0, n1);
+		    {
 		      std::vector<Node> v;
 		      dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
 		      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
 		            "Something is wrong with LoggerBoolMap");
+		    }
+		    {
 		      std::vector<Node> v(countNodes(gr));
 		      dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
 		      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
 		            "Something is wrong with LoggerBoolMap");
+		    }
+		  }
 		  // IdMap, RangeIdMap
+		  {
 		    typedef ListDigraph Graph;
 		    DIGRAPH_TYPEDEFS(Graph);
 		    checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
 		    checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
 		    checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
 		    checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
 		    Graph gr;
 		    IdMap<Graph, Node> nmap(gr);
 		    IdMap<Graph, Arc> amap(gr);
 		    RangeIdMap<Graph, Node> nrmap(gr);
 		    RangeIdMap<Graph, Arc> armap(gr);
 		    Node n0 = gr.addNode();
 		    Node n1 = gr.addNode();
 		    Node n2 = gr.addNode();
 		    Arc a0 = gr.addArc(n0, n1);
 		    Arc a1 = gr.addArc(n0, n2);
 		    Arc a2 = gr.addArc(n2, n1);
 		    Arc a3 = gr.addArc(n2, n0);
 		    check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
 		    check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
 		    check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
 		    check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
 		    check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");
 		    check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
 		    check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
 		    check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
 		    check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
 		    check(nrmap.size() == 3 && armap.size() == 4,
 		          "Wrong RangeIdMap::size()");
 		    check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
 		    check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
 		    check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
 		    check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
 		    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
 		    check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
 		    check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
 		    check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
 		    check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
 		    gr.erase(n1);
 		    if (nrmap[n0] == 1) nrmap.swap(n0, n2);
 		    nrmap.swap(n2, n0);
 		    if (armap[a1] == 1) armap.swap(a1, a3);
 		    armap.swap(a3, a1);
 		    check(nrmap.size() == 2 && armap.size() == 2,
 		          "Wrong RangeIdMap::size()");
 		    check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
 		    check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
 		    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
 		    check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
 		    check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
 		    check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
+		  }
 		  // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
+		  {
 		    typedef ListGraph Graph;
 		    GRAPH_TYPEDEFS(Graph);
 		    checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
 		    checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
 		    checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
 		    checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
 		    checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
 		    checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();
 		    Graph gr;
 		    Node n0 = gr.addNode();
 		    Node n1 = gr.addNode();
 		    Node n2 = gr.addNode();
 		    gr.addEdge(n0,n1);
 		    gr.addEdge(n1,n2);
 		    gr.addEdge(n0,n2);
 		    gr.addEdge(n2,n1);
 		    gr.addEdge(n1,n2);
 		    gr.addEdge(n0,n1);
 		    for (EdgeIt e(gr); e != INVALID; ++e) {
 		      check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
 		      check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
+		    }
 		    check(mapCompare(gr,
 		          sourceMap(orienter(gr, constMap<Edge, bool>(true))),
 		          targetMap(orienter(gr, constMap<Edge, bool>(false)))),
 		          "Wrong SourceMap or TargetMap");
 		    typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
 		    Digraph dgr(gr, constMap<Edge, bool>(true));
 		    OutDegMap<Digraph> odm(dgr);
 		    InDegMap<Digraph> idm(dgr);
 		    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
 		    check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
 		    gr.addEdge(n2, n0);
 		    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
 		    check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
+		  }
 		  // CrossRefMap
+		  {
 		    typedef ListDigraph Graph;
 		    DIGRAPH_TYPEDEFS(Graph);
 		    checkConcept<ReadWriteMap<Node, int>,
 		                 CrossRefMap<Graph, Node, int> >();
 		    checkConcept<ReadWriteMap<Node, bool>,
 		                 CrossRefMap<Graph, Node, bool> >();
 		    checkConcept<ReadWriteMap<Node, double>,
 		                 CrossRefMap<Graph, Node, double> >();
 		    Graph gr;
 		    typedef CrossRefMap<Graph, Node, char> CRMap;
 		    CRMap map(gr);
 		    Node n0 = gr.addNode();
 		    Node n1 = gr.addNode();
 		    Node n2 = gr.addNode();
 		    map.set(n0, 'A');
 		    map.set(n1, 'B');
 		    map.set(n2, 'C');
 		    check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
 		          "Wrong CrossRefMap");
 		    check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
 		          "Wrong CrossRefMap");
 		    check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
 		          "Wrong CrossRefMap");
 		    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
 		          "Wrong CrossRefMap::count()");
 		    CRMap::ValueIt it = map.beginValue();
 		    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
 		          it == map.endValue(), "Wrong value iterator");
 		    map.set(n2, 'A');
 		    check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
 		          "Wrong CrossRefMap");
 		    check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
 		    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
 		    check(map('C') == INVALID && map.inverse()['C'] == INVALID,
 		          "Wrong CrossRefMap");
@@ -598,43 +599,43 @@
 		  // CrossRefMap
+		  {
 		    typedef SmartDigraph Graph;
 		    DIGRAPH_TYPEDEFS(Graph);
 		    checkConcept<ReadWriteMap<Node, int>,
 		                 CrossRefMap<Graph, Node, int> >();
 		    Graph gr;
 		    typedef CrossRefMap<Graph, Node, char> CRMap;
 		    typedef CRMap::ValueIterator ValueIt;
 		    CRMap map(gr);
 		    Node n0 = gr.addNode();
 		    Node n1 = gr.addNode();
 		    Node n2 = gr.addNode();
 		    map.set(n0, 'A');
 		    map.set(n1, 'B');
 		    map.set(n2, 'C');
 		    map.set(n2, 'A');
 		    map.set(n0, 'C');
 		    check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
 		          "Wrong CrossRefMap");
 		    check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
 		    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
 		    check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
 		    ValueIt it = map.beginValue();
 		    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
 		          it == map.endValue(), "Wrong value iterator");
+		  }
 		  // Iterable bool map
+		  {
 		    typedef SmartGraph Graph;
 		    typedef SmartGraph::Node Item;
 		    typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm;
 		    checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>();
@@ -812,38 +813,38 @@
 		    for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) {
 		      check(map1[static_cast<Item>(it)] == 1.0, "Wrong value");
 		      ++n;
+		    }
 		    check(n == num, "Wrong number");
+		  }
 		  // Graph map utilities:
 		  // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
 		  // mapFind(), mapFindIf(), mapCount(), mapCountIf()
 		  // mapCopy(), mapCompare(), mapFill()
+		  {
 		    DIGRAPH_TYPEDEFS(SmartDigraph);
 		    SmartDigraph g;
 		    Node n1 = g.addNode();
 		    Node n2 = g.addNode();
 		    Node n3 = g.addNode();
 		    SmartDigraph::NodeMap<int> map1(g);
 		    SmartDigraph::ArcMap<char> map2(g);
 		    ConstMap<Node, A> cmap1 = A();
 		    ConstMap<Arc, C> cmap2 = C(0);
 		    map1[n1] = 10;
 		    map1[n2] = 5;
 		    map1[n3] = 12;
 		    // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
 		    check(mapMin(g, map1) == n2, "Wrong mapMin()");
 		    check(mapMax(g, map1) == n3, "Wrong mapMax()");
 		    check(mapMin(g, map1, std::greater<int>()) == n3, "Wrong mapMin()");
 		    check(mapMax(g, map1, std::greater<int>()) == n2, "Wrong mapMax()");
 		    check(mapMinValue(g, map1) == 5, "Wrong mapMinValue()");
 		    check(mapMaxValue(g, map1) == 12, "Wrong mapMaxValue()");
@@ -852,17 +853,17 @@
 		    check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()");
 		    check(mapMax(g, cmap2) == INVALID, "Wrong mapMax()");
 		    Arc a1 = g.addArc(n1, n2);
 		    Arc a2 = g.addArc(n1, n3);
 		    Arc a3 = g.addArc(n2, n3);
 		    Arc a4 = g.addArc(n3, n1);
 		    map2[a1] = 'b';
 		    map2[a2] = 'a';
 		    map2[a3] = 'b';
 		    map2[a4] = 'c';
 		    // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
 		    check(mapMin(g, map2) == a2, "Wrong mapMin()");
 		    check(mapMax(g, map2) == a4, "Wrong mapMax()");
@@ -919,81 +920,81 @@
 		    check(mapCountIf(g, map1, Less<int>(5)) == 0,
 		          "Wrong mapCountIf()");
 		    check(mapCountIf(g, map2, Less<char>('d')) == 4,
 		          "Wrong mapCountIf()");
 		    check(mapCountIf(g, map2, Less<char>('c')) == 3,
 		          "Wrong mapCountIf()");
 		    check(mapCountIf(g, map2, Less<char>('a')) == 0,
 		          "Wrong mapCountIf()");
 		    // MapIt, ConstMapIt
 		/*
 		These tests can be used after applying bugfix #330
 		    typedef SmartDigraph::NodeMap<int>::MapIt MapIt;
 		    typedef SmartDigraph::NodeMap<int>::ConstMapIt ConstMapIt;
 		    check(*std::min_element(MapIt(map1), MapIt(INVALID)) == 5,
 		          "Wrong NodeMap<>::MapIt");
 		    check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12,
 		          "Wrong NodeMap<>::MapIt");
 		    int sum = 0;
 		    std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum));
 		    check(sum == 27, "Wrong NodeMap<>::MapIt");
 		    std::for_each(ConstMapIt(map1), ConstMapIt(INVALID), Sum<int>(sum));
 		    check(sum == 54, "Wrong NodeMap<>::ConstMapIt");
 		*/
 		    // mapCopy(), mapCompare(), mapFill()
 		    check(mapCompare(g, map1, map1), "Wrong mapCompare()");
 		    check(mapCompare(g, cmap2, cmap2), "Wrong mapCompare()");
 		    check(mapCompare(g, map1, shiftMap(map1, 0)), "Wrong mapCompare()");
 		    check(mapCompare(g, map2, scaleMap(map2, 1)), "Wrong mapCompare()");
 		    check(!mapCompare(g, map1, shiftMap(map1, 1)), "Wrong mapCompare()");
 		    SmartDigraph::NodeMap<int> map3(g, 0);
 		    SmartDigraph::ArcMap<char> map4(g, 'a');
 		    check(!mapCompare(g, map1, map3), "Wrong mapCompare()");
 		    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
 		    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
 		    mapCopy(g, map1, map3);
 		    mapCopy(g, map2, map4);
 		    check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()");
 		    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
 		    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
 		    Undirector<SmartDigraph> ug(g);
 		    Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x');
 		    Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14);
 		    check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
 		    check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
 		    check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
 		    check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
 		    mapCopy(g, map2, umap1);
 		    check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
 		    check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
 		    check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
 		    check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
 		    mapCopy(g, map2, umap1);
 		    mapCopy(g, umap1, map2);
 		    mapCopy(ug, map2, umap1);
 		    mapCopy(ug, umap1, map2);
 		    check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
 		    mapCopy(ug, umap1, umap2);
 		    check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
 		    check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()");
 		    mapFill(g, map1, 2);
 		    check(mapCompare(g, constMap<Node>(2), map1), "Wrong mapFill()");
 		    check(!mapCompare(g, map2, constMap<Arc>('z')), "Wrong mapCompare()");
 		    mapCopy(g, constMap<Arc>('z'), map2);
 		    check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()");
+		  }
 		  return 0;
+		}

test/matching_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -129,26 +129,26 @@
 		    const_mat_test = mat_test;
 		  mat_test.init();
 		  mat_test.greedyInit();
 		  mat_test.matchingInit(mat);
 		  mat_test.startSparse();
 		  mat_test.startDense();
 		  mat_test.run();
 		  const_mat_test.matchingSize();
 		  const_mat_test.matching(e);
 		  const_mat_test.matching(n);
 		  const MaxMatching<Graph>::MatchingMap& mmap =
 		    const_mat_test.matchingMap();
 		  e = mmap[n];
 		  const_mat_test.mate(n);
-		  MaxMatching<Graph>::Status stat =
 		  MaxMatching<Graph>::Status stat =
 		    const_mat_test.status(n);
 		  const MaxMatching<Graph>::StatusMap& smap =
 		    const_mat_test.statusMap();
 		  stat = smap[n];
 		  const_mat_test.barrier(n);
+		}
 		void checkMaxWeightedMatchingCompile()
@@ -165,26 +165,26 @@
 		  MaxWeightedMatching<Graph> mat_test(g, w);
 		  const MaxWeightedMatching<Graph>&
 		    const_mat_test = mat_test;
 		  mat_test.init();
 		  mat_test.start();
 		  mat_test.run();
 		  const_mat_test.matchingWeight();
 		  const_mat_test.matchingSize();
 		  const_mat_test.matching(e);
 		  const_mat_test.matching(n);
 		  const MaxWeightedMatching<Graph>::MatchingMap& mmap =
 		    const_mat_test.matchingMap();
 		  e = mmap[n];
 		  const_mat_test.mate(n);
 		  int k = 0;
 		  const_mat_test.dualValue();
 		  const_mat_test.nodeValue(n);
 		  const_mat_test.blossomNum();
 		  const_mat_test.blossomSize(k);
 		  const_mat_test.blossomValue(k);
+		}
@@ -202,25 +202,25 @@
 		  MaxWeightedPerfectMatching<Graph> mat_test(g, w);
 		  const MaxWeightedPerfectMatching<Graph>&
 		    const_mat_test = mat_test;
 		  mat_test.init();
 		  mat_test.start();
 		  mat_test.run();
 		  const_mat_test.matchingWeight();
 		  const_mat_test.matching(e);
 		  const_mat_test.matching(n);
 		  const MaxWeightedPerfectMatching<Graph>::MatchingMap& mmap =
 		    const_mat_test.matchingMap();
 		  e = mmap[n];
 		  const_mat_test.mate(n);
 		  int k = 0;
 		  const_mat_test.dualValue();
 		  const_mat_test.nodeValue(n);
 		  const_mat_test.blossomNum();
 		  const_mat_test.blossomSize(k);
 		  const_mat_test.blossomValue(k);
+		}
@@ -420,28 +420,28 @@
 		      mwm.init();
 		      mwm.start();
 		      checkWeightedMatching(graph, weight, mwm);
+		    }
+		    {
 		      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
 		      bool result = mwpm.run();
 		      check(result == perfect, "Perfect matching found");
 		      if (perfect) {
 		        checkWeightedPerfectMatching(graph, weight, mwpm);
+		      }
+		    }
+		    {
 		      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
 		      mwpm.init();
 		      bool result = mwpm.start();
 		      check(result == perfect, "Perfect matching found");
 		      if (perfect) {
 		        checkWeightedPerfectMatching(graph, weight, mwpm);
+		      }
+		    }
+		  }
 		  return 0;

test/min_cost_arborescence_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -105,32 +105,32 @@
 		    .run(s);
 		  mcarb_test.init();
 		  mcarb_test.addSource(s);
 		  mcarb_test.start();
 		  n = mcarb_test.processNextNode();
 		  b = const_mcarb_test.emptyQueue();
 		  i = const_mcarb_test.queueSize();
 		  c = const_mcarb_test.arborescenceCost();
 		  b = const_mcarb_test.arborescence(e);
 		  e = const_mcarb_test.pred(n);
 		  const MinCostArbType::ArborescenceMap &am =
 		    const_mcarb_test.arborescenceMap();
 		  const MinCostArbType::PredMap &pm =
 		    const_mcarb_test.predMap();
 		  b = const_mcarb_test.reached(n);
 		  b = const_mcarb_test.processed(n);
 		  i = const_mcarb_test.dualNum();
 		  c = const_mcarb_test.dualValue();
 		  i = const_mcarb_test.dualSize(i);
 		  c = const_mcarb_test.dualValue(i);
 		  ignore_unused_variable_warning(am);
 		  ignore_unused_variable_warning(pm);
+		}
 		int main() {
 		  typedef SmartDigraph Digraph;
 		  DIGRAPH_TYPEDEFS(Digraph);

test/min_cost_flow_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -47,17 +47,17 @@
 		  "    5     9    0    0    0    6   11\n"
 		  "    6    -6    0    0    0   -5   -6\n"
 		  "    7     0    0    0    0    0    0\n"
 		  "    8     0    0    0    0    0    3\n"
 		  "    9     3    0    0    0    0    0\n"
 		  "   10    -2    0    0    0   -7   -2\n"
 		  "   11     0    0    0    0  -10    0\n"
 		  "   12   -20  -27    0  -30  -30  -20\n"
-		  "\n"
 		  "\n"
 		  "@arcs\n"
 		  "       cost  cap low1 low2 low3\n"
 		  " 1  2    70   11    0    8    8\n"
 		  " 1  3   150    3    0    1    0\n"
 		  " 1  4    80   15    0    2    2\n"
 		  " 2  8    80   12    0    0    0\n"
 		  " 3  5   140    5    0    3    1\n"
 		  " 4  6    60   10    0    1    0\n"
@@ -97,17 +97,17 @@
 		  "1 3     30      0      0\n"
 		  "2 4     20      0      0\n"
 		  "3 4     80      0      0\n"
 		  "3 2     50      0      0\n"
 		  "5 3     10      0      0\n"
 		  "5 6     80      0   1000\n"
 		  "6 7     30      0  -1000\n"
 		  "7 5   -120      0      0\n";
 		char test_neg2_lgf[] =
 		  "@nodes\n"
 		  "label   sup\n"
 		  "    1   100\n"
 		  "    2  -300\n"
 		  "@arcs\n"
 		  "      cost\n"
 		  "1 2     -1\n";
@@ -146,17 +146,17 @@
 		class McfClassConcept
+		{
 		public:
 		  template <typename MCF>
 		  struct Constraints {
 		    void constraints() {
 		      checkConcept<concepts::Digraph, GR>();
 		      const Constraints& me = *this;
 		      MCF mcf(me.g);
 		      const MCF& const_mcf = mcf;
 		      b = mcf.reset().resetParams()
 		             .lowerMap(me.lower)
 		             .upperMap(me.upper)
@@ -175,17 +175,17 @@
 		    typedef typename GR::Node Node;
 		    typedef typename GR::Arc Arc;
 		    typedef concepts::ReadMap<Node, Value> NM;
 		    typedef concepts::ReadMap<Arc, Value> VAM;
 		    typedef concepts::ReadMap<Arc, Cost> CAM;
 		    typedef concepts::WriteMap<Arc, Value> FlowMap;
 		    typedef concepts::WriteMap<Node, Cost> PotMap;
 		    GR g;
 		    VAM lower;
 		    VAM upper;
 		    CAM cost;
 		    NM sup;
 		    Node n;
 		    Arc a;
 		    Value k;
@@ -229,43 +229,43 @@
 		  return true;
+		}
 		// Check the feasibility of the given potentials (dual soluiton)
 		// using the "Complementary Slackness" optimality condition
 		template < typename GR, typename LM, typename UM,
 		           typename CM, typename SM, typename FM, typename PM >
 		bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
-		                     const CM& cost, const SM& supply, const FM& flow,
 		                     const CM& cost, const SM& supply, const FM& flow,
 		                     const PM& pi, SupplyType type )
+		{
 		  TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 		  bool opt = true;
 		  for (ArcIt e(gr); opt && e != INVALID; ++e) {
 		    typename CM::Value red_cost =
 		      cost[e] + pi[gr.source(e)] - pi[gr.target(e)];
 		    opt = red_cost == 0 ||
 		          (red_cost > 0 && flow[e] == lower[e]) ||
 		          (red_cost < 0 && flow[e] == upper[e]);
+		  }
 		  for (NodeIt n(gr); opt && n != INVALID; ++n) {
 		    typename SM::Value sum = 0;
 		    for (OutArcIt e(gr, n); e != INVALID; ++e)
 		      sum += flow[e];
 		    for (InArcIt e(gr, n); e != INVALID; ++e)
 		      sum -= flow[e];
 		    if (type != LEQ) {
 		      opt = (pi[n] <= 0) && (sum == supply[n] || pi[n] == 0);
 		    } else {
 		      opt = (pi[n] >= 0) && (sum == supply[n] || pi[n] == 0);
+		    }
+		  }
 		  return opt;
+		}
 		// Check whether the dual cost is equal to the primal cost
 		template < typename GR, typename LM, typename UM,
 		           typename CM, typename SM, typename PM >
 		bool checkDualCost( const GR& gr, const LM& lower, const UM& upper,
 		                    const CM& cost, const SM& supply, const PM& pi,
@@ -280,26 +280,26 @@
+		  }
 		  for (ArcIt a(gr); a != INVALID; ++a) {
 		    if (lower[a] != 0) {
 		      dual_cost += lower[a] * cost[a];
 		      red_supply[gr.source(a)] -= lower[a];
 		      red_supply[gr.target(a)] += lower[a];
+		    }
+		  }
 		  for (NodeIt n(gr); n != INVALID; ++n) {
 		    dual_cost -= red_supply[n] * pi[n];
+		  }
 		  for (ArcIt a(gr); a != INVALID; ++a) {
 		    typename CM::Value red_cost =
 		      cost[a] + pi[gr.source(a)] - pi[gr.target(a)];
 		    dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
+		  }
 		  return dual_cost == total;
+		}
 		// Run a minimum cost flow algorithm and check the results
 		template < typename MCF, typename GR,
 		           typename LM, typename UM,
 		           typename CM, typename SM,
 		           typename PT >
@@ -327,17 +327,17 @@
+		}
 		template < typename MCF, typename Param >
 		void runMcfGeqTests( Param param,
 		                     const std::string &test_str = "",
 		                     bool full_neg_cost_support = false )
+		{
 		  MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr);
 		  // Basic tests
 		  mcf1.upperMap(u).costMap(c).supplyMap(s1);
 		  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s1,
 		           mcf1.OPTIMAL, true,     5240, test_str + "-1");
 		  mcf1.stSupply(v, w, 27);
 		  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s2,
 		           mcf1.OPTIMAL, true,     7620, test_str + "-2");
 		  mcf1.lowerMap(l2).supplyMap(s1);
@@ -430,31 +430,31 @@
 		    .nodeMap("sup2", s2)
 		    .nodeMap("sup3", s3)
 		    .nodeMap("sup4", s4)
 		    .nodeMap("sup5", s5)
 		    .nodeMap("sup6", s6)
 		    .node("source", v)
 		    .node("target", w)
 		    .run();
 		  std::istringstream neg_inp1(test_neg1_lgf);
 		  DigraphReader<Digraph>(neg1_gr, neg_inp1)
 		    .arcMap("cost", neg1_c)
 		    .arcMap("low1", neg1_l1)
 		    .arcMap("low2", neg1_l2)
 		    .nodeMap("sup", neg1_s)
 		    .run();
 		  std::istringstream neg_inp2(test_neg2_lgf);
 		  DigraphReader<Digraph>(neg2_gr, neg_inp2)
 		    .arcMap("cost", neg2_c)
 		    .nodeMap("sup", neg2_s)
 		    .run();
 		  // Check the interface of NetworkSimplex
+		  {
 		    typedef concepts::Digraph GR;
 		    checkConcept< McfClassConcept<GR, int, int>,
 		                  NetworkSimplex<GR> >();
 		    checkConcept< McfClassConcept<GR, double, double>,
 		                  NetworkSimplex<GR, double> >();
 		    checkConcept< McfClassConcept<GR, int, double>,
@@ -496,30 +496,30 @@
 		                  CycleCanceling<GR> >();
 		    checkConcept< McfClassConcept<GR, double, double>,
 		                  CycleCanceling<GR, double> >();
 		    checkConcept< McfClassConcept<GR, int, double>,
 		                  CycleCanceling<GR, int, double> >();
+		  }
 		  // Test NetworkSimplex
+		  {
+		  {
 		    typedef NetworkSimplex<Digraph> MCF;
 		    runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);
 		    runMcfLeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE");
 		    runMcfGeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE", true);
 		    runMcfLeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE");
 		    runMcfGeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS", true);
 		    runMcfLeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS");
 		    runMcfGeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL", true);
 		    runMcfLeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL");
 		    runMcfGeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL", true);
 		    runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");
+		  }
 		  // Test CapacityScaling
+		  {
 		    typedef CapacityScaling<Digraph> MCF;
 		    runMcfGeqTests<MCF>(0, "SSP");
 		    runMcfGeqTests<MCF>(2, "CAS");
+		  }
 		  // Test CostScaling

test/min_mean_cycle_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -56,48 +56,48 @@
 		  "4 4    3    3    0    0   0  0  1  0\n"
 		  "5 2    4    4    4    4   0  0  0  0\n"
 		  "5 6    3    3    3    3   0  1  0  0\n"
 		  "6 5    2    2    2    2   0  1  0  0\n"
 		  "6 4   -1   -1   -1   -1   0  0  0  0\n"
 		  "6 7    1    1    1    1   0  0  0  0\n"
 		  "7 7    4    4    4   -1   0  0  0  1\n";
 		// Check the interface of an MMC algorithm
 		template <typename GR, typename Cost>
 		struct MmcClassConcept
+		{
 		  template <typename MMC>
 		  struct Constraints {
 		    void constraints() {
 		      const Constraints& me = *this;
 		      typedef typename MMC
 		        ::template SetPath<ListPath<GR> >
 		        ::template SetLargeCost<Cost>
 		        ::Create MmcAlg;
 		      MmcAlg mmc(me.g, me.cost);
 		      const MmcAlg& const_mmc = mmc;
 		      typename MmcAlg::Tolerance tol = const_mmc.tolerance();
 		      mmc.tolerance(tol);
 		      b = mmc.cycle(p).run();
 		      b = mmc.findCycleMean();
 		      b = mmc.findCycle();
 		      v = const_mmc.cycleCost();
 		      i = const_mmc.cycleSize();
 		      d = const_mmc.cycleMean();
 		      p = const_mmc.cycle();
+		    }
 		    typedef concepts::ReadMap<typename GR::Arc, Cost> CM;
 		    GR g;
 		    CM cost;
 		    ListPath<GR> p;
 		    Cost v;
 		    int i;
 		    double d;
 		    bool b;
 		  };
@@ -148,44 +148,44 @@
+		  {
 		    typedef concepts::Digraph GR;
 		    // KarpMmc
 		    checkConcept< MmcClassConcept<GR, int>,
 		                  KarpMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
 		    checkConcept< MmcClassConcept<GR, float>,
 		                  KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
 		    // HartmannOrlinMmc
 		    checkConcept< MmcClassConcept<GR, int>,
 		                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
 		    checkConcept< MmcClassConcept<GR, float>,
 		                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
 		    // HowardMmc
 		    checkConcept< MmcClassConcept<GR, int>,
 		                  HowardMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
 		    checkConcept< MmcClassConcept<GR, float>,
 		                  HowardMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
 		    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, int> >
 		           ::LargeCost, long_int>::result == 1), "Wrong LargeCost type");
 		    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, float> >
 		           ::LargeCost, double>::result == 1), "Wrong LargeCost type");
+		  }
 		  // Run various tests
+		  {
 		    typedef SmartDigraph GR;
 		    DIGRAPH_TYPEDEFS(GR);
 		    GR gr;
 		    IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);
 		    IntArcMap c1(gr), c2(gr), c3(gr), c4(gr);
 		    std::istringstream input(test_lgf);
 		    digraphReader(gr, input).
 		      arcMap("len1", l1).
 		      arcMap("len2", l2).
 		      arcMap("len3", l3).
 		      arcMap("len4", l4).
 		      arcMap("c1", c1).
 		      arcMap("c2", c2).

test/preflow_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -89,17 +89,17 @@
 		  typedef Preflow<Digraph, CapMap>
 		            ::SetFlowMap<FlowMap>
 		            ::SetElevator<Elev>
 		            ::SetStandardElevator<LinkedElev>
 		            ::Create PreflowType;
 		  PreflowType preflow_test(g, cap, n, n);
 		  const PreflowType& const_preflow_test = preflow_test;
 		  const PreflowType::Elevator& elev = const_preflow_test.elevator();
 		  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
 		  PreflowType::Tolerance tol = const_preflow_test.tolerance();
 		  preflow_test.tolerance(tol);
 		  preflow_test
 		    .capacityMap(cap)
 		    .flowMap(flow)
@@ -113,17 +113,17 @@
 		  preflow_test.run();
 		  preflow_test.runMinCut();
 		  v = const_preflow_test.flowValue();
 		  v = const_preflow_test.flow(e);
 		  const FlowMap& fm = const_preflow_test.flowMap();
 		  b = const_preflow_test.minCut(n);
 		  const_preflow_test.minCutMap(cut);
 		  ignore_unused_variable_warning(fm);
+		}
 		int cutValue (const SmartDigraph& g,
 		              const SmartDigraph::NodeMap<bool>& cut,
 		              const SmartDigraph::ArcMap<int>& cap) {
 		  int c=0;

test/suurballe_test.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -76,17 +76,17 @@
 		void checkSuurballeCompile()
+		{
 		  typedef int VType;
 		  typedef concepts::Digraph Digraph;
 		  typedef Digraph::Node Node;
 		  typedef Digraph::Arc Arc;
 		  typedef concepts::ReadMap<Arc, VType> LengthMap;
 		  typedef Suurballe<Digraph, LengthMap> ST;
 		  typedef Suurballe<Digraph, LengthMap>
 		    ::SetFlowMap<ST::FlowMap>
 		    ::SetPotentialMap<ST::PotentialMap>
 		    ::SetPath<SimplePath<Digraph> >
 		    ::SetHeap<concepts::Heap<VType, Digraph::NodeMap<int> > >
 		    ::Create SuurballeType;
@@ -109,29 +109,29 @@
 		  k = suurb_test.run(n, n, k);
 		  suurb_test.init(n);
 		  suurb_test.fullInit(n);
 		  suurb_test.start(n);
 		  suurb_test.start(n, k);
 		  k = suurb_test.findFlow(n);
 		  k = suurb_test.findFlow(n, k);
 		  suurb_test.findPaths();
 		  int f;
 		  VType c;
 		  c = const_suurb_test.totalLength();
 		  f = const_suurb_test.flow(e);
 		  const SuurballeType::FlowMap& fm =
 		    const_suurb_test.flowMap();
 		  c = const_suurb_test.potential(n);
 		  const SuurballeType::PotentialMap& pm =
 		    const_suurb_test.potentialMap();
 		  k = const_suurb_test.pathNum();
 		  Path<Digraph> p = const_suurb_test.path(k);
 		  ignore_unused_variable_warning(fm);
 		  ignore_unused_variable_warning(pm);
+		}
 		// Check the feasibility of the flow
 		template <typename Digraph, typename FlowMap>
 		bool checkFlow( const Digraph& gr, const FlowMap& flow,
 		                typename Digraph::Node s, typename Digraph::Node t,
@@ -203,56 +203,56 @@
 		    arcMap("length", length).
 		    node("source", s).
 		    node("target", t).
 		    run();
 		  // Check run()
+		  {
 		    Suurballe<ListDigraph> suurballe(digraph, length);
 		    // Find 2 paths
 		    check(suurballe.run(s, t) == 2, "Wrong number of paths");
 		    check(checkFlow(digraph, suurballe.flowMap(), s, t, 2),
 		          "The flow is not feasible");
 		    check(suurballe.totalLength() == 510, "The flow is not optimal");
 		    check(checkOptimality(digraph, length, suurballe.flowMap(),
 		                          suurballe.potentialMap()),
 		          "Wrong potentials");
 		    for (int i = 0; i < suurballe.pathNum(); ++i)
 		      check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
 		    // Find 3 paths
 		    check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
 		    check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
 		          "The flow is not feasible");
 		    check(suurballe.totalLength() == 1040, "The flow is not optimal");
 		    check(checkOptimality(digraph, length, suurballe.flowMap(),
 		                          suurballe.potentialMap()),
 		          "Wrong potentials");
 		    for (int i = 0; i < suurballe.pathNum(); ++i)
 		      check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
 		    // Find 5 paths (only 3 can be found)
 		    check(suurballe.run(s, t, 5) == 3, "Wrong number of paths");
 		    check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
 		          "The flow is not feasible");
 		    check(suurballe.totalLength() == 1040, "The flow is not optimal");
 		    check(checkOptimality(digraph, length, suurballe.flowMap(),
 		                          suurballe.potentialMap()),
 		          "Wrong potentials");
 		    for (int i = 0; i < suurballe.pathNum(); ++i)
 		      check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
+		  }
 		  // Check fullInit() + start()
+		  {
 		    Suurballe<ListDigraph> suurballe(digraph, length);
 		    suurballe.fullInit(s);
 		    // Find 2 paths
 		    check(suurballe.start(t) == 2, "Wrong number of paths");
 		    check(suurballe.totalLength() == 510, "The flow is not optimal");
 		    // Find 3 paths
 		    check(suurballe.start(t, 3) == 3, "Wrong number of paths");
 		    check(suurballe.totalLength() == 1040, "The flow is not optimal");

test/test_tools.h

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -40,11 +40,11 @@
 		#define check(rc, msg)                                                  \
 		  {                                                                     \
 		    if(!(rc)) {                                                         \
 		      std::cerr << __FILE__ ":" << __LINE__ << ": error: "              \
 		                << msg << std::endl;                                    \
 		      abort();                                                          \
 		    } else { }                                                          \
 		  }                                                                     \
 		#endif

tools/dimacs-solver.cc

Show inline comments

 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * 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).
+		 *
 		 * Permission to use, modify and distribute this software is granted
 		 * provided that this copyright notice appears in all copies. For
 		 * precise terms see the accompanying LICENSE file.
+		 *
 		 * This software is provided "AS IS" with no warranty of any kind,
@@ -83,17 +83,17 @@
 		  readDimacsMax(is, g, cap, s, t, infty, desc);
 		  if(report) std::cerr << "Read the file: " << ti << '\n';
 		  ti.restart();
 		  Preflow<Digraph, Digraph::ArcMap<Value> > pre(g,cap,s,t);
 		  if(report) std::cerr << "Setup Preflow class: " << ti << '\n';
 		  ti.restart();
 		  pre.run();
 		  if(report) std::cerr << "Run Preflow: " << ti << '\n';
-		  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
 		  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
+		}
 		template<class Value, class LargeValue>
 		void solve_min(ArgParser &ap, std::istream &is, std::ostream &,
 		               Value infty, DimacsDescriptor &desc)
+		{
 		  bool report = !ap.given("q");
 		  Digraph g;
@@ -143,17 +143,17 @@
 		  if(report) std::cerr << "Read the file: " << ti << '\n';
 		  ti.restart();
 		  MaxMatching<Graph> mat(g);
 		  if(report) std::cerr << "Setup MaxMatching class: " << ti << '\n';
 		  ti.restart();
 		  mat.run();
 		  if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
 		  if(report) std::cerr << "\nCardinality of max matching: "
-		                       << mat.matchingSize() << '\n';
 		                       << mat.matchingSize() << '\n';
+		}
 		template<class Value, class LargeValue>
 		void solve(ArgParser &ap, std::istream &is, std::ostream &os,
 		           DimacsDescriptor &desc)
+		{
 		  std::stringstream iss(static_cast<std::string>(ap["infcap"]));
@@ -161,17 +161,17 @@
 		  iss >> infty;
 		  if(iss.fail())
+		    {
 		      std::cerr << "Cannot interpret '"
 		                << static_cast<std::string>(ap["infcap"]) << "' as infinite"
 		                << std::endl;
 		      exit(1);
+		    }
 		  switch(desc.type)
+		    {
 		    case DimacsDescriptor::MIN:
 		      solve_min<Value, LargeValue>(ap,is,os,infty,desc);
 		      break;
 		    case DimacsDescriptor::MAX:
 		      solve_max<Value>(ap,is,os,infty,desc);
 		      break;
@@ -233,17 +233,17 @@
 		    default:
 		      std::cerr << ap.commandName() << ": too many arguments\n";
 		      return 1;
+		    }
 		  std::istream& is = (ap.files().size()<1 ? std::cin : input);
 		  std::ostream& os = (ap.files().size()<2 ? std::cout : output);
 		  DimacsDescriptor desc = dimacsType(is);
 		  if(!ap.given("q"))
+		    {
 		      std::cout << "Problem type: ";
 		      switch(desc.type)
+		        {
 		        case DimacsDescriptor::MIN:
 		          std::cout << "min";
 		          break;
@@ -258,17 +258,17 @@
 		        default:
 		          exit(1);
 		          break;
+		        }
 		      std::cout << "\nNum of nodes: " << desc.nodeNum;
 		      std::cout << "\nNum of arcs:  " << desc.edgeNum;
 		      std::cout << "\n\n";
+		    }
 		  if(ap.given("double"))
 		    solve<double, double>(ap,is,os,desc);
 		  else if(ap.given("ldouble"))
 		    solve<long double, long double>(ap,is,os,desc);
 		#ifdef LEMON_HAVE_LONG_LONG
 		  else if(ap.given("long"))
 		    solve<long long, long long>(ap,is,os,desc);
 		  else solve<int, long long>(ap,is,os,desc);

RhodeCode

Login to your account

1	1	/* -- mode: C++; indent-tabs-mode: nil; --
2	2	*
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).
8	8	*
9	9	* Permission to use, modify and distribute this software is granted
10	10	* provided that this copyright notice appears in all copies. For
11	11	* precise terms see the accompanying LICENSE file.
12	12	*
13	13	* This software is provided "AS IS" with no warranty of any kind,

1	1	/* -- mode: C++; indent-tabs-mode: nil; --
2	2	*
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).
8	8	*
9	9	* Permission to use, modify and distribute this software is granted
10	10	* provided that this copyright notice appears in all copies. For
11	11	* precise terms see the accompanying LICENSE file.
12	12	*
13	13	* This software is provided "AS IS" with no warranty of any kind,