Changes in / [1359:3ec484b11733:1357:2126945deb6a] in lemon

Files:

• CMakeLists.txt (modified) (3 diffs)
• doc/Doxyfile.in (modified) (7 diffs)
• doc/groups.dox (modified) (1 diff)
• doc/named-param.dox (modified) (1 diff)
• doc/references.bib (modified) (1 diff)
• lemon/bellman_ford.h (modified) (2 diffs)
• lemon/bits/edge_set_extender.h (modified) (10 diffs)
• lemon/bits/graph_adaptor_extender.h (modified) (10 diffs)
• lemon/bits/graph_extender.h (modified) (19 diffs)
• lemon/bits/path_dump.h (modified) (1 diff)
• lemon/bits/stl_iterators.h (deleted)
• lemon/cbc.cc (modified) (1 diff)
• lemon/clp.cc (modified) (2 diffs)
• lemon/clp.h (modified) (1 diff)
• lemon/concepts/bpgraph.h (modified) (9 diffs)
• lemon/concepts/digraph.h (modified) (5 diffs)
• lemon/concepts/graph.h (modified) (7 diffs)
• lemon/concepts/path.h (modified) (4 diffs)
• lemon/config.h.in (modified) (1 diff)
• lemon/cplex.cc (modified) (4 diffs)
• lemon/glpk.cc (modified) (2 diffs)
• lemon/glpk.h (modified) (1 diff)
• lemon/list_graph.h (modified) (58 diffs)
• lemon/lp_base.h (modified) (47 diffs)
• lemon/maps.h (modified) (6 diffs)
• lemon/path.h (modified) (14 diffs)
• lemon/random.h (modified) (1 diff)
• lemon/smart_graph.h (modified) (48 diffs)
• lemon/soplex.cc (modified) (3 diffs)
• lemon/vf2.h (deleted)
• test/CMakeLists.txt (modified) (1 diff)
• test/bellman_ford_test.cc (modified) (1 diff)
• test/graph_test.h (modified) (8 diffs)
• test/lp_test.cc (modified) (3 diffs)
• test/maps_test.cc (modified) (3 diffs)
• test/vf2_test.cc (deleted)

CMakeLists.txt

@@ -4 +4 @@
   CMAKE_POLICY(SET CMP0048 OLD) 
 ENDIF(POLICY CMP0048)
-
-IF(POLICY CMP0043) 
-  CMAKE_POLICY(SET CMP0043 OLD) 
-ENDIF(POLICY CMP0043)
 
 IF(POLICY CMP0026)
@@ -239 +235 @@
     FORCE )
 
-SET_DIRECTORY_PROPERTIES(PROPERTIES
-  COMPILE_DEFINITIONS_DEBUG "LEMON_ENABLE_DEBUG"
-  COMPILE_DEFINITIONS_MAINTAINER "LEMON_ENABLE_DEBUG"
-)
 
 INCLUDE(CheckTypeSize)
@@ -271 +263 @@
 
 ENABLE_TESTING()
-
-
-INCLUDE(CheckCXXCompilerFlag)
-CHECK_CXX_COMPILER_FLAG("-std=c++11" LEMON_CXX11)
-IF(LEMON_CXX11)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-ENDIF()
-
 
 IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")

doc/Doxyfile.in

@@ -20 +20 @@
 STRIP_FROM_PATH        = "@abs_top_srcdir@"
 STRIP_FROM_INC_PATH    = "@abs_top_srcdir@"
-SHORT_NAMES            = NO
+SHORT_NAMES            = YES
 JAVADOC_AUTOBRIEF      = NO
 QT_AUTOBRIEF           = NO
@@ -40 +40 @@
 SUBGROUPING            = YES
 TYPEDEF_HIDES_STRUCT   = NO
+SYMBOL_CACHE_SIZE      = 0
 #---------------------------------------------------------------------------
 # Build related configuration options
@@ -72 +73 @@
 MAX_INITIALIZER_LINES  = 5
 SHOW_USED_FILES        = NO
+SHOW_DIRECTORIES       = YES
 SHOW_FILES             = YES
 SHOW_NAMESPACES        = YES
@@ -149 +151 @@
 HTML_COLORSTYLE_GAMMA  = 80
 HTML_TIMESTAMP         = YES
+HTML_ALIGN_MEMBERS     = YES
 HTML_DYNAMIC_SECTIONS  = YES
 GENERATE_DOCSET        = NO
@@ -175 +178 @@
 ENUM_VALUES_PER_LINE   = 4
 GENERATE_TREEVIEW      = NO
+USE_INLINE_TREES       = NO
 TREEVIEW_WIDTH         = 250
 EXT_LINKS_IN_WINDOW    = NO
@@ -221 +225 @@
 GENERATE_XML           = NO
 XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
 XML_PROGRAMLISTING     = YES
 #---------------------------------------------------------------------------
@@ -261 +267 @@
 HAVE_DOT               = YES
 DOT_NUM_THREADS        = 0
-DOT_FONTNAME           = 
+DOT_FONTNAME           = FreeSans
 DOT_FONTSIZE           = 10
 DOT_FONTPATH           = 

doc/groups.dox

@@ -562 +562 @@
 
 /**
-@defgroup graph_isomorphism Graph Isomorphism
-@ingroup algs
-\brief Algorithms for testing (sub)graph isomorphism
-
-This group contains algorithms for finding isomorph copies of a
-given graph in another one, or simply check whether two graphs are isomorphic.
-
-The formal definition of subgraph isomorphism is as follows.
-
-We are given two graphs, \f$G_1=(V_1,E_1)\f$ and \f$G_2=(V_2,E_2)\f$. A
-function \f$f:V_1\longrightarrow V_2\f$ is called \e mapping or \e
-embedding if \f$f(u)\neq f(v)\f$ whenever \f$u\neq v\f$.
-
-The standard <em>Subgraph Isomorphism Problem (SIP)</em> looks for a
-mapping with the property that whenever \f$(u,v)\in E_1\f$, then
-\f$(f(u),f(v))\in E_2\f$.
-
-In case of <em>Induced Subgraph Isomorphism Problem (ISIP)</em> one
-also requires that if \f$(u,v)\not\in E_1\f$, then \f$(f(u),f(v))\not\in
-E_2\f$
-
-In addition, the graph nodes may be \e labeled, i.e. we are given two
-node labelings \f$l_1:V_1\longrightarrow L\f$ and \f$l_2:V_2\longrightarrow
-L\f$ and we require that \f$l_1(u)=l_2(f(u))\f$ holds for all nodes \f$u \in
-G\f$.
-
-*/
-
-/**
 @defgroup planar Planar Embedding and Drawing
 @ingroup algs

doc/named-param.dox

@@ -26 +26 @@
 function parameters by name also when you call the function. It is
 especially comfortable in case of a function having tons of parameters
-with natural default values. Sadly, C++ lacks this amenity.
+with natural default values. Sadly, C++ lack this amenity.
 
 However, with a crafty trick and with some little

doc/references.bib

@@ -355 +355 @@
   pages =        {587--612}
 }
-
-@article{cordella2004sub,
-  title =        {A (sub) graph isomorphism algorithm for matching
-                  large graphs},
-  author =       {Cordella, Luigi P and Foggia, Pasquale and Sansone,
-                  Carlo and Vento, Mario},
-  journal =      {Pattern Analysis and Machine Intelligence, IEEE
-                  Transactions on},
-  volume =       26,
-  number =       10,
-  pages =        {1367--1372},
-  year =         2004,
-  publisher =    {IEEE}
-}

lemon/bellman_ford.h

@@ -30 +30 @@
 #include <lemon/maps.h>
 #include <lemon/path.h>
-#include <lemon/bits/stl_iterators.h>
 
 #include <limits>
@@ -691 +690 @@
       int _index;
     };
-
-    /// \brief Gets the collection of the active nodes.
-    ///
-    /// This function can be used for iterating on 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.
-    /// It returns a wrapped ActiveIt, which looks
-    /// like an STL container (by having begin() and end())
-    /// which you can use in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper1<ActiveIt, BellmanFord>
-    activeNodes() const {
-      return LemonRangeWrapper1<ActiveIt, BellmanFord>(*this);
-    }
-
 
     /// \name Query Functions

lemon/bits/edge_set_extender.h

@@ -114 +114 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-    }
 
     class ArcIt : public Arc {
@@ -140 +137 @@
     };
 
-    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-    }
 
     class OutArcIt : public Arc {
@@ -167 +161 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-    }
 
     class InArcIt : public Arc {
@@ -193 +184 @@
 
     };
-
-    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-    }
 
     // \brief Base node of the iterator
@@ -386 +373 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Graph>(*this);
-    }
 
     class ArcIt : public Arc {
@@ -412 +396 @@
     };
 
-    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Graph>(*this);
-    }
 
     class OutArcIt : public Arc {
@@ -439 +420 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-    }
 
     class InArcIt : public Arc {
@@ -466 +444 @@
     };
 
-    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-    }
 
     class EdgeIt : public Parent::Edge {
@@ -491 +466 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-    }
 
     class IncEdgeIt : public Parent::Edge {
@@ -520 +491 @@
       }
     };
-
-    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-    }
 
     // \brief Base node of the iterator

lemon/bits/graph_adaptor_extender.h

@@ -86 +86 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
-    }
 
     class ArcIt : public Arc {
@@ -111 +108 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
-    }
 
 
@@ -140 +133 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Adaptor, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Adaptor, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -167 +156 @@
 
     };
-
-    LemonRangeWrapper2<InArcIt, Adaptor, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Adaptor, Node>(*this, u);
-    }
 
     Node baseNode(const OutArcIt &e) const {
@@ -270 +255 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
-    }
-
 
     class ArcIt : public Arc {
@@ -296 +277 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
-    }
 
 
@@ -325 +302 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Adaptor, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Adaptor, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -353 +326 @@
     };
 
-    LemonRangeWrapper2<InArcIt, Adaptor, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Adaptor, Node>(*this, u);
-    }
-
     class EdgeIt : public Parent::Edge {
       const Adaptor* _adaptor;
@@ -378 +347 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, Adaptor> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Adaptor>(*this);
-    }
-
 
     class IncEdgeIt : public Edge {
@@ -409 +373 @@
     };
 
-    LemonRangeWrapper2<IncEdgeIt, Adaptor, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Adaptor, Node>(*this, u);
-    }
-
-
     Node baseNode(const OutArcIt &a) const {
       return Parent::source(a);

lemon/bits/graph_extender.h

@@ -28 +28 @@
 #include <lemon/concepts/maps.h>
 
-#include <lemon/bits/stl_iterators.h>
-
 //\ingroup graphbits
 //\file
@@ -119 +117 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-    }
-
 
     class ArcIt : public Arc {
@@ -145 +139 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-    }
 
 
@@ -174 +164 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -201 +187 @@
 
     };
-
-    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-    }
 
     // \brief Base node of the iterator
@@ -455 +437 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Graph>(*this);
-    }
-
 
     class ArcIt : public Arc {
@@ -481 +459 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Graph>(*this);
-    }
 
 
@@ -510 +484 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -538 +508 @@
     };
 
-    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-    }
-
 
     class EdgeIt : public Parent::Edge {
@@ -564 +530 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-    }
-
 
     class IncEdgeIt : public Parent::Edge {
@@ -594 +555 @@
       }
     };
-
-    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-    }
-
 
     // \brief Base node of the iterator
@@ -948 +904 @@
     };
 
-    LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
-    }
-
-
     class RedNodeIt : public RedNode {
       const BpGraph* _graph;
@@ -975 +926 @@
     };
 
-    LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
-      return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
-    }
-
-
     class BlueNodeIt : public BlueNode {
       const BpGraph* _graph;
@@ -1002 +948 @@
     };
 
-    LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
-      return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
-    }
-
-
 
     class ArcIt : public Arc {
@@ -1029 +970 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
-    }
 
 
@@ -1058 +995 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -1086 +1019 @@
     };
 
-    LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
-    }
-
 
     class EdgeIt : public Parent::Edge {
@@ -1112 +1041 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
-    }
-
 
     class IncEdgeIt : public Parent::Edge {
@@ -1142 +1066 @@
       }
     };
-
-    LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
-    }
-
 
     // \brief Base node of the iterator

lemon/bits/path_dump.h

@@ -62 +62 @@
       }
 
-      operator typename Digraph::Arc() const {
+      operator const typename Digraph::Arc() const {
         return path->predMap[current];
       }

lemon/cbc.cc

@@ -112 +112 @@
 
   void CbcMip::_eraseColId(int i) {
-    _cols.eraseIndex(i);
+    cols.eraseIndex(i);
   }
 
   void CbcMip::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
+    rows.eraseIndex(i);
   }
 

lemon/clp.cc

@@ -30 +30 @@
   ClpLp::ClpLp(const ClpLp& other) {
     _prob = new ClpSimplex(*other._prob);
-    _rows = other._rows;
-    _cols = other._cols;
+    rows = other.rows;
+    cols = other.cols;
     _init_temporals();
     messageLevel(MESSAGE_NOTHING);
@@ -104 +104 @@
 
   void ClpLp::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.shiftIndices(i);
+    cols.eraseIndex(i);
+    cols.shiftIndices(i);
   }
 
   void ClpLp::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.shiftIndices(i);
+    rows.eraseIndex(i);
+    rows.shiftIndices(i);
   }
 

lemon/clp.h

@@ -152 +152 @@
 
     ///Returns the constraint identifier understood by CLP.
-    int clpRow(Row r) const { return _rows(id(r)); }
+    int clpRow(Row r) const { return rows(id(r)); }
 
     ///Returns the variable identifier understood by CLP.
-    int clpCol(Col c) const { return _cols(id(c)); }
+    int clpCol(Col c) const { return cols(id(c)); }
 
   };

lemon/concepts/bpgraph.h

@@ -28 +28 @@
 #include <lemon/concept_check.h>
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -223 +222 @@
       };
 
-      /// \brief Gets the collection of the red nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the red nodes of the graph. It returns a wrapped RedNodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.redNodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
-        return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the blue nodes.
 
@@ -282 +265 @@
       };
 
-      /// \brief Gets the collection of the blue nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the blue nodes of the graph. It returns a wrapped BlueNodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.blueNodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
-        return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the nodes.
 
@@ -341 +308 @@
       };
 
-      /// \brief Gets the collection of the nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the graph. It returns a wrapped NodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
-      }
-
-
 
       /// The edge type of the graph
@@ -445 +396 @@
       };
 
-      /// \brief Gets the collection of the edges of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// edges of the graph. It returns a wrapped
-      /// EdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto e: g.edges())
-      ///   doSomething(e);
-      ///\endcode
-      LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
-        return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the incident edges of a node.
 
@@ -509 +443 @@
         IncEdgeIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the incident edges
-      ///  of a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incident undirected edges of a certain node of the graph.
-      /// It returns a wrapped
-      /// IncEdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto e: g.incEdges(u))
-      ///   doSomething(e);
-      ///\endcode
-      LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
-        return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
-      }
-
 
       /// The arc type of the graph
@@ -624 +539 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the directed arcs of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the graph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph you can write:
-      ///\code
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
-      }
-
 
       /// Iterator class for the outgoing arcs of a node.
@@ -690 +588 @@
       };
 
-      /// \brief Gets the collection of the outgoing directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the graph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -756 +636 @@
       };
 
-      /// \brief Gets the collection of the incoming directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming arcs of a certain node of the graph. It returns a wrapped
-      /// InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
-      }
-
-
       /// \brief Standard graph map type for the nodes.
       ///

lemon/concepts/digraph.h

@@ -28 +28 @@
 #include <lemon/concept_check.h>
 #include <lemon/concepts/graph_components.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -149 +148 @@
       };
 
-      /// \brief Gets the collection of the nodes of the digraph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the digraph. It returns a wrapped NodeIt, which looks
-      /// like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListDigraph g;
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-      }
-
 
       /// The arc type of the digraph
@@ -258 +238 @@
       };
 
-      /// \brief Gets the collection of the outgoing arcs of a certain node
-      /// of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the digraph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Digraph and u is a node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -324 +283 @@
       };
 
-      /// \brief Gets the collection of the incoming arcs of a certain node
-      /// of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming arcs of a certain node of the digraph. It returns a wrapped
-      /// InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Digraph and u is a node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the arcs.
 
@@ -389 +327 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the arcs of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the digraph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListDigraph g;
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-      }
-
 
       /// \brief The source node of the arc.

lemon/concepts/graph.h

@@ -28 +28 @@
 #include <lemon/concept_check.h>
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -182 +181 @@
       };
 
-      /// \brief Gets the collection of the nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the graph. It returns a wrapped NodeIt, which looks
-      /// like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, Graph>(*this);
-      }
-
 
       /// The edge type of the graph
@@ -289 +269 @@
       };
 
-      /// \brief Gets the collection of the edges of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// edges of the graph. It returns a wrapped
-      /// EdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto e: g.edges())
-      ///   doSomething(e);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.edges().begin(), g.edges().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-        return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-      }
-
-
       /// Iterator class for the incident edges of a node.
 
@@ -357 +316 @@
         IncEdgeIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the incident undirected edges
-      ///  of a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incident undirected edges of a certain node of the graph.
-      /// It returns a wrapped
-      /// IncEdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto e: g.incEdges(u))
-      ///   doSomething(e);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.incEdges(u).begin(), g.incEdges(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-        return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-      }
-
 
       /// The arc type of the graph
@@ -474 +411 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the directed arcs of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the graph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Graph>(*this);
-      }
-
 
       /// Iterator class for the outgoing arcs of a node.
@@ -544 +460 @@
       };
 
-      /// \brief Gets the collection of the outgoing directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the graph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -613 +508 @@
       };
 
-      /// \brief Gets the collection of the incoming directed arcs of
-      /// a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming directed arcs of a certain node of the graph. It returns
-      /// a wrapped InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-      }
-
       /// \brief Standard graph map type for the nodes.
       ///

lemon/concepts/path.h

@@ -27 +27 @@
 #include <lemon/core.h>
 #include <lemon/concept_check.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -117 +116 @@
       };
 
-      /// \brief Gets the collection of the arcs of the path.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Path> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Path>(*this);
-      }
-
-
       template <typename _Path>
       struct Constraints {
@@ -282 +264 @@
 
       };
-
-      /// \brief Gets the collection of the arcs of the path.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, PathDumper> arcs() const {
-        return LemonRangeWrapper1<ArcIt, PathDumper>(*this);
-      }
-
 
       /// \brief LEMON style iterator for enumerating the arcs of a path
@@ -329 +294 @@
       };
 
-      /// \brief Gets the collection of the arcs of the path
-      /// in reverse direction.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path in reverse direction. It returns a wrapped
-      /// RevArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.revArcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<RevArcIt, PathDumper> revArcs() const {
-        return LemonRangeWrapper1<RevArcIt, PathDumper>(*this);
-      }
-
-
       template <typename _Path>
       struct Constraints {

lemon/config.h.in

@@ -4 +4 @@
 #define LEMON_VERSION "@PROJECT_VERSION@"
 #cmakedefine LEMON_HAVE_LONG_LONG 1
-
-#cmakedefine LEMON_CXX11 1
 
 #cmakedefine LEMON_WIN32 1

lemon/cplex.cc

@@ -105 +105 @@
     int status;
     _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);
-    _rows = cplex._rows;
-    _cols = cplex._cols;
+    rows = cplex.rows;
+    cols = cplex.cols;
     messageLevel(MESSAGE_NOTHING);
   }
@@ -133 +133 @@
                          ExprIterator e, Value ub) {
     int i = CPXgetnumrows(cplexEnv(), _prob);
-
-    int rmatbeg = 0;
-    
+    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);
+    } else if (lb == ub){
+      const char s = 'E';
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
+    } else {
+      const char s = 'R';
+      double len = ub - lb;
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
+    }
+
     std::vector<int> indices;
+    std::vector<int> rowlist;
     std::vector<Value> values;
 
@@ -142 +155 @@
       indices.push_back(it->first);
       values.push_back(it->second);
-    }
-
-    if (lb == -INF) {
-      const char s = 'L';
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &ub, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-    } else if (ub == INF) {
-      const char s = 'G';
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &lb, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-    } else if (lb == ub){
-      const char s = 'E';
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &lb, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-    } else {
-      const char s = 'R';
-      double len = ub - lb;
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &ub, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-      CPXchgrngval(cplexEnv(), _prob, 1, &i, &len);
-    }
-    
+      rowlist.push_back(i);
+    }
+
+    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
+                   &rowlist.front(), &indices.front(), &values.front());
+
     return i;
   }
@@ -176 +173 @@
 
   void CplexBase::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.shiftIndices(i);
+    cols.eraseIndex(i);
+    cols.shiftIndices(i);
   }
   void CplexBase::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.shiftIndices(i);
+    rows.eraseIndex(i);
+    rows.shiftIndices(i);
   }
 

lemon/glpk.cc

@@ -39 +39 @@
     glp_copy_prob(lp, other.lp, GLP_ON);
     glp_create_index(lp);
-    _rows = other._rows;
-    _cols = other._cols;
+    rows = other.rows;
+    cols = other.cols;
     messageLevel(MESSAGE_NOTHING);
   }
@@ -109 +109 @@
 
   void GlpkBase::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.shiftIndices(i);
+    cols.eraseIndex(i);
+    cols.shiftIndices(i);
   }
 
   void GlpkBase::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.shiftIndices(i);
+    rows.eraseIndex(i);
+    rows.shiftIndices(i);
   }
 

lemon/glpk.h

@@ -142 +142 @@
 
     ///Returns the constraint identifier understood by GLPK.
-    int lpxRow(Row r) const { return _rows(id(r)); }
+    int lpxRow(Row r) const { return rows(id(r)); }
 
     ///Returns the variable identifier understood by GLPK.
-    int lpxCol(Col c) const { return _cols(id(c)); }
+    int lpxCol(Col c) const { return cols(id(c)); }
 
 #ifdef DOXYGEN

lemon/list_graph.h

@@ -49 +49 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node;
@@ -55 +55 @@
     int first_free_node;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -98 +98 @@
 
     ListDigraphBase()
-      : _nodes(), first_node(-1),
-        first_free_node(-1), _arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id].source); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
+      : nodes(), first_node(-1),
+        first_free_node(-1), arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id].source); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
 
 
@@ -114 +114 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
@@ -121 +121 @@
       int n;
       for(n = first_node;
-          n != -1 && _nodes[n].first_out == -1;
-          n = _nodes[n].next) {}
-      arc.id = (n == -1) ? -1 : _nodes[n].first_out;
+          n != -1 && nodes[n].first_out == -1;
+          n = nodes[n].next) {}
+      arc.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& arc) const {
-      if (_arcs[arc.id].next_out != -1) {
-        arc.id = _arcs[arc.id].next_out;
+      if (arcs[arc.id].next_out != -1) {
+        arc.id = arcs[arc.id].next_out;
       } else {
         int n;
-        for(n = _nodes[_arcs[arc.id].source].next;
-            n != -1 && _nodes[n].first_out == -1;
-            n = _nodes[n].next) {}
-        arc.id = (n == -1) ? -1 : _nodes[n].first_out;
+        for(n = nodes[arcs[arc.id].source].next;
+            n != -1 && nodes[n].first_out == -1;
+            n = nodes[n].next) {}
+        arc.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id=_arcs[e.id].next_out;
+      e.id=arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_in;
+      e.id = nodes[v.id].first_in;
     }
     void nextIn(Arc &e) const {
-      e.id=_arcs[e.id].next_in;
+      e.id=arcs[e.id].next_in;
     }
 
@@ -160 +160 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_in != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_in != -2;
     }
 
@@ -173 +173 @@
 
       if(first_free_node==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
+        n = nodes.size();
+        nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if(first_node != -1) _nodes[first_node].prev = n;
+        first_free_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if(first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].first_in = _nodes[n].first_out = -1;
+      nodes[n].prev = -1;
+
+      nodes[n].first_in = nodes[n].first_out = -1;
 
       return Node(n);
@@ -194 +194 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_in;
-      }
-
-      _arcs[n].source = u.id;
-      _arcs[n].target = v.id;
-
-      _arcs[n].next_out = _nodes[u.id].first_out;
-      if(_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = n;
-      }
-
-      _arcs[n].next_in = _nodes[v.id].first_in;
-      if(_nodes[v.id].first_in != -1) {
-        _arcs[_nodes[v.id].first_in].prev_in = n;
-      }
-
-      _arcs[n].prev_in = _arcs[n].prev_out = -1;
-
-      _nodes[u.id].first_out = _nodes[v.id].first_in = n;
+        first_free_arc = arcs[n].next_in;
+      }
+
+      arcs[n].source = u.id;
+      arcs[n].target = v.id;
+
+      arcs[n].next_out = nodes[u.id].first_out;
+      if(nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = n;
+      }
+
+      arcs[n].next_in = nodes[v.id].first_in;
+      if(nodes[v.id].first_in != -1) {
+        arcs[nodes[v.id].first_in].prev_in = n;
+      }
+
+      arcs[n].prev_in = arcs[n].prev_out = -1;
+
+      nodes[u.id].first_out = nodes[v.id].first_in = n;
 
       return Arc(n);
@@ -224 +224 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
-      } else {
-        first_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_free_node;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
+      } else {
+        first_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_free_node;
       first_free_node = n;
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
 
     }
@@ -243 +243 @@
       int n = arc.id;
 
-      if(_arcs[n].next_in!=-1) {
-        _arcs[_arcs[n].next_in].prev_in = _arcs[n].prev_in;
-      }
-
-      if(_arcs[n].prev_in!=-1) {
-        _arcs[_arcs[n].prev_in].next_in = _arcs[n].next_in;
-      } else {
-        _nodes[_arcs[n].target].first_in = _arcs[n].next_in;
-      }
-
-
-      if(_arcs[n].next_out!=-1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if(_arcs[n].prev_out!=-1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
-      } else {
-        _nodes[_arcs[n].source].first_out = _arcs[n].next_out;
-      }
-
-      _arcs[n].next_in = first_free_arc;
+      if(arcs[n].next_in!=-1) {
+        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+      }
+
+      if(arcs[n].prev_in!=-1) {
+        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
+      } else {
+        nodes[arcs[n].target].first_in = arcs[n].next_in;
+      }
+
+
+      if(arcs[n].next_out!=-1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if(arcs[n].prev_out!=-1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
+      } else {
+        nodes[arcs[n].source].first_out = arcs[n].next_out;
+      }
+
+      arcs[n].next_in = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_in = -2;
+      arcs[n].prev_in = -2;
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_node = first_free_arc = -1;
     }
@@ -278 +278 @@
     void changeTarget(Arc e, Node n)
     {
-      if(_arcs[e.id].next_in != -1)
-        _arcs[_arcs[e.id].next_in].prev_in = _arcs[e.id].prev_in;
-      if(_arcs[e.id].prev_in != -1)
-        _arcs[_arcs[e.id].prev_in].next_in = _arcs[e.id].next_in;
-      else _nodes[_arcs[e.id].target].first_in = _arcs[e.id].next_in;
-      if (_nodes[n.id].first_in != -1) {
-        _arcs[_nodes[n.id].first_in].prev_in = e.id;
-      }
-      _arcs[e.id].target = n.id;
-      _arcs[e.id].prev_in = -1;
-      _arcs[e.id].next_in = _nodes[n.id].first_in;
-      _nodes[n.id].first_in = e.id;
+      if(arcs[e.id].next_in != -1)
+        arcs[arcs[e.id].next_in].prev_in = arcs[e.id].prev_in;
+      if(arcs[e.id].prev_in != -1)
+        arcs[arcs[e.id].prev_in].next_in = arcs[e.id].next_in;
+      else nodes[arcs[e.id].target].first_in = arcs[e.id].next_in;
+      if (nodes[n.id].first_in != -1) {
+        arcs[nodes[n.id].first_in].prev_in = e.id;
+      }
+      arcs[e.id].target = n.id;
+      arcs[e.id].prev_in = -1;
+      arcs[e.id].next_in = nodes[n.id].first_in;
+      nodes[n.id].first_in = e.id;
     }
     void changeSource(Arc e, Node n)
     {
-      if(_arcs[e.id].next_out != -1)
-        _arcs[_arcs[e.id].next_out].prev_out = _arcs[e.id].prev_out;
-      if(_arcs[e.id].prev_out != -1)
-        _arcs[_arcs[e.id].prev_out].next_out = _arcs[e.id].next_out;
-      else _nodes[_arcs[e.id].source].first_out = _arcs[e.id].next_out;
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = e.id;
-      }
-      _arcs[e.id].source = n.id;
-      _arcs[e.id].prev_out = -1;
-      _arcs[e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = e.id;
+      if(arcs[e.id].next_out != -1)
+        arcs[arcs[e.id].next_out].prev_out = arcs[e.id].prev_out;
+      if(arcs[e.id].prev_out != -1)
+        arcs[arcs[e.id].prev_out].next_out = arcs[e.id].next_out;
+      else nodes[arcs[e.id].source].first_out = arcs[e.id].next_out;
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = e.id;
+      }
+      arcs[e.id].source = n.id;
+      arcs[e.id].prev_out = -1;
+      arcs[e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = e.id;
     }
 
@@ -487 +487 @@
     Node split(Node n, bool connect = true) {
       Node b = addNode();
-      _nodes[b.id].first_out=_nodes[n.id].first_out;
-      _nodes[n.id].first_out=-1;
-      for(int i=_nodes[b.id].first_out; i!=-1; i=_arcs[i].next_out) {
-        _arcs[i].source=b.id;
+      nodes[b.id].first_out=nodes[n.id].first_out;
+      nodes[n.id].first_out=-1;
+      for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
+        arcs[i].source=b.id;
       }
       if (connect) addArc(n,b);
@@ -533 +533 @@
     /// to build the digraph.
     /// \sa reserveArc()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for arcs.
@@ -543 +543 @@
     /// to build the digraph.
     /// \sa reserveNode()
-    void reserveArc(int m) { _arcs.reserve(m); };
+    void reserveArc(int m) { arcs.reserve(m); };
 
     /// \brief Class to make a snapshot of the digraph and restore
@@ -804 +804 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node;
@@ -810 +810 @@
     int first_free_node;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -868 +868 @@
 
     ListGraphBase()
-      : _nodes(), first_node(-1),
-        first_free_node(-1), _arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
-
-    Node u(Edge e) const { return Node(_arcs[2 * e.id].target); }
-    Node v(Edge e) const { return Node(_arcs[2 * e.id + 1].target); }
+      : nodes(), first_node(-1),
+        first_free_node(-1), arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
+
+    Node u(Edge e) const { return Node(arcs[2 * e.id].target); }
+    Node v(Edge e) const { return Node(arcs[2 * e.id + 1].target); }
 
     static bool direction(Arc e) {
@@ -895 +895 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
     void first(Arc& e) const {
       int n = first_node;
-      while (n != -1 && _nodes[n].first_out == -1) {
-        n = _nodes[n].next;
-      }
-      e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      while (n != -1 && nodes[n].first_out == -1) {
+        n = nodes[n].next;
+      }
+      e.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& e) const {
-      if (_arcs[e.id].next_out != -1) {
-        e.id = _arcs[e.id].next_out;
-      } else {
-        int n = _nodes[_arcs[e.id ^ 1].target].next;
-        while(n != -1 && _nodes[n].first_out == -1) {
-          n = _nodes[n].next;
-        }
-        e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      if (arcs[e.id].next_out != -1) {
+        e.id = arcs[e.id].next_out;
+      } else {
+        int n = nodes[arcs[e.id ^ 1].target].next;
+        while(n != -1 && nodes[n].first_out == -1) {
+          n = nodes[n].next;
+        }
+        e.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
@@ -921 +921 @@
       int n = first_node;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -929 +929 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -935 +935 @@
 
     void next(Edge& e) const {
-      int n = _arcs[e.id * 2].target;
-      e.id = _arcs[(e.id * 2) | 1].next_out;
+      int n = arcs[e.id * 2].target;
+      e.id = arcs[(e.id * 2) | 1].next_out;
       while ((e.id & 1) != 1) {
-        e.id = _arcs[e.id].next_out;
+        e.id = arcs[e.id].next_out;
       }
       if (e.id != -1) {
@@ -944 +944 @@
         return;
       }
-      n = _nodes[n].next;
+      n = nodes[n].next;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -954 +954 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -960 +960 @@
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id = _arcs[e.id].next_out;
+      e.id = arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = ((_nodes[v.id].first_out) ^ 1);
+      e.id = ((nodes[v.id].first_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
     void nextIn(Arc &e) const {
-      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
+      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
 
     void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = _nodes[v.id].first_out;
+      int a = nodes[v.id].first_out;
       if (a != -1 ) {
         e.id = a / 2;
@@ -986 +986 @@
     }
     void nextInc(Edge &e, bool& d) const {
-      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
+      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
       if (a != -1 ) {
         e.id = a / 2;
@@ -1005 +1005 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_out != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_out != -2;
     }
 
     bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
-        _arcs[2 * e.id].prev_out != -2;
+      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
+        arcs[2 * e.id].prev_out != -2;
     }
 
@@ -1023 +1023 @@
 
       if(first_free_node==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
+        n = nodes.size();
+        nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
+        first_free_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].first_out = -1;
+      nodes[n].prev = -1;
+
+      nodes[n].first_out = -1;
 
       return Node(n);
@@ -1044 +1044 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_out;
-      }
-
-      _arcs[n].target = u.id;
-      _arcs[n | 1].target = v.id;
-
-      _arcs[n].next_out = _nodes[v.id].first_out;
-      if (_nodes[v.id].first_out != -1) {
-        _arcs[_nodes[v.id].first_out].prev_out = n;
-      }
-      _arcs[n].prev_out = -1;
-      _nodes[v.id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u.id].first_out;
-      if (_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
-      }
-      _arcs[n | 1].prev_out = -1;
-      _nodes[u.id].first_out = (n | 1);
+        first_free_arc = arcs[n].next_out;
+      }
+
+      arcs[n].target = u.id;
+      arcs[n | 1].target = v.id;
+
+      arcs[n].next_out = nodes[v.id].first_out;
+      if (nodes[v.id].first_out != -1) {
+        arcs[nodes[v.id].first_out].prev_out = n;
+      }
+      arcs[n].prev_out = -1;
+      nodes[v.id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u.id].first_out;
+      if (nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+      }
+      arcs[n | 1].prev_out = -1;
+      nodes[u.id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -1075 +1075 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
-      } else {
-        first_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_free_node;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
+      } else {
+        first_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_free_node;
       first_free_node = n;
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
     }
 
@@ -1093 +1093 @@
       int n = edge.id * 2;
 
-      if (_arcs[n].next_out != -1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if (_arcs[n].prev_out != -1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
-      } else {
-        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
-      }
-
-      if (_arcs[n | 1].next_out != -1) {
-        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
-      }
-
-      if (_arcs[n | 1].prev_out != -1) {
-        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
-      } else {
-        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
-      }
-
-      _arcs[n].next_out = first_free_arc;
+      if (arcs[n].next_out != -1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if (arcs[n].prev_out != -1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
+      } else {
+        nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
+      }
+
+      if (arcs[n | 1].next_out != -1) {
+        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+      }
+
+      if (arcs[n | 1].prev_out != -1) {
+        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
+      } else {
+        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
+      }
+
+      arcs[n].next_out = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_out = -2;
-      _arcs[n | 1].prev_out = -2;
+      arcs[n].prev_out = -2;
+      arcs[n | 1].prev_out = -2;
 
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_node = first_free_arc = -1;
     }
@@ -1129 +1129 @@
 
     void changeV(Edge e, Node n) {
-      if(_arcs[2 * e.id].next_out != -1) {
-        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
-      }
-      if(_arcs[2 * e.id].prev_out != -1) {
-        _arcs[_arcs[2 * e.id].prev_out].next_out =
-          _arcs[2 * e.id].next_out;
-      } else {
-        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
-          _arcs[2 * e.id].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
-      }
-      _arcs[(2 * e.id) | 1].target = n.id;
-      _arcs[2 * e.id].prev_out = -1;
-      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = 2 * e.id;
+      if(arcs[2 * e.id].next_out != -1) {
+        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+      }
+      if(arcs[2 * e.id].prev_out != -1) {
+        arcs[arcs[2 * e.id].prev_out].next_out =
+          arcs[2 * e.id].next_out;
+      } else {
+        nodes[arcs[(2 * e.id) | 1].target].first_out =
+          arcs[2 * e.id].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+      }
+      arcs[(2 * e.id) | 1].target = n.id;
+      arcs[2 * e.id].prev_out = -1;
+      arcs[2 * e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = 2 * e.id;
     }
 
     void changeU(Edge e, Node n) {
-      if(_arcs[(2 * e.id) | 1].next_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
-          _arcs[(2 * e.id) | 1].prev_out;
-      }
-      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      } else {
-        _nodes[_arcs[2 * e.id].target].first_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
-      }
-      _arcs[2 * e.id].target = n.id;
-      _arcs[(2 * e.id) | 1].prev_out = -1;
-      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = ((2 * e.id) | 1);
+      if(arcs[(2 * e.id) | 1].next_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
+          arcs[(2 * e.id) | 1].prev_out;
+      }
+      if(arcs[(2 * e.id) | 1].prev_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
+          arcs[(2 * e.id) | 1].next_out;
+      } else {
+        nodes[arcs[2 * e.id].target].first_out =
+          arcs[(2 * e.id) | 1].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+      }
+      arcs[2 * e.id].target = n.id;
+      arcs[(2 * e.id) | 1].prev_out = -1;
+      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = ((2 * e.id) | 1);
     }
 
@@ -1210 +1210 @@
     ListGraph() {}
 
-    typedef Parent::IncEdgeIt IncEdgeIt;
+    typedef Parent::OutArcIt IncEdgeIt;
 
     /// \brief Add a new node to the graph.
@@ -1345 +1345 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -1355 +1355 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
@@ -1618 +1618 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node, first_red, first_blue;
@@ -1625 +1625 @@
     int first_free_red, first_free_blue;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -1707 +1707 @@
 
     ListBpGraphBase()
-      : _nodes(), first_node(-1),
+      : nodes(), first_node(-1),
         first_red(-1), first_blue(-1),
         max_red(-1), max_blue(-1),
         first_free_red(-1), first_free_blue(-1),
-        _arcs(), first_free_arc(-1) {}
-
-
-    bool red(Node n) const { return _nodes[n.id].red; }
-    bool blue(Node n) const { return !_nodes[n.id].red; }
+        arcs(), first_free_arc(-1) {}
+
+
+    bool red(Node n) const { return nodes[n.id].red; }
+    bool blue(Node n) const { return !nodes[n.id].red; }
 
     static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
     static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
 
-    int maxNodeId() const { return _nodes.size()-1; }
+    int maxNodeId() const { return nodes.size()-1; }
     int maxRedId() const { return max_red; }
     int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
 
     RedNode redNode(Edge e) const {
-      return RedNode(_arcs[2 * e.id].target);
+      return RedNode(arcs[2 * e.id].target);
     }
     BlueNode blueNode(Edge e) const {
-      return BlueNode(_arcs[2 * e.id + 1].target);
+      return BlueNode(arcs[2 * e.id + 1].target);
     }
 
@@ -1749 +1749 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
@@ -1757 +1757 @@
 
     void next(RedNode& node) const {
-      node.id = _nodes[node.id].partition_next;
+      node.id = nodes[node.id].partition_next;
     }
 
@@ -1765 +1765 @@
 
     void next(BlueNode& node) const {
-      node.id = _nodes[node.id].partition_next;
+      node.id = nodes[node.id].partition_next;
     }
 
     void first(Arc& e) const {
       int n = first_node;
-      while (n != -1 && _nodes[n].first_out == -1) {
-        n = _nodes[n].next;
-      }
-      e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      while (n != -1 && nodes[n].first_out == -1) {
+        n = nodes[n].next;
+      }
+      e.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& e) const {
-      if (_arcs[e.id].next_out != -1) {
-        e.id = _arcs[e.id].next_out;
-      } else {
-        int n = _nodes[_arcs[e.id ^ 1].target].next;
-        while(n != -1 && _nodes[n].first_out == -1) {
-          n = _nodes[n].next;
-        }
-        e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      if (arcs[e.id].next_out != -1) {
+        e.id = arcs[e.id].next_out;
+      } else {
+        int n = nodes[arcs[e.id ^ 1].target].next;
+        while(n != -1 && nodes[n].first_out == -1) {
+          n = nodes[n].next;
+        }
+        e.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
@@ -1791 +1791 @@
       int n = first_node;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -1799 +1799 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -1805 +1805 @@
 
     void next(Edge& e) const {
-      int n = _arcs[e.id * 2].target;
-      e.id = _arcs[(e.id * 2) | 1].next_out;
+      int n = arcs[e.id * 2].target;
+      e.id = arcs[(e.id * 2) | 1].next_out;
       while ((e.id & 1) != 1) {
-        e.id = _arcs[e.id].next_out;
+        e.id = arcs[e.id].next_out;
       }
       if (e.id != -1) {
@@ -1814 +1814 @@
         return;
       }
-      n = _nodes[n].next;
+      n = nodes[n].next;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -1824 +1824 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -1830 +1830 @@
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id = _arcs[e.id].next_out;
+      e.id = arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = ((_nodes[v.id].first_out) ^ 1);
+      e.id = ((nodes[v.id].first_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
     void nextIn(Arc &e) const {
-      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
+      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
 
     void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = _nodes[v.id].first_out;
+      int a = nodes[v.id].first_out;
       if (a != -1 ) {
         e.id = a / 2;
@@ -1856 +1856 @@
     }
     void nextInc(Edge &e, bool& d) const {
-      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
+      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
       if (a != -1 ) {
         e.id = a / 2;
@@ -1867 +1867 @@
 
     static int id(Node v) { return v.id; }
-    int id(RedNode v) const { return _nodes[v.id].partition_index; }
-    int id(BlueNode v) const { return _nodes[v.id].partition_index; }
+    int id(RedNode v) const { return nodes[v.id].partition_index; }
+    int id(BlueNode v) const { return nodes[v.id].partition_index; }
     static int id(Arc e) { return e.id; }
     static int id(Edge e) { return e.id; }
@@ -1877 +1877 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_out != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_out != -2;
     }
 
     bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
-        _arcs[2 * e.id].prev_out != -2;
+      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
+        arcs[2 * e.id].prev_out != -2;
     }
 
@@ -1895 +1895 @@
 
       if(first_free_red==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
-        _nodes[n].partition_index = ++max_red;
-        _nodes[n].red = true;
+        n = nodes.size();
+        nodes.push_back(NodeT());
+        nodes[n].partition_index = ++max_red;
+        nodes[n].red = true;
       } else {
         n = first_free_red;
-        first_free_red = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
+        first_free_red = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].partition_next = first_red;
-      if (first_red != -1) _nodes[first_red].partition_prev = n;
+      nodes[n].prev = -1;
+
+      nodes[n].partition_next = first_red;
+      if (first_red != -1) nodes[first_red].partition_prev = n;
       first_red = n;
-      _nodes[n].partition_prev = -1;
-
-      _nodes[n].first_out = -1;
+      nodes[n].partition_prev = -1;
+
+      nodes[n].first_out = -1;
 
       return RedNode(n);
@@ -1923 +1923 @@
 
       if(first_free_blue==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
-        _nodes[n].partition_index = ++max_blue;
-        _nodes[n].red = false;
+        n = nodes.size();
+        nodes.push_back(NodeT());
+        nodes[n].partition_index = ++max_blue;
+        nodes[n].red = false;
       } else {
         n = first_free_blue;
-        first_free_blue = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
+        first_free_blue = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].partition_next = first_blue;
-      if (first_blue != -1) _nodes[first_blue].partition_prev = n;
+      nodes[n].prev = -1;
+
+      nodes[n].partition_next = first_blue;
+      if (first_blue != -1) nodes[first_blue].partition_prev = n;
       first_blue = n;
-      _nodes[n].partition_prev = -1;
-
-      _nodes[n].first_out = -1;
+      nodes[n].partition_prev = -1;
+
+      nodes[n].first_out = -1;
 
       return BlueNode(n);
@@ -1951 +1951 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_out;
-      }
-
-      _arcs[n].target = u.id;
-      _arcs[n | 1].target = v.id;
-
-      _arcs[n].next_out = _nodes[v.id].first_out;
-      if (_nodes[v.id].first_out != -1) {
-        _arcs[_nodes[v.id].first_out].prev_out = n;
-      }
-      _arcs[n].prev_out = -1;
-      _nodes[v.id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u.id].first_out;
-      if (_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
-      }
-      _arcs[n | 1].prev_out = -1;
-      _nodes[u.id].first_out = (n | 1);
+        first_free_arc = arcs[n].next_out;
+      }
+
+      arcs[n].target = u.id;
+      arcs[n | 1].target = v.id;
+
+      arcs[n].next_out = nodes[v.id].first_out;
+      if (nodes[v.id].first_out != -1) {
+        arcs[nodes[v.id].first_out].prev_out = n;
+      }
+      arcs[n].prev_out = -1;
+      nodes[v.id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u.id].first_out;
+      if (nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+      }
+      arcs[n | 1].prev_out = -1;
+      nodes[u.id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -1982 +1982 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
-      } else {
-        first_node = _nodes[n].next;
-      }
-
-      if (_nodes[n].partition_next != -1) {
-        _nodes[_nodes[n].partition_next].partition_prev = _nodes[n].partition_prev;
-      }
-
-      if (_nodes[n].partition_prev != -1) {
-        _nodes[_nodes[n].partition_prev].partition_next = _nodes[n].partition_next;
-      } else {
-        if (_nodes[n].red) {
-          first_red = _nodes[n].partition_next;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
+      } else {
+        first_node = nodes[n].next;
+      }
+
+      if (nodes[n].partition_next != -1) {
+        nodes[nodes[n].partition_next].partition_prev = nodes[n].partition_prev;
+      }
+
+      if (nodes[n].partition_prev != -1) {
+        nodes[nodes[n].partition_prev].partition_next = nodes[n].partition_next;
+      } else {
+        if (nodes[n].red) {
+          first_red = nodes[n].partition_next;
         } else {
-          first_blue = _nodes[n].partition_next;
-        }
-      }
-
-      if (_nodes[n].red) {
-        _nodes[n].next = first_free_red;
+          first_blue = nodes[n].partition_next;
+        }
+      }
+
+      if (nodes[n].red) {
+        nodes[n].next = first_free_red;
         first_free_red = n;
       } else {
-        _nodes[n].next = first_free_blue;
+        nodes[n].next = first_free_blue;
         first_free_blue = n;
       }
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
     }
 
@@ -2019 +2019 @@
       int n = edge.id * 2;
 
-      if (_arcs[n].next_out != -1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if (_arcs[n].prev_out != -1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
-      } else {
-        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
-      }
-
-      if (_arcs[n | 1].next_out != -1) {
-        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
-      }
-
-      if (_arcs[n | 1].prev_out != -1) {
-        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
-      } else {
-        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
-      }
-
-      _arcs[n].next_out = first_free_arc;
+      if (arcs[n].next_out != -1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if (arcs[n].prev_out != -1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
+      } else {
+        nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
+      }
+
+      if (arcs[n | 1].next_out != -1) {
+        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+      }
+
+      if (arcs[n | 1].prev_out != -1) {
+        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
+      } else {
+        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
+      }
+
+      arcs[n].next_out = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_out = -2;
-      _arcs[n | 1].prev_out = -2;
+      arcs[n].prev_out = -2;
+      arcs[n | 1].prev_out = -2;
 
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_arc = first_red = first_blue =
         max_red = max_blue = first_free_red = first_free_blue = -1;
@@ -2056 +2056 @@
 
     void changeRed(Edge e, RedNode n) {
-      if(_arcs[(2 * e.id) | 1].next_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
-          _arcs[(2 * e.id) | 1].prev_out;
-      }
-      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      } else {
-        _nodes[_arcs[2 * e.id].target].first_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
-      }
-      _arcs[2 * e.id].target = n.id;
-      _arcs[(2 * e.id) | 1].prev_out = -1;
-      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = ((2 * e.id) | 1);
+      if(arcs[(2 * e.id) | 1].next_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
+          arcs[(2 * e.id) | 1].prev_out;
+      }
+      if(arcs[(2 * e.id) | 1].prev_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
+          arcs[(2 * e.id) | 1].next_out;
+      } else {
+        nodes[arcs[2 * e.id].target].first_out =
+          arcs[(2 * e.id) | 1].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+      }
+      arcs[2 * e.id].target = n.id;
+      arcs[(2 * e.id) | 1].prev_out = -1;
+      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = ((2 * e.id) | 1);
     }
 
     void changeBlue(Edge e, BlueNode n) {
-       if(_arcs[2 * e.id].next_out != -1) {
-        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
-      }
-      if(_arcs[2 * e.id].prev_out != -1) {
-        _arcs[_arcs[2 * e.id].prev_out].next_out =
-          _arcs[2 * e.id].next_out;
-      } else {
-        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
-          _arcs[2 * e.id].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
-      }
-      _arcs[(2 * e.id) | 1].target = n.id;
-      _arcs[2 * e.id].prev_out = -1;
-      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = 2 * e.id;
+       if(arcs[2 * e.id].next_out != -1) {
+        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+      }
+      if(arcs[2 * e.id].prev_out != -1) {
+        arcs[arcs[2 * e.id].prev_out].next_out =
+          arcs[2 * e.id].next_out;
+      } else {
+        nodes[arcs[(2 * e.id) | 1].target].first_out =
+          arcs[2 * e.id].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+      }
+      arcs[(2 * e.id) | 1].target = n.id;
+      arcs[2 * e.id].prev_out = -1;
+      arcs[2 * e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = 2 * e.id;
     }
 
@@ -2137 +2137 @@
     ListBpGraph() {}
 
-    typedef Parent::IncEdgeIt IncEdgeIt;
+    typedef Parent::OutArcIt IncEdgeIt;
 
     /// \brief Add a new red node to the graph.
@@ -2250 +2250 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -2260 +2260 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore

lemon/lp_base.h

@@ -32 +32 @@
 #include<lemon/bits/solver_bits.h>
 
-#include<lemon/bits/stl_iterators.h>
-
 ///\file
 ///\brief The interface of the LP solver interface.
@@ -48 +46 @@
   protected:
 
-    _solver_bits::VarIndex _rows;
-    _solver_bits::VarIndex _cols;
+    _solver_bits::VarIndex rows;
+    _solver_bits::VarIndex cols;
 
   public:
@@ -169 +167 @@
       ColIt(const LpBase &solver) : _solver(&solver)
       {
-        _solver->_cols.firstItem(_id);
+        _solver->cols.firstItem(_id);
       }
       /// Invalid constructor \& conversion
@@ -182 +180 @@
       ColIt &operator++()
       {
-        _solver->_cols.nextItem(_id);
+        _solver->cols.nextItem(_id);
         return *this;
       }
     };
-
-    /// \brief Gets the collection of the columns of the LP problem.
-    ///
-    /// This function can be used for iterating on
-    /// the columns of the LP problem. It returns a wrapped ColIt, which looks
-    /// like an STL container (by having begin() and end())
-    /// which you can use in range-based for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto c: lp.cols())
-    ///   doSomething(c);
-    ///\endcode
-    LemonRangeWrapper1<ColIt, LpBase> cols() {
-      return LemonRangeWrapper1<ColIt, LpBase>(*this);
-    }
-
 
     /// \brief Returns the ID of the column.
@@ -280 +262 @@
       RowIt(const LpBase &solver) : _solver(&solver)
       {
-        _solver->_rows.firstItem(_id);
+        _solver->rows.firstItem(_id);
       }
       /// Invalid constructor \& conversion
@@ -293 +275 @@
       RowIt &operator++()
       {
-        _solver->_rows.nextItem(_id);
+        _solver->rows.nextItem(_id);
         return *this;
       }
     };
-    
-    /// \brief Gets the collection of the rows of the LP problem.
-    ///
-    /// This function can be used for iterating on
-    /// the rows of the LP problem. It returns a wrapped RowIt, which looks
-    /// like an STL container (by having begin() and end())
-    /// which you can use in range-based for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto c: lp.rows())
-    ///   doSomething(c);
-    ///\endcode
-    LemonRangeWrapper1<RowIt, LpBase> rows() {
-      return LemonRangeWrapper1<RowIt, LpBase>(*this);
-    }
-    
 
     /// \brief Returns the ID of the row.
@@ -660 +626 @@
     ///This data structure represents a column of the matrix,
     ///thas is it strores a linear expression of the dual variables
-    ///(\ref LpBase::Row "Row"s).
+    ///(\ref Row "Row"s).
     ///
     ///There are several ways to access and modify the contents of this
@@ -677 +643 @@
     ///(This code computes the sum of all coefficients).
     ///- Numbers (<tt>double</tt>'s)
-    ///and variables (\ref LpBase::Row "Row"s) directly convert to an
+    ///and variables (\ref Row "Row"s) directly convert to an
     ///\ref DualExpr and the usual linear operations are defined, so
     ///\code
@@ -969 +935 @@
     //Abstract virtual functions
 
-    virtual int _addColId(int col) { return _cols.addIndex(col); }
-    virtual int _addRowId(int row) { return _rows.addIndex(row); }
-
-    virtual void _eraseColId(int col) { _cols.eraseIndex(col); }
-    virtual void _eraseRowId(int row) { _rows.eraseIndex(row); }
+    virtual int _addColId(int col) { return cols.addIndex(col); }
+    virtual int _addRowId(int row) { return rows.addIndex(row); }
+
+    virtual void _eraseColId(int col) { cols.eraseIndex(col); }
+    virtual void _eraseRowId(int row) { rows.eraseIndex(row); }
 
     virtual int _addCol() = 0;
@@ -1038 +1004 @@
     Value obj_const_comp;
 
-    LpBase() : _rows(), _cols(), obj_const_comp(0) {}
+    LpBase() : rows(), cols(), obj_const_comp(0) {}
 
   public:
@@ -1150 +1116 @@
     void col(Col c, const DualExpr &e) {
       e.simplify();
-      _setColCoeffs(_cols(id(c)), ExprIterator(e.comps.begin(), _rows),
-                    ExprIterator(e.comps.end(), _rows));
+      _setColCoeffs(cols(id(c)), ExprIterator(e.comps.begin(), rows),
+                    ExprIterator(e.comps.end(), rows));
     }
 
@@ -1160 +1126 @@
     DualExpr col(Col c) const {
       DualExpr e;
-      _getColCoeffs(_cols(id(c)), InsertIterator(e.comps, _rows));
+      _getColCoeffs(cols(id(c)), InsertIterator(e.comps, rows));
       return e;
     }
@@ -1189 +1155 @@
     ///\param t can be
     ///- a standard STL compatible iterable container with
-    ///\ref LpBase::Row "Row" as its \c values_type like
+    ///\ref Row as its \c values_type like
     ///\code
     ///std::vector<LpBase::Row>
@@ -1195 +1161 @@
     ///\endcode
     ///- a standard STL compatible iterable container with
-    ///\ref LpBase::Row "Row" as its \c mapped_type like
+    ///\ref Row as its \c mapped_type like
     ///\code
     ///std::map<AnyType,LpBase::Row>
@@ -1247 +1213 @@
     void row(Row r, Value l, const Expr &e, Value u) {
       e.simplify();
-      _setRowCoeffs(_rows(id(r)), ExprIterator(e.comps.begin(), _cols),
-                    ExprIterator(e.comps.end(), _cols));
-      _setRowLowerBound(_rows(id(r)),l - *e);
-      _setRowUpperBound(_rows(id(r)),u - *e);
+      _setRowCoeffs(rows(id(r)), ExprIterator(e.comps.begin(), cols),
+                    ExprIterator(e.comps.end(), cols));
+      _setRowLowerBound(rows(id(r)),l - *e);
+      _setRowUpperBound(rows(id(r)),u - *e);
     }
 
@@ -1269 +1235 @@
     Expr row(Row r) const {
       Expr e;
-      _getRowCoeffs(_rows(id(r)), InsertIterator(e.comps, _cols));
+      _getRowCoeffs(rows(id(r)), InsertIterator(e.comps, cols));
       return e;
     }
@@ -1282 +1248 @@
       Row r;
       e.simplify();
-      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), _cols),
-                                ExprIterator(e.comps.end(), _cols), u - *e));
+      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
+                                ExprIterator(e.comps.end(), cols), u - *e));
       return r;
     }
@@ -1295 +1261 @@
       c.expr().simplify();
       r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
-                                ExprIterator(c.expr().comps.begin(), _cols),
-                                ExprIterator(c.expr().comps.end(), _cols),
+                                ExprIterator(c.expr().comps.begin(), cols),
+                                ExprIterator(c.expr().comps.end(), cols),
                                 c.upperBounded()?c.upperBound()-*c.expr():INF));
       return r;
@@ -1304 +1270 @@
     ///\param c is the column to be deleted
     void erase(Col c) {
-      _eraseCol(_cols(id(c)));
-      _eraseColId(_cols(id(c)));
+      _eraseCol(cols(id(c)));
+      _eraseColId(cols(id(c)));
     }
     ///Erase a row (i.e a constraint) from the LP
@@ -1311 +1277 @@
     ///\param r is the row to be deleted
     void erase(Row r) {
-      _eraseRow(_rows(id(r)));
-      _eraseRowId(_rows(id(r)));
+      _eraseRow(rows(id(r)));
+      _eraseRowId(rows(id(r)));
     }
 
@@ -1321 +1287 @@
     std::string colName(Col c) const {
       std::string name;
-      _getColName(_cols(id(c)), name);
+      _getColName(cols(id(c)), name);
       return name;
     }
@@ -1330 +1296 @@
     ///\param name The name to be given
     void colName(Col c, const std::string& name) {
-      _setColName(_cols(id(c)), name);
+      _setColName(cols(id(c)), name);
     }
 
@@ -1339 +1305 @@
     Col colByName(const std::string& name) const {
       int k = _colByName(name);
-      return k != -1 ? Col(_cols[k]) : Col(INVALID);
+      return k != -1 ? Col(cols[k]) : Col(INVALID);
     }
 
@@ -1348 +1314 @@
     std::string rowName(Row r) const {
       std::string name;
-      _getRowName(_rows(id(r)), name);
+      _getRowName(rows(id(r)), name);
       return name;
     }
@@ -1357 +1323 @@
     ///\param name The name to be given
     void rowName(Row r, const std::string& name) {
-      _setRowName(_rows(id(r)), name);
+      _setRowName(rows(id(r)), name);
     }
 
@@ -1366 +1332 @@
     Row rowByName(const std::string& name) const {
       int k = _rowByName(name);
-      return k != -1 ? Row(_rows[k]) : Row(INVALID);
+      return k != -1 ? Row(rows[k]) : Row(INVALID);
     }
 
@@ -1375 +1341 @@
     ///\param val is the new value of the coefficient
     void coeff(Row r, Col c, Value val) {
-      _setCoeff(_rows(id(r)),_cols(id(c)), val);
+      _setCoeff(rows(id(r)),cols(id(c)), val);
     }
 
@@ -1384 +1350 @@
     ///\return the corresponding coefficient
     Value coeff(Row r, Col c) const {
-      return _getCoeff(_rows(id(r)),_cols(id(c)));
+      return _getCoeff(rows(id(r)),cols(id(c)));
     }
 
@@ -1393 +1359 @@
     /// Value or -\ref INF.
     void colLowerBound(Col c, Value value) {
-      _setColLowerBound(_cols(id(c)),value);
+      _setColLowerBound(cols(id(c)),value);
     }
 
@@ -1402 +1368 @@
     ///\return The lower bound for column \c c
     Value colLowerBound(Col c) const {
-      return _getColLowerBound(_cols(id(c)));
+      return _getColLowerBound(cols(id(c)));
     }
 
@@ -1448 +1414 @@
     /// Value or \ref INF.
     void colUpperBound(Col c, Value value) {
-      _setColUpperBound(_cols(id(c)),value);
+      _setColUpperBound(cols(id(c)),value);
     };
 
@@ -1457 +1423 @@
     /// \return The upper bound for column \c c
     Value colUpperBound(Col c) const {
-      return _getColUpperBound(_cols(id(c)));
+      return _getColUpperBound(cols(id(c)));
     }
 
@@ -1504 +1470 @@
     /// Value, -\ref INF or \ref INF.
     void colBounds(Col c, Value lower, Value upper) {
-      _setColLowerBound(_cols(id(c)),lower);
-      _setColUpperBound(_cols(id(c)),upper);
+      _setColLowerBound(cols(id(c)),lower);
+      _setColUpperBound(cols(id(c)),upper);
     }
 
@@ -1550 +1516 @@
     /// Value or -\ref INF.
     void rowLowerBound(Row r, Value value) {
-      _setRowLowerBound(_rows(id(r)),value);
+      _setRowLowerBound(rows(id(r)),value);
     }
 
@@ -1559 +1525 @@
     ///\return The lower bound for row \c r
     Value rowLowerBound(Row r) const {
-      return _getRowLowerBound(_rows(id(r)));
+      return _getRowLowerBound(rows(id(r)));
     }
 
@@ -1568 +1534 @@
     /// Value or -\ref INF.
     void rowUpperBound(Row r, Value value) {
-      _setRowUpperBound(_rows(id(r)),value);
+      _setRowUpperBound(rows(id(r)),value);
     }
 
@@ -1577 +1543 @@
     ///\return The upper bound for row \c r
     Value rowUpperBound(Row r) const {
-      return _getRowUpperBound(_rows(id(r)));
+      return _getRowUpperBound(rows(id(r)));
     }
 
     ///Set an element of the objective function
-    void objCoeff(Col c, Value v) {_setObjCoeff(_cols(id(c)),v); };
+    void objCoeff(Col c, Value v) {_setObjCoeff(cols(id(c)),v); };
 
     ///Get an element of the objective function
-    Value objCoeff(Col c) const { return _getObjCoeff(_cols(id(c))); };
+    Value objCoeff(Col c) const { return _getObjCoeff(cols(id(c))); };
 
     ///Set the objective function
@@ -1591 +1557 @@
     ///
     void obj(const Expr& e) {
-      _setObjCoeffs(ExprIterator(e.comps.begin(), _cols),
-                    ExprIterator(e.comps.end(), _cols));
+      _setObjCoeffs(ExprIterator(e.comps.begin(), cols),
+                    ExprIterator(e.comps.end(), cols));
       obj_const_comp = *e;
     }
@@ -1602 +1568 @@
     Expr obj() const {
       Expr e;
-      _getObjCoeffs(InsertIterator(e.comps, _cols));
+      _getObjCoeffs(InsertIterator(e.comps, cols));
       *e = obj_const_comp;
       return e;
@@ -1621 +1587 @@
 
     ///Clear the problem
-    void clear() { _clear(); _rows.clear(); _cols.clear(); }
+    void clear() { _clear(); rows.clear(); cols.clear(); }
 
     /// Set the message level of the solver
@@ -1964 +1930 @@
     /// Return the primal value of the column.
     /// \pre The problem is solved.
-    Value primal(Col c) const { return _getPrimal(_cols(id(c))); }
+    Value primal(Col c) const { return _getPrimal(cols(id(c))); }
 
     /// Return the primal value of the expression
@@ -1991 +1957 @@
     /// \note Some solvers does not provide primal ray calculation
     /// functions.
-    Value primalRay(Col c) const { return _getPrimalRay(_cols(id(c))); }
+    Value primalRay(Col c) const { return _getPrimalRay(cols(id(c))); }
 
     /// Return the dual value of the row
@@ -1997 +1963 @@
     /// Return the dual value of the row.
     /// \pre The problem is solved.
-    Value dual(Row r) const { return _getDual(_rows(id(r))); }
+    Value dual(Row r) const { return _getDual(rows(id(r))); }
 
     /// Return the dual value of the dual expression
@@ -2025 +1991 @@
     /// \note Some solvers does not provide dual ray calculation
     /// functions.
-    Value dualRay(Row r) const { return _getDualRay(_rows(id(r))); }
+    Value dualRay(Row r) const { return _getDualRay(rows(id(r))); }
 
     /// Return the basis status of the column
 
     /// \see VarStatus
-    VarStatus colStatus(Col c) const { return _getColStatus(_cols(id(c))); }
+    VarStatus colStatus(Col c) const { return _getColStatus(cols(id(c))); }
 
     /// Return the basis status of the row
 
     /// \see VarStatus
-    VarStatus rowStatus(Row r) const { return _getRowStatus(_rows(id(r))); }
+    VarStatus rowStatus(Row r) const { return _getRowStatus(rows(id(r))); }
 
     ///The value of the objective function
@@ -2115 +2081 @@
     ///
     void colType(Col c, ColTypes col_type) {
-      _setColType(_cols(id(c)),col_type);
+      _setColType(cols(id(c)),col_type);
     }
 
@@ -2123 +2089 @@
     ///
     ColTypes colType(Col c) const {
-      return _getColType(_cols(id(c)));
+      return _getColType(cols(id(c)));
     }
     ///@}
@@ -2140 +2106 @@
     ///  Return the value of the row in the solution.
     /// \pre The problem is solved.
-    Value sol(Col c) const { return _getSol(_cols(id(c))); }
+    Value sol(Col c) const { return _getSol(cols(id(c))); }
 
     /// Return the value of the expression in the solution

lemon/maps.h

@@ -26 +26 @@
 
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 ///\file
@@ -2583 +2582 @@
     };
 
-    /// \brief STL style iterator for the keys mapped to \c true.
-    ///
-    /// This is an STL style wrapper for \ref TrueIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper1<TrueIt, IterableBoolMap>
-    trueKeys() {
-      return LemonRangeWrapper1<TrueIt, IterableBoolMap>(*this);
-    }
-
-
     /// \brief Iterator for the keys mapped to \c false.
     ///
@@ -2631 +2620 @@
       const IterableBoolMap* _map;
     };
-
-    /// \brief STL style iterator for the keys mapped to \c false.
-    ///
-    /// This is an STL style wrapper for \ref FalseIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper1<FalseIt, IterableBoolMap>
-    falseKeys() {
-      return LemonRangeWrapper1<FalseIt, IterableBoolMap>(*this);
-    }
-
 
     /// \brief Iterator for the keys mapped to a given value.
@@ -2685 +2664 @@
       const IterableBoolMap* _map;
     };
-
-    /// \brief STL style iterator for the keys mapped to a given value.
-    ///
-    /// This is an STL style wrapper for \ref ItemIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper2<ItemIt, IterableBoolMap, bool>
-    items(bool value) {
-      return LemonRangeWrapper2<ItemIt, IterableBoolMap, bool>(*this, value);
-    }
 
   protected:
@@ -3036 +3006 @@
     };
 
-    /// \brief STL style iterator for the keys with the same value.
-    ///
-    /// This is an STL style wrapper for \ref ItemIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper2<ItemIt, IterableIntMap, int>
-    items(int value) {
-      return LemonRangeWrapper2<ItemIt, IterableIntMap, int>(*this, value);
-    }
-
-
   protected:
 
@@ -3289 +3249 @@
     };
 
-    /// \brief STL style iterator for the keys with the same value.
-    ///
-    /// This is an STL style wrapper for \ref ItemIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper2<ItemIt, IterableValueMap, V>
-    items(const V& value) {
-      return LemonRangeWrapper2<ItemIt, IterableValueMap, V>(*this, value);
-    }
-
-
   protected:
 

lemon/path.h

@@ -31 +31 @@
 #include <lemon/core.h>
 #include <lemon/concepts/path.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -141 +140 @@
       int idx;
     };
-
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, Path> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Path>(*this);
-    }
-
 
     /// \brief Length of the path.
@@ -364 +346 @@
     };
 
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, SimplePath> arcs() const {
-      return LemonRangeWrapper1<ArcIt, SimplePath>(*this);
-    }
-
-
     /// \brief Length of the path.
     int length() const { return data.size(); }
@@ -578 +543 @@
       Node *node;
     };
-
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, ListPath> arcs() const {
-      return LemonRangeWrapper1<ArcIt, ListPath>(*this);
-    }
-
 
     /// \brief The n-th arc.
@@ -848 +796 @@
     ///
     /// Default constructor
-    StaticPath() : len(0), _arcs(0) {}
+    StaticPath() : len(0), arcs(0) {}
 
     /// \brief Copy constructor
     ///
-    StaticPath(const StaticPath& cpath) : _arcs(0) {
+    StaticPath(const StaticPath& cpath) : arcs(0) {
       pathCopy(cpath, *this);
     }
@@ -860 +808 @@
     /// This path can be initialized from any other path type.
     template <typename CPath>
-    StaticPath(const CPath& cpath) : _arcs(0) {
+    StaticPath(const CPath& cpath) : arcs(0) {
       pathCopy(cpath, *this);
     }
@@ -868 +816 @@
     /// Destructor of the path
     ~StaticPath() {
-      if (_arcs) delete[] _arcs;
+      if (arcs) delete[] arcs;
     }
 
@@ -935 +883 @@
       int idx;
     };
-    
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, StaticPath> arcs() const {
-      return LemonRangeWrapper1<ArcIt, StaticPath>(*this);
-    }
-    
 
     /// \brief The n-th arc.
@@ -957 +888 @@
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
-      return _arcs[n];
+      return arcs[n];
     }
 
@@ -974 +905 @@
     void clear() {
       len = 0;
-      if (_arcs) delete[] _arcs;
-      _arcs = 0;
+      if (arcs) delete[] arcs;
+      arcs = 0;
     }
 
     /// \brief The first arc of the path.
     const Arc& front() const {
-      return _arcs[0];
+      return arcs[0];
     }
 
     /// \brief The last arc of the path.
     const Arc& back() const {
-      return _arcs[len - 1];
+      return arcs[len - 1];
     }
 
@@ -994 +925 @@
     void build(const CPath& path) {
       len = path.length();
-      _arcs = new Arc[len];
+      arcs = new Arc[len];
       int index = 0;
       for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
-        _arcs[index] = it;
+        arcs[index] = it;
         ++index;
       }
@@ -1005 +936 @@
     void buildRev(const CPath& path) {
       len = path.length();
-      _arcs = new Arc[len];
+      arcs = new Arc[len];
       int index = len;
       for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
         --index;
-        _arcs[index] = it;
+        arcs[index] = it;
       }
     }
@@ -1015 +946 @@
   private:
     int len;
-    Arc* _arcs;
+    Arc* arcs;
   };
 
@@ -1227 +1158 @@
   };
 
-  /// \brief Gets the collection of the nodes of the path.
-  ///
-  /// This function can be used for iterating on the
-  /// nodes of the path. It returns a wrapped
-  /// PathNodeIt, which looks like an STL container
-  /// (by having begin() and end()) which you can use in range-based
-  /// for loops, STL algorithms, etc.
-  /// For example you can write:
-  ///\code
-  /// for(auto u: pathNodes(g,p))
-  ///   doSomething(u);
-  ///\endcode
-  template<typename Path>
-  LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>
-      pathNodes(const typename Path::Digraph &g, const Path &p) {
-    return
-        LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>(g,p);
-  }
-
   ///@}
 

lemon/random.h

@@ -252 +252 @@
         current = state + length;
 
-        Word *curr = state + length - 1;
-        long num;
+        register Word *curr = state + length - 1;
+        register long num;
 
         num = length - shift;

lemon/smart_graph.h

@@ -48 +48 @@
     };
 
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
 
   public:
@@ -60 +60 @@
   public:
 
-    SmartDigraphBase() : _nodes(), _arcs() { }
+    SmartDigraphBase() : nodes(), arcs() { }
     SmartDigraphBase(const SmartDigraphBase &_g)
-      : _nodes(_g._nodes), _arcs(_g._arcs) { }
+      : nodes(_g.nodes), arcs(_g.arcs) { }
 
     typedef True NodeNumTag;
     typedef True ArcNumTag;
 
-    int nodeNum() const { return _nodes.size(); }
-    int arcNum() const { return _arcs.size(); }
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxArcId() const { return _arcs.size()-1; }
+    int nodeNum() const { return nodes.size(); }
+    int arcNum() const { return arcs.size(); }
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxArcId() const { return arcs.size()-1; }
 
     Node addNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_in = -1;
-      _nodes[n].first_out = -1;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_in = -1;
+      nodes[n].first_out = -1;
       return Node(n);
     }
 
     Arc addArc(Node u, Node v) {
-      int n = _arcs.size();
-      _arcs.push_back(ArcT());
-      _arcs[n].source = u._id;
-      _arcs[n].target = v._id;
-      _arcs[n].next_out = _nodes[u._id].first_out;
-      _arcs[n].next_in = _nodes[v._id].first_in;
-      _nodes[u._id].first_out = _nodes[v._id].first_in = n;
+      int n = arcs.size();
+      arcs.push_back(ArcT());
+      arcs[n].source = u._id;
+      arcs[n].target = v._id;
+      arcs[n].next_out = nodes[u._id].first_out;
+      arcs[n].next_in = nodes[v._id].first_in;
+      nodes[u._id].first_out = nodes[v._id].first_in = n;
 
       return Arc(n);
@@ -94 +94 @@
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
-    }
-
-    Node source(Arc a) const { return Node(_arcs[a._id].source); }
-    Node target(Arc a) const { return Node(_arcs[a._id].target); }
+      arcs.clear();
+      nodes.clear();
+    }
+
+    Node source(Arc a) const { return Node(arcs[a._id].source); }
+    Node target(Arc a) const { return Node(arcs[a._id].target); }
 
     static int id(Node v) { return v._id; }
@@ -108 +108 @@
 
     bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     }
     bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     }
 
@@ -146 +146 @@
 
     void first(Node& node) const {
-      node._id = _nodes.size() - 1;
+      node._id = nodes.size() - 1;
     }
 
@@ -154 +154 @@
 
     void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
+      arc._id = arcs.size() - 1;
     }
 
@@ -162 +162 @@
 
     void firstOut(Arc& arc, const Node& node) const {
-      arc._id = _nodes[node._id].first_out;
+      arc._id = nodes[node._id].first_out;
     }
 
     void nextOut(Arc& arc) const {
-      arc._id = _arcs[arc._id].next_out;
+      arc._id = arcs[arc._id].next_out;
     }
 
     void firstIn(Arc& arc, const Node& node) const {
-      arc._id = _nodes[node._id].first_in;
+      arc._id = nodes[node._id].first_in;
     }
 
     void nextIn(Arc& arc) const {
-      arc._id = _arcs[arc._id].next_in;
+      arc._id = arcs[arc._id].next_in;
     }
 
@@ -267 +267 @@
     {
       Node b = addNode();
-      _nodes[b._id].first_out=_nodes[n._id].first_out;
-      _nodes[n._id].first_out=-1;
-      for(int i=_nodes[b._id].first_out; i!=-1; i=_arcs[i].next_out) {
-        _arcs[i].source=b._id;
+      nodes[b._id].first_out=nodes[n._id].first_out;
+      nodes[n._id].first_out=-1;
+      for(int i=nodes[b._id].first_out; i!=-1; i=arcs[i].next_out) {
+        arcs[i].source=b._id;
       }
       if(connect) addArc(n,b);
@@ -292 +292 @@
     /// to build the digraph.
     /// \sa reserveArc()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for arcs.
@@ -302 +302 @@
     /// to build the digraph.
     /// \sa reserveNode()
-    void reserveArc(int m) { _arcs.reserve(m); };
+    void reserveArc(int m) { arcs.reserve(m); };
 
   public:
@@ -312 +312 @@
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<_arcs.size()) {
-        Arc arc = arcFromId(_arcs.size()-1);
+      while(s.arc_num<arcs.size()) {
+        Arc arc = arcFromId(arcs.size()-1);
         Parent::notifier(Arc()).erase(arc);
-        _nodes[_arcs.back().source].first_out=_arcs.back().next_out;
-        _nodes[_arcs.back().target].first_in=_arcs.back().next_in;
-        _arcs.pop_back();
-      }
-      while(s.node_num<_nodes.size()) {
-        Node node = nodeFromId(_nodes.size()-1);
+        nodes[arcs.back().source].first_out=arcs.back().next_out;
+        nodes[arcs.back().target].first_in=arcs.back().next_in;
+        arcs.pop_back();
+      }
+      while(s.node_num<nodes.size()) {
+        Node node = nodeFromId(nodes.size()-1);
         Parent::notifier(Node()).erase(node);
-        _nodes.pop_back();
+        nodes.pop_back();
       }
     }
@@ -363 +363 @@
       ///
       Snapshot(SmartDigraph &gr) : _graph(&gr) {
-        node_num=_graph->_nodes.size();
-        arc_num=_graph->_arcs.size();
+        node_num=_graph->nodes.size();
+        arc_num=_graph->arcs.size();
       }
 
@@ -374 +374 @@
       void save(SmartDigraph &gr) {
         _graph=&gr;
-        node_num=_graph->_nodes.size();
-        arc_num=_graph->_arcs.size();
+        node_num=_graph->nodes.size();
+        arc_num=_graph->arcs.size();
       }
 
@@ -403 +403 @@
     };
 
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
 
   public:
@@ -466 +466 @@
 
     SmartGraphBase()
-      : _nodes(), _arcs() {}
+      : nodes(), arcs() {}
 
     typedef True NodeNumTag;
@@ -472 +472 @@
     typedef True ArcNumTag;
 
-    int nodeNum() const { return _nodes.size(); }
-    int edgeNum() const { return _arcs.size() / 2; }
-    int arcNum() const { return _arcs.size(); }
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e._id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e._id].target); }
-
-    Node u(Edge e) const { return Node(_arcs[2 * e._id].target); }
-    Node v(Edge e) const { return Node(_arcs[2 * e._id + 1].target); }
+    int nodeNum() const { return nodes.size(); }
+    int edgeNum() const { return arcs.size() / 2; }
+    int arcNum() const { return arcs.size(); }
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e._id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e._id].target); }
+
+    Node u(Edge e) const { return Node(arcs[2 * e._id].target); }
+    Node v(Edge e) const { return Node(arcs[2 * e._id + 1].target); }
 
     static bool direction(Arc e) {
@@ -495 +495 @@
 
     void first(Node& node) const {
-      node._id = _nodes.size() - 1;
+      node._id = nodes.size() - 1;
     }
 
@@ -503 +503 @@
 
     void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
+      arc._id = arcs.size() - 1;
     }
 
@@ -511 +511 @@
 
     void first(Edge& arc) const {
-      arc._id = _arcs.size() / 2 - 1;
+      arc._id = arcs.size() / 2 - 1;
     }
 
@@ -519 +519 @@
 
     void firstOut(Arc &arc, const Node& v) const {
-      arc._id = _nodes[v._id].first_out;
+      arc._id = nodes[v._id].first_out;
     }
     void nextOut(Arc &arc) const {
-      arc._id = _arcs[arc._id].next_out;
+      arc._id = arcs[arc._id].next_out;
     }
 
     void firstIn(Arc &arc, const Node& v) const {
-      arc._id = ((_nodes[v._id].first_out) ^ 1);
+      arc._id = ((nodes[v._id].first_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
     void nextIn(Arc &arc) const {
-      arc._id = ((_arcs[arc._id ^ 1].next_out) ^ 1);
+      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
 
     void firstInc(Edge &arc, bool& d, const Node& v) const {
-      int de = _nodes[v._id].first_out;
+      int de = nodes[v._id].first_out;
       if (de != -1) {
         arc._id = de / 2;
@@ -545 +545 @@
     }
     void nextInc(Edge &arc, bool& d) const {
-      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
+      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
       if (de != -1) {
         arc._id = de / 2;
@@ -564 +564 @@
 
     bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     }
     bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     }
     bool valid(Edge e) const {
-      return e._id >= 0 && 2 * e._id < static_cast<int>(_arcs.size());
+      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
     }
 
     Node addNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_out = -1;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
 
       return Node(n);
@@ -582 +582 @@
 
     Edge addEdge(Node u, Node v) {
-      int n = _arcs.size();
-      _arcs.push_back(ArcT());
-      _arcs.push_back(ArcT());
-
-      _arcs[n].target = u._id;
-      _arcs[n | 1].target = v._id;
-
-      _arcs[n].next_out = _nodes[v._id].first_out;
-      _nodes[v._id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u._id].first_out;
-      _nodes[u._id].first_out = (n | 1);
+      int n = arcs.size();
+      arcs.push_back(ArcT());
+      arcs.push_back(ArcT());
+
+      arcs[n].target = u._id;
+      arcs[n | 1].target = v._id;
+
+      arcs[n].next_out = nodes[v._id].first_out;
+      nodes[v._id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u._id].first_out;
+      nodes[u._id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -599 +599 @@
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
     }
 
@@ -702 +702 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -712 +712 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
   public:
@@ -723 +723 @@
     {
       s._graph = this;
-      s.node_num = _nodes.size();
-      s.arc_num = _arcs.size();
+      s.node_num = nodes.size();
+      s.arc_num = arcs.size();
     }
 
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<_arcs.size()) {
-        int n=_arcs.size()-1;
+      while(s.arc_num<arcs.size()) {
+        int n=arcs.size()-1;
         Edge arc=edgeFromId(n/2);
         Parent::notifier(Edge()).erase(arc);
@@ -737 +737 @@
         dir.push_back(arcFromId(n-1));
         Parent::notifier(Arc()).erase(dir);
-        _nodes[_arcs[n-1].target].first_out=_arcs[n].next_out;
-        _nodes[_arcs[n].target].first_out=_arcs[n-1].next_out;
-        _arcs.pop_back();
-        _arcs.pop_back();
-      }
-      while(s.node_num<_nodes.size()) {
-        int n=_nodes.size()-1;
+        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
+        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
+        arcs.pop_back();
+        arcs.pop_back();
+      }
+      while(s.node_num<nodes.size()) {
+        int n=nodes.size()-1;
         Node node = nodeFromId(n);
         Parent::notifier(Node()).erase(node);
-        _nodes.pop_back();
+        nodes.pop_back();
       }
     }
@@ -826 +826 @@
     };
 
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
 
     int first_red, first_blue;
@@ -916 +916 @@
 
     SmartBpGraphBase()
-      : _nodes(), _arcs(), first_red(-1), first_blue(-1),
+      : nodes(), arcs(), first_red(-1), first_blue(-1),
         max_red(-1), max_blue(-1) {}
 
@@ -923 +923 @@
     typedef True ArcNumTag;
 
-    int nodeNum() const { return _nodes.size(); }
+    int nodeNum() const { return nodes.size(); }
     int redNum() const { return max_red + 1; }
     int blueNum() const { return max_blue + 1; }
-    int edgeNum() const { return _arcs.size() / 2; }
-    int arcNum() const { return _arcs.size(); }
-
-    int maxNodeId() const { return _nodes.size()-1; }
+    int edgeNum() const { return arcs.size() / 2; }
+    int arcNum() const { return arcs.size(); }
+
+    int maxNodeId() const { return nodes.size()-1; }
     int maxRedId() const { return max_red; }
     int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    bool red(Node n) const { return _nodes[n._id].red; }
-    bool blue(Node n) const { return !_nodes[n._id].red; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    bool red(Node n) const { return nodes[n._id].red; }
+    bool blue(Node n) const { return !nodes[n._id].red; }
 
     static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
     static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
 
-    Node source(Arc a) const { return Node(_arcs[a._id ^ 1].target); }
-    Node target(Arc a) const { return Node(_arcs[a._id].target); }
+    Node source(Arc a) const { return Node(arcs[a._id ^ 1].target); }
+    Node target(Arc a) const { return Node(arcs[a._id].target); }
 
     RedNode redNode(Edge e) const {
-      return RedNode(_arcs[2 * e._id].target);
+      return RedNode(arcs[2 * e._id].target);
     }
     BlueNode blueNode(Edge e) const {
-      return BlueNode(_arcs[2 * e._id + 1].target);
+      return BlueNode(arcs[2 * e._id + 1].target);
     }
 
@@ -960 +960 @@
 
     void first(Node& node) const {
-      node._id = _nodes.size() - 1;
+      node._id = nodes.size() - 1;
     }
 
@@ -972 +972 @@
 
     void next(RedNode& node) const {
-      node._id = _nodes[node._id].partition_next;
+      node._id = nodes[node._id].partition_next;
     }
 
@@ -980 +980 @@
 
     void next(BlueNode& node) const {
-      node._id = _nodes[node._id].partition_next;
+      node._id = nodes[node._id].partition_next;
     }
 
     void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
+      arc._id = arcs.size() - 1;
     }
 
@@ -992 +992 @@
 
     void first(Edge& arc) const {
-      arc._id = _arcs.size() / 2 - 1;
+      arc._id = arcs.size() / 2 - 1;
     }
 
@@ -1000 +1000 @@
 
     void firstOut(Arc &arc, const Node& v) const {
-      arc._id = _nodes[v._id].first_out;
+      arc._id = nodes[v._id].first_out;
     }
     void nextOut(Arc &arc) const {
-      arc._id = _arcs[arc._id].next_out;
+      arc._id = arcs[arc._id].next_out;
     }
 
     void firstIn(Arc &arc, const Node& v) const {
-      arc._id = ((_nodes[v._id].first_out) ^ 1);
+      arc._id = ((nodes[v._id].first_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
     void nextIn(Arc &arc) const {
-      arc._id = ((_arcs[arc._id ^ 1].next_out) ^ 1);
+      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
 
     void firstInc(Edge &arc, bool& d, const Node& v) const {
-      int de = _nodes[v._id].first_out;
+      int de = nodes[v._id].first_out;
       if (de != -1) {
         arc._id = de / 2;
@@ -1026 +1026 @@
     }
     void nextInc(Edge &arc, bool& d) const {
-      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
+      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
       if (de != -1) {
         arc._id = de / 2;
@@ -1037 +1037 @@
 
     static int id(Node v) { return v._id; }
-    int id(RedNode v) const { return _nodes[v._id].partition_index; }
-    int id(BlueNode v) const { return _nodes[v._id].partition_index; }
+    int id(RedNode v) const { return nodes[v._id].partition_index; }
+    int id(BlueNode v) const { return nodes[v._id].partition_index; }
     static int id(Arc e) { return e._id; }
     static int id(Edge e) { return e._id; }
@@ -1047 +1047 @@
 
     bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     }
     bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     }
     bool valid(Edge e) const {
-      return e._id >= 0 && 2 * e._id < static_cast<int>(_arcs.size());
+      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
     }
 
     RedNode addRedNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_out = -1;
-      _nodes[n].red = true;
-      _nodes[n].partition_index = ++max_red;
-      _nodes[n].partition_next = first_red;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
+      nodes[n].red = true;
+      nodes[n].partition_index = ++max_red;
+      nodes[n].partition_next = first_red;
       first_red = n;
 
@@ -1069 +1069 @@
 
     BlueNode addBlueNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_out = -1;
-      _nodes[n].red = false;
-      _nodes[n].partition_index = ++max_blue;
-      _nodes[n].partition_next = first_blue;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
+      nodes[n].red = false;
+      nodes[n].partition_index = ++max_blue;
+      nodes[n].partition_next = first_blue;
       first_blue = n;
 
@@ -1081 +1081 @@
 
     Edge addEdge(RedNode u, BlueNode v) {
-      int n = _arcs.size();
-      _arcs.push_back(ArcT());
-      _arcs.push_back(ArcT());
-
-      _arcs[n].target = u._id;
-      _arcs[n | 1].target = v._id;
-
-      _arcs[n].next_out = _nodes[v._id].first_out;
-      _nodes[v._id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u._id].first_out;
-      _nodes[u._id].first_out = (n | 1);
+      int n = arcs.size();
+      arcs.push_back(ArcT());
+      arcs.push_back(ArcT());
+
+      arcs[n].target = u._id;
+      arcs[n | 1].target = v._id;
+
+      arcs[n].next_out = nodes[v._id].first_out;
+      nodes[v._id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u._id].first_out;
+      nodes[u._id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -1098 +1098 @@
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_red = -1;
       first_blue = -1;
@@ -1214 +1214 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -1224 +1224 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
   public:
@@ -1235 +1235 @@
     {
       s._graph = this;
-      s.node_num = _nodes.size();
-      s.arc_num = _arcs.size();
+      s.node_num = nodes.size();
+      s.arc_num = arcs.size();
     }
 
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<_arcs.size()) {
-        int n=_arcs.size()-1;
+      while(s.arc_num<arcs.size()) {
+        int n=arcs.size()-1;
         Edge arc=edgeFromId(n/2);
         Parent::notifier(Edge()).erase(arc);
@@ -1249 +1249 @@
         dir.push_back(arcFromId(n-1));
         Parent::notifier(Arc()).erase(dir);
-        _nodes[_arcs[n-1].target].first_out=_arcs[n].next_out;
-        _nodes[_arcs[n].target].first_out=_arcs[n-1].next_out;
-        _arcs.pop_back();
-        _arcs.pop_back();
-      }
-      while(s.node_num<_nodes.size()) {
-        int n=_nodes.size()-1;
+        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
+        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
+        arcs.pop_back();
+        arcs.pop_back();
+      }
+      while(s.node_num<nodes.size()) {
+        int n=nodes.size()-1;
         Node node = nodeFromId(n);
         if (Parent::red(node)) {
-          first_red = _nodes[n].partition_next;
+          first_red = nodes[n].partition_next;
           if (first_red != -1) {
-            max_red = _nodes[first_red].partition_index;
+            max_red = nodes[first_red].partition_index;
           } else {
             max_red = -1;
@@ -1266 +1266 @@
           Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));
         } else {
-          first_blue = _nodes[n].partition_next;
+          first_blue = nodes[n].partition_next;
           if (first_blue != -1) {
-            max_blue = _nodes[first_blue].partition_index;
+            max_blue = nodes[first_blue].partition_index;
           } else {
             max_blue = -1;
@@ -1275 +1275 @@
         }
         Parent::notifier(Node()).erase(node);
-        _nodes.pop_back();
+        nodes.pop_back();
       }
     }

lemon/soplex.cc

@@ -38 +38 @@
 
   SoplexLp::SoplexLp(const SoplexLp& lp) {
-    _rows = lp._rows;
-    _cols = lp._cols;
+    rows = lp.rows;
+    cols = lp.cols;
 
     soplex = new soplex::SoPlex;
@@ -123 +123 @@
 
   void SoplexLp::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.relocateIndex(i, _cols.maxIndex());
+    cols.eraseIndex(i);
+    cols.relocateIndex(i, cols.maxIndex());
   }
   void SoplexLp::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.relocateIndex(i, _rows.maxIndex());
+    rows.eraseIndex(i);
+    rows.relocateIndex(i, rows.maxIndex());
   }
 
@@ -433 +433 @@
     _row_names.clear();
     _row_names_ref.clear();
-    _cols.clear();
-    _rows.clear();
+    cols.clear();
+    rows.clear();
     _clear_temporals();
   }

test/CMakeLists.txt

@@ -55 +55 @@
   tsp_test
   unionfind_test
-  vf2_test
 )
 

test/bellman_ford_test.cc

@@ -102 +102 @@
 
     for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
-    for (auto n: const_bf_test.activeNodes()) { ::lemon::ignore_unused_variable_warning(n); }
-    for (Digraph::Node n: const_bf_test.activeNodes()) {
-      ::lemon::ignore_unused_variable_warning(n);
-    }
   }
   {

test/graph_test.h

@@ -39 +39 @@
     check(n==INVALID,"Wrong Node list linking.");
     check(countNodes(G)==cnt,"Wrong Node number.");
-
-#ifdef LEMON_CXX11
-    {
-      typename Graph::NodeIt n(G);
-      for(auto u: G.nodes())
-        {
-          check(n==u,"Wrong STL Node iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL Node iterator.");
-    }
-    {
-      typename Graph::NodeIt n(G);
-      for(typename Graph::Node u: G.nodes())
-        {
-          check(n==u,"Wrong STL Node iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL Node iterator.");
-    }
-#endif
   }
 
@@ -78 +57 @@
     check(n==INVALID,"Wrong red Node list linking.");
     check(countRedNodes(G)==cnt,"Wrong red Node number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::RedNodeIt n(G);
-      for(auto u: G.redNodes())
-        {
-          check(n==u,"Wrong STL RedNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL RedNode iterator.");
-    }
-    {
-      typename Graph::RedNodeIt n(G);
-      for(typename Graph::RedNode u: G.redNodes())
-        {
-          check(n==u,"Wrong STL RedNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL RedNode iterator.");
-    }
-#endif
   }
 
@@ -116 +75 @@
     check(n==INVALID,"Wrong blue Node list linking.");
     check(countBlueNodes(G)==cnt,"Wrong blue Node number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::BlueNodeIt n(G);
-      for(auto u: G.blueNodes())
-        {
-          check(n==u,"Wrong STL BlueNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL BlueNode iterator.");
-    }
-    {
-      typename Graph::BlueNodeIt n(G);
-      for(typename Graph::BlueNode u: G.blueNodes())
-        {
-          check(n==u,"Wrong STL BlueNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL BlueNode iterator.");
-    }
-#endif
-
   }
 
@@ -153 +91 @@
     check(e==INVALID,"Wrong Arc list linking.");
     check(countArcs(G)==cnt,"Wrong Arc number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::ArcIt a(G);
-      for(auto e: G.arcs())
-        {
-          check(a==e,"Wrong STL Arc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Arc iterator.");
-    }
-    {
-      typename Graph::ArcIt a(G);
-      for(typename Graph::Arc e: G.arcs())
-        {
-          check(a==e,"Wrong STL Arc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Arc iterator.");
-    }
-#endif
-
   }
 
@@ -189 +106 @@
     check(e==INVALID,"Wrong OutArc list linking.");
     check(countOutArcs(G,n)==cnt,"Wrong OutArc number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::OutArcIt a(G,n);
-      for(auto e: G.outArcs(n))
-        {
-          check(a==e,"Wrong STL OutArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL OutArc iterator.");
-    }
-    {
-      typename Graph::OutArcIt a(G,n);
-      for(typename Graph::Arc e: G.outArcs(n))
-        {
-          check(a==e,"Wrong STL OutArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL OutArc iterator.");
-    }
-#endif
-
   }
 
@@ -225 +121 @@
     check(e==INVALID,"Wrong InArc list linking.");
     check(countInArcs(G,n)==cnt,"Wrong InArc number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::InArcIt a(G,n);
-      for(auto e: G.inArcs(n))
-        {
-          check(a==e,"Wrong STL InArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL InArc iterator.");
-    }
-    {
-      typename Graph::InArcIt a(G,n);
-      for(typename Graph::Arc e: G.inArcs(n))
-        {
-          check(a==e,"Wrong STL InArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL InArc iterator.");
-    }
-#endif
   }
 
@@ -259 +135 @@
     check(e==INVALID,"Wrong Edge list linking.");
     check(countEdges(G)==cnt,"Wrong Edge number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::EdgeIt a(G);
-      for(auto e: G.edges())
-        {
-          check(a==e,"Wrong STL Edge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Edge iterator.");
-    }
-    {
-      typename Graph::EdgeIt a(G);
-      for(typename Graph::Edge e: G.edges())
-        {
-          check(a==e,"Wrong STL Edge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Edge iterator.");
-    }
-#endif
-
   }
 
@@ -296 +151 @@
     check(e==INVALID,"Wrong IncEdge list linking.");
     check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::IncEdgeIt a(G,n);
-      for(auto e: G.incEdges(n))
-        {
-          check(a==e,"Wrong STL IncEdge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL IncEdge iterator.");
-    }
-    {
-      typename Graph::IncEdgeIt a(G,n);
-      for(typename Graph::Edge e: G.incEdges(n))
-        {
-          check(a==e,"Wrong STL IncEdge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL IncEdge iterator.");
-    }
-#endif
-
   }
 

test/lp_test.cc

@@ -21 +21 @@
 #include "test_tools.h"
 #include <lemon/tolerance.h>
-#include <lemon/concept_check.h>
+
 #include <lemon/config.h>
 
@@ -48 +48 @@
   int count=0;
   for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
-#ifdef LEMON_CXX11
-  int cnt = 0;
-  for(auto c: lp.cols()) { cnt++; ::lemon::ignore_unused_variable_warning(c); }
-  check(count == cnt, "Wrong STL iterator");
-#endif
   return count;
 }
@@ -59 +54 @@
   int count=0;
   for (LpBase::RowIt r(lp); r!=INVALID; ++r) ++count;
-#ifdef LEMON_CXX11
-  int cnt = 0;
-  for(auto r: lp.rows()) { cnt++; ::lemon::ignore_unused_variable_warning(r); }
-  check(count == cnt, "Wrong STL iterator");
-#endif
   return count;
 }

test/maps_test.cc

@@ -731 +731 @@
     check(n == 3, "Wrong number");
     check(map1.falseNum() == 3, "Wrong number");
-
-#ifdef LEMON_CXX11
-    {
-      int c = 0;
-      for(auto v: map1.items(false)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.falseNum(), "Wrong number");
-    }
-    {
-      int c = 0;
-      for(auto v: map1.items(true)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.trueNum(), "Wrong number");
-    }
-    {
-      int c = 0;
-      for(auto v: map1.falseKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.falseNum(), "Wrong number");
-    }
-    {
-      int c = 0;
-      for(auto v: map1.trueKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.trueNum(), "Wrong number");
-    }
-#endif
-
   }
 
@@ -805 +781 @@
     }
     check(n == num, "Wrong number");
-#ifdef LEMON_CXX11
-    {
-      int c = 0;
-      for(auto v: map1.items(0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == (num + 1) / 2, "Wrong number");
-      for(auto v: map1.items(1)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == num, "Wrong number");
-    }
-#endif
 
   }
@@ -872 +839 @@
     }
     check(n == num, "Wrong number");
-
-#ifdef LEMON_CXX11
-    {
-      int c = 0;
-      for(auto v: map1.items(0.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == (num + 1) / 2, "Wrong number");
-      for(auto v: map1.items(1.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == num, "Wrong number");
-    }
-#endif
 
   }