COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search


Ignore:
Files:
4 added
39 edited

Legend:

Unmodified
Added
Removed

  • CMakeLists.txt

    r565 r574  
    4040ADD_SUBDIRECTORY(lemon)
    4141ADD_SUBDIRECTORY(demo)
     42ADD_SUBDIRECTORY(tools)
    4243ADD_SUBDIRECTORY(doc)
    4344ADD_SUBDIRECTORY(test)
    … …  
    5758    "${PROJECT_NAME} ${PROJECT_VERSION}")
    5859
    59   SET(CPACK_COMPONENTS_ALL headers library html_documentation)
     60  SET(CPACK_COMPONENTS_ALL headers library html_documentation bin)
    6061
    6162  SET(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ headers")
    6263  SET(CPACK_COMPONENT_LIBRARY_DISPLAY_NAME "Dynamic-link library")
     64  SET(CPACK_COMPONENT_BIN_DISPLAY_NAME "Command line utilities")
    6365  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DISPLAY_NAME "HTML documentation")
    6466
    … …  
    6769  SET(CPACK_COMPONENT_LIBRARY_DESCRIPTION
    6870    "DLL and import library")
     71  SET(CPACK_COMPONENT_BIN_DESCRIPTION
     72    "Command line utilities")
    6973  SET(CPACK_COMPONENT_HTML_DOCUMENTATION_DESCRIPTION
    7074    "Doxygen generated documentation")

  • INSTALL

    r318 r526  
    55tarballs and successfully extracted it. The latest version of LEMON is
    66available at our web page (http://lemon.cs.elte.hu/).
     7
     8LEMON provides two different build environments, one is based on "autotool",
     9while the other is based on "cmake". This file contains instructions only for
     10the former one, which is the recommended build environment on Linux, Mac OSX
     11and other unices or if you use Cygwin on Windows. For cmake installation
     12instructions visit http://lemon.cs.elte.hu.
    713
    814In order to install LEMON from the extracted source tarball you have to

  • lemon/Makefile.am

    r569 r575  
    8484        lemon/math.h \
    8585        lemon/max_matching.h \
     86        lemon/min_cost_arborescence.h \
    8687        lemon/nauty_reader.h \
    8788        lemon/path.h \

  • lemon/bfs.h

    r463 r525  
    5050    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5151    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    52     ///Instantiates a PredMap.
    53 
    54     ///This function instantiates a PredMap.
     52    ///Instantiates a \c PredMap.
     53
     54    ///This function instantiates a \ref PredMap.
    5555    ///\param g is the digraph, to which we would like to define the
    56     ///PredMap.
     56    ///\ref PredMap.
    5757    static PredMap *createPredMap(const Digraph &g)
    5858    {
    … …  
    6565    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6666    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    67     ///Instantiates a ProcessedMap.
    68 
    69     ///This function instantiates a ProcessedMap.
     67    ///Instantiates a \c ProcessedMap.
     68
     69    ///This function instantiates a \ref ProcessedMap.
    7070    ///\param g is the digraph, to which
    71     ///we would like to define the ProcessedMap
     71    ///we would like to define the \ref ProcessedMap
    7272#ifdef DOXYGEN
    7373    static ProcessedMap *createProcessedMap(const Digraph &g)
    … …  
    8484    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8585    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    86     ///Instantiates a ReachedMap.
    87 
    88     ///This function instantiates a ReachedMap.
     86    ///Instantiates a \c ReachedMap.
     87
     88    ///This function instantiates a \ref ReachedMap.
    8989    ///\param g is the digraph, to which
    90     ///we would like to define the ReachedMap.
     90    ///we would like to define the \ref ReachedMap.
    9191    static ReachedMap *createReachedMap(const Digraph &g)
    9292    {
    … …  
    9999    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    100100    typedef typename Digraph::template NodeMap<int> DistMap;
    101     ///Instantiates a DistMap.
    102 
    103     ///This function instantiates a DistMap.
     101    ///Instantiates a \c DistMap.
     102
     103    ///This function instantiates a \ref DistMap.
    104104    ///\param g is the digraph, to which we would like to define the
    105     ///DistMap.
     105    ///\ref DistMap.
    106106    static DistMap *createDistMap(const Digraph &g)
    107107    {
    … …  
    222222    };
    223223    ///\brief \ref named-templ-param "Named parameter" for setting
    224     ///PredMap type.
     224    ///\c PredMap type.
    225225    ///
    226226    ///\ref named-templ-param "Named parameter" for setting
    227     ///PredMap type.
     227    ///\c PredMap type.
    228228    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    229229    template <class T>
    … …  
    242242    };
    243243    ///\brief \ref named-templ-param "Named parameter" for setting
    244     ///DistMap type.
     244    ///\c DistMap type.
    245245    ///
    246246    ///\ref named-templ-param "Named parameter" for setting
    247     ///DistMap type.
     247    ///\c DistMap type.
    248248    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    249249    template <class T>
    … …  
    262262    };
    263263    ///\brief \ref named-templ-param "Named parameter" for setting
    264     ///ReachedMap type.
     264    ///\c ReachedMap type.
    265265    ///
    266266    ///\ref named-templ-param "Named parameter" for setting
    267     ///ReachedMap type.
     267    ///\c ReachedMap type.
    268268    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    269269    template <class T>
    … …  
    282282    };
    283283    ///\brief \ref named-templ-param "Named parameter" for setting
    284     ///ProcessedMap type.
     284    ///\c ProcessedMap type.
    285285    ///
    286286    ///\ref named-templ-param "Named parameter" for setting
    287     ///ProcessedMap type.
     287    ///\c ProcessedMap type.
    288288    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    289289    template <class T>
    … …  
    301301    };
    302302    ///\brief \ref named-templ-param "Named parameter" for setting
    303     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     303    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    304304    ///
    305305    ///\ref named-templ-param "Named parameter" for setting
    306     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     306    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    307307    ///If you don't set it explicitly, it will be automatically allocated.
    308308    struct SetStandardProcessedMap :
    … …  
    11951195  /// This class defines the interface of the BfsVisit events, and
    11961196  /// it could be the base of a real visitor class.
    1197   template <typename _Digraph>
     1197  template <typename GR>
    11981198  struct BfsVisitor {
    1199     typedef _Digraph Digraph;
     1199    typedef GR Digraph;
    12001200    typedef typename Digraph::Arc Arc;
    12011201    typedef typename Digraph::Node Node;
    … …  
    12251225  };
    12261226#else
    1227   template <typename _Digraph>
     1227  template <typename GR>
    12281228  struct BfsVisitor {
    1229     typedef _Digraph Digraph;
     1229    typedef GR Digraph;
    12301230    typedef typename Digraph::Arc Arc;
    12311231    typedef typename Digraph::Node Node;
    … …  
    12551255  ///
    12561256  /// Default traits class of BfsVisit class.
    1257   /// \tparam _Digraph The type of the digraph the algorithm runs on.
    1258   template<class _Digraph>
     1257  /// \tparam GR The type of the digraph the algorithm runs on.
     1258  template<class GR>
    12591259  struct BfsVisitDefaultTraits {
    12601260
    12611261    /// \brief The type of the digraph the algorithm runs on.
    1262     typedef _Digraph Digraph;
     1262    typedef GR Digraph;
    12631263
    12641264    /// \brief The type of the map that indicates which nodes are reached.
    … …  
    12811281  /// \ingroup search
    12821282  ///
    1283   /// \brief %BFS algorithm class with visitor interface.
     1283  /// \brief BFS algorithm class with visitor interface.
    12841284  ///
    1285   /// This class provides an efficient implementation of the %BFS algorithm
     1285  /// This class provides an efficient implementation of the BFS algorithm
    12861286  /// with visitor interface.
    12871287  ///
    1288   /// The %BfsVisit class provides an alternative interface to the Bfs
     1288  /// The BfsVisit class provides an alternative interface to the Bfs
    12891289  /// class. It works with callback mechanism, the BfsVisit object calls
    12901290  /// the member functions of the \c Visitor class on every BFS event.
    … …  
    12951295  /// instead.
    12961296  ///
    1297   /// \tparam _Digraph The type of the digraph the algorithm runs on.
    1298   /// The default value is
    1299   /// \ref ListDigraph. The value of _Digraph is not used directly by
    1300   /// \ref BfsVisit, it is only passed to \ref BfsVisitDefaultTraits.
    1301   /// \tparam _Visitor The Visitor type that is used by the algorithm.
    1302   /// \ref BfsVisitor "BfsVisitor<_Digraph>" is an empty visitor, which
     1297  /// \tparam GR The type of the digraph the algorithm runs on.
     1298  /// The default type is \ref ListDigraph.
     1299  /// The value of GR is not used directly by \ref BfsVisit,
     1300  /// it is only passed to \ref BfsVisitDefaultTraits.
     1301  /// \tparam VS The Visitor type that is used by the algorithm.
     1302  /// \ref BfsVisitor "BfsVisitor<GR>" is an empty visitor, which
    13031303  /// does not observe the BFS events. If you want to observe the BFS
    13041304  /// events, you should implement your own visitor class.
    1305   /// \tparam _Traits Traits class to set various data types used by the
     1305  /// \tparam TR Traits class to set various data types used by the
    13061306  /// algorithm. The default traits class is
    1307   /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<_Digraph>".
     1307  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
    13081308  /// See \ref BfsVisitDefaultTraits for the documentation of
    13091309  /// a BFS visit traits class.
    13101310#ifdef DOXYGEN
    1311   template <typename _Digraph, typename _Visitor, typename _Traits>
     1311  template <typename GR, typename VS, typename TR>
    13121312#else
    1313   template <typename _Digraph = ListDigraph,
    1314             typename _Visitor = BfsVisitor<_Digraph>,
    1315             typename _Traits = BfsVisitDefaultTraits<_Digraph> >
     1313  template <typename GR = ListDigraph,
     1314            typename VS = BfsVisitor<GR>,
     1315            typename TR = BfsVisitDefaultTraits<GR> >
    13161316#endif
    13171317  class BfsVisit {
    … …  
    13191319
    13201320    ///The traits class.
    1321     typedef _Traits Traits;
     1321    typedef TR Traits;
    13221322
    13231323    ///The type of the digraph the algorithm runs on.
    … …  
    13251325
    13261326    ///The visitor type used by the algorithm.
    1327     typedef _Visitor Visitor;
     1327    typedef VS Visitor;
    13281328
    13291329    ///The type of the map that indicates which nodes are reached.

  • lemon/bits/array_map.h

    r463 r525  
    136136    // \brief Template assign operator.
    137137    //
    138     // The given parameter should be conform to the ReadMap
     138    // The given parameter should conform to the ReadMap
    139139    // concecpt and could be indiced by the current item set of
    140140    // the NodeMap. In this case the value for each item

  • lemon/bits/default_map.h

    r564 r582  
    2020#define LEMON_BITS_DEFAULT_MAP_H
    2121
     22#include <lemon/config.h>
    2223#include <lemon/bits/array_map.h>
    2324#include <lemon/bits/vector_map.h>

  • lemon/bits/path_dump.h

    r566 r576  
    1717 */
    1818
    19 #ifndef LEMON_BITS_PRED_MAP_PATH_H
    20 #define LEMON_BITS_PRED_MAP_PATH_H
     19#ifndef LEMON_BITS_PATH_DUMP_H
     20#define LEMON_BITS_PATH_DUMP_H
    2121
    2222#include <lemon/core.h>

  • lemon/bits/vector_map.h

    r463 r525  
    125125    // \brief Template assign operator.
    126126    //
    127     // The given parameter should be conform to the ReadMap
     127    // The given parameter should conform to the ReadMap
    128128    // concecpt and could be indiced by the current item set of
    129129    // the NodeMap. In this case the value for each item

  • lemon/bits/windows.h

    r511 r576  
    1717 */
    1818
    19 #ifndef LEMON_WINDOWS_H
    20 #define LEMON_WINDOWS_H
     19#ifndef LEMON_BITS_WINDOWS_H
     20#define LEMON_BITS_WINDOWS_H
    2121
    2222#include <string>

  • lemon/circulation.h

    r463 r525  
    3232  ///
    3333  /// Default traits class of Circulation class.
    34   /// \tparam _Diraph Digraph type.
    35   /// \tparam _LCapMap Lower bound capacity map type.
    36   /// \tparam _UCapMap Upper bound capacity map type.
    37   /// \tparam _DeltaMap Delta map type.
    38   template <typename _Diraph, typename _LCapMap,
    39             typename _UCapMap, typename _DeltaMap>
     34  /// \tparam GR Digraph type.
     35  /// \tparam LM Lower bound capacity map type.
     36  /// \tparam UM Upper bound capacity map type.
     37  /// \tparam DM Delta map type.
     38  template <typename GR, typename LM,
     39            typename UM, typename DM>
    4040  struct CirculationDefaultTraits {
    4141
    4242    /// \brief The type of the digraph the algorithm runs on.
    43     typedef _Diraph Digraph;
     43    typedef GR Digraph;
    4444
    4545    /// \brief The type of the map that stores the circulation lower
    … …  
    4848    /// The type of the map that stores the circulation lower bound.
    4949    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    50     typedef _LCapMap LCapMap;
     50    typedef LM LCapMap;
    5151
    5252    /// \brief The type of the map that stores the circulation upper
    … …  
    5555    /// The type of the map that stores the circulation upper bound.
    5656    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    57     typedef _UCapMap UCapMap;
     57    typedef UM UCapMap;
    5858
    5959    /// \brief The type of the map that stores the lower bound for
    … …  
    6363    /// of the nodes. It must meet the \ref concepts::ReadMap "ReadMap"
    6464    /// concept.
    65     typedef _DeltaMap DeltaMap;
     65    typedef DM DeltaMap;
    6666
    6767    /// \brief The type of the flow values.
    … …  
    138138     in this way.
    139139
    140      \tparam _Digraph The type of the digraph the algorithm runs on.
    141      \tparam _LCapMap The type of the lower bound capacity map. The default
    142      map type is \ref concepts::Digraph::ArcMap "_Digraph::ArcMap<int>".
    143      \tparam _UCapMap The type of the upper bound capacity map. The default
    144      map type is \c _LCapMap.
    145      \tparam _DeltaMap The type of the map that stores the lower bound
     140     \tparam GR The type of the digraph the algorithm runs on.
     141     \tparam LM The type of the lower bound capacity map. The default
     142     map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
     143     \tparam UM The type of the upper bound capacity map. The default
     144     map type is \c LM.
     145     \tparam DM The type of the map that stores the lower bound
    146146     for the supply of the nodes. The default map type is
    147      \c _Digraph::ArcMap<_UCapMap::Value>.
     147     \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>".
    148148  */
    149149#ifdef DOXYGEN
    150 template< typename _Digraph,
    151           typename _LCapMap,
    152           typename _UCapMap,
    153           typename _DeltaMap,
    154           typename _Traits >
     150template< typename GR,
     151          typename LM,
     152          typename UM,
     153          typename DM,
     154          typename TR >
    155155#else
    156 template< typename _Digraph,
    157           typename _LCapMap = typename _Digraph::template ArcMap<int>,
    158           typename _UCapMap = _LCapMap,
    159           typename _DeltaMap = typename _Digraph::
    160                                template NodeMap<typename _UCapMap::Value>,
    161           typename _Traits=CirculationDefaultTraits<_Digraph, _LCapMap,
    162                                                     _UCapMap, _DeltaMap> >
     156template< typename GR,
     157          typename LM = typename GR::template ArcMap<int>,
     158          typename UM = LM,
     159          typename DM = typename GR::template NodeMap<typename UM::Value>,
     160          typename TR = CirculationDefaultTraits<GR, LM, UM, DM> >
    163161#endif
    164162  class Circulation {
    … …  
    166164
    167165    ///The \ref CirculationDefaultTraits "traits class" of the algorithm.
    168     typedef _Traits Traits;
     166    typedef TR Traits;
    169167    ///The type of the digraph the algorithm runs on.
    170168    typedef typename Traits::Digraph Digraph;

  • lemon/clp.cc

    r485 r587  
    5757  }
    5858
    59   ClpLp* ClpLp::_newSolver() const {
     59  ClpLp* ClpLp::newSolver() const {
    6060    ClpLp* newlp = new ClpLp;
    6161    return newlp;
    6262  }
    6363
    64   ClpLp* ClpLp::_cloneSolver() const {
     64  ClpLp* ClpLp::cloneSolver() const {
    6565    ClpLp* copylp = new ClpLp(*this);
    6666    return copylp;

  • lemon/clp.h

    r485 r587  
    5757    ~ClpLp();
    5858
     59    /// \e
     60    virtual ClpLp* newSolver() const;
     61    /// \e
     62    virtual ClpLp* cloneSolver() const;
     63
    5964  protected:
    6065
    … …  
    6671
    6772  protected:
    68 
    69     virtual ClpLp* _newSolver() const;
    70     virtual ClpLp* _cloneSolver() const;
    7173
    7274    virtual const char* _solverName() const;

  • lemon/concepts/digraph.h

    r463 r576  
    1717 */
    1818
    19 #ifndef LEMON_CONCEPT_DIGRAPH_H
    20 #define LEMON_CONCEPT_DIGRAPH_H
     19#ifndef LEMON_CONCEPTS_DIGRAPH_H
     20#define LEMON_CONCEPTS_DIGRAPH_H
    2121
    2222///\ingroup graph_concepts
    … …  
    485485
    486486
    487 #endif // LEMON_CONCEPT_DIGRAPH_H
     487#endif

  • lemon/concepts/graph.h

    r463 r576  
    2121///\brief The concept of Undirected Graphs.
    2222
    23 #ifndef LEMON_CONCEPT_GRAPH_H
    24 #define LEMON_CONCEPT_GRAPH_H
     23#ifndef LEMON_CONCEPTS_GRAPH_H
     24#define LEMON_CONCEPTS_GRAPH_H
    2525
    2626#include <lemon/concepts/graph_components.h>
    27 #include <lemon/concepts/graph.h>
    2827#include <lemon/core.h>
    2928

  • lemon/concepts/graph_components.h

    r463 r581  
    2222
    2323
    24 #ifndef LEMON_CONCEPT_GRAPH_COMPONENTS_H
    25 #define LEMON_CONCEPT_GRAPH_COMPONENTS_H
     24#ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
     25#define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
    2626
    2727#include <lemon/core.h>
    … …  
    115115    ///
    116116    /// This class provides the minimal set of features needed for a
    117     /// directed graph structure. All digraph concepts have to be
     117    /// directed graph structure. All digraph concepts have to
    118118    /// conform to this base directed graph. It just provides types
    119119    /// for nodes and arcs and functions to get the source and the
    … …  
    180180    /// This class provides the minimal set of features needed for an
    181181    /// undirected graph structure. All undirected graph concepts have
    182     /// to be conform to this base graph. It just provides types for
     182    /// to conform to this base graph. It just provides types for
    183183    /// nodes, arcs and edges and functions to get the
    184184    /// source and the target of the arcs and edges,
    … …  
    295295    /// This class provides beside the core digraph features
    296296    /// core id functions for the digraph structure.
    297     /// The most of the base digraphs should be conform to this concept.
     297    /// The most of the base digraphs should conform to this concept.
    298298    /// The id's are unique and immutable.
    299299    template <typename _Base = BaseDigraphComponent>
    … …  
    373373    /// This class provides beside the core undirected graph features
    374374    /// core id functions for the undirected graph structure.  The
    375     /// most of the base undirected graphs should be conform to this
     375    /// most of the base undirected graphs should conform to this
    376376    /// concept.  The id's are unique and immutable.
    377377    template <typename _Base = BaseGraphComponent>

  • lemon/concepts/heap.h

    r566 r576  
    2121///\brief The concept of heaps.
    2222
    23 #ifndef LEMON_CONCEPT_HEAP_H
    24 #define LEMON_CONCEPT_HEAP_H
     23#ifndef LEMON_CONCEPTS_HEAP_H
     24#define LEMON_CONCEPTS_HEAP_H
    2525
    2626#include <lemon/core.h>
    … …  
    244244  } // namespace lemon
    245245}
    246 #endif // LEMON_CONCEPT_PATH_H
     246#endif

  • lemon/concepts/maps.h

    r463 r576  
    1717 */
    1818
    19 #ifndef LEMON_CONCEPT_MAPS_H
    20 #define LEMON_CONCEPT_MAPS_H
     19#ifndef LEMON_CONCEPTS_MAPS_H
     20#define LEMON_CONCEPTS_MAPS_H
    2121
    2222#include <lemon/core.h>
    … …  
    214214} //namespace lemon
    215215
    216 #endif // LEMON_CONCEPT_MAPS_H
     216#endif

  • lemon/concepts/path.h

    r463 r576  
    2222///
    2323
    24 #ifndef LEMON_CONCEPT_PATH_H
    25 #define LEMON_CONCEPT_PATH_H
     24#ifndef LEMON_CONCEPTS_PATH_H
     25#define LEMON_CONCEPTS_PATH_H
    2626
    2727#include <lemon/core.h>
    … …  
    306306} // namespace lemon
    307307
    308 #endif // LEMON_CONCEPT_PATH_H
     308#endif

  • lemon/core.h

    r463 r582  
    2323#include <algorithm>
    2424
     25#include <lemon/core.h>
    2526#include <lemon/bits/enable_if.h>
    2627#include <lemon/bits/traits.h>

  • lemon/cplex.cc

    r485 r587  
    452452  CplexLp::~CplexLp() {}
    453453
    454   CplexLp* CplexLp::_newSolver() const { return new CplexLp; }
    455   CplexLp* CplexLp::_cloneSolver() const {return new CplexLp(*this); }
     454  CplexLp* CplexLp::newSolver() const { return new CplexLp; }
     455  CplexLp* CplexLp::cloneSolver() const {return new CplexLp(*this); }
    456456
    457457  const char* CplexLp::_solverName() const { return "CplexLp"; }
    … …  
    824824  CplexMip::~CplexMip() {}
    825825
    826   CplexMip* CplexMip::_newSolver() const { return new CplexMip; }
    827   CplexMip* CplexMip::_cloneSolver() const {return new CplexMip(*this); }
     826  CplexMip* CplexMip::newSolver() const { return new CplexMip; }
     827  CplexMip* CplexMip::cloneSolver() const {return new CplexMip(*this); }
    828828
    829829  const char* CplexMip::_solverName() const { return "CplexMip"; }

  • lemon/cplex.h

    r485 r587  
    161161  /// This class implements an interface for the CPLEX LP solver.
    162162  ///\ingroup lp_group
    163   class CplexLp : public CplexBase, public LpSolver {
     163  class CplexLp : public LpSolver, public CplexBase {
    164164  public:
    165165    /// \e
    … …  
    171171    /// \e
    172172    virtual ~CplexLp();
     173
     174    /// \e
     175    virtual CplexLp* cloneSolver() const;
     176    /// \e
     177    virtual CplexLp* newSolver() const;
    173178
    174179  private:
    … …  
    186191
    187192  protected:
    188 
    189     virtual CplexLp* _cloneSolver() const;
    190     virtual CplexLp* _newSolver() const;
    191193
    192194    virtual const char* _solverName() const;
    … …  
    223225  /// This class implements an interface for the CPLEX MIP solver.
    224226  ///\ingroup lp_group
    225   class CplexMip : public CplexBase, public MipSolver {
     227  class CplexMip : public MipSolver, public CplexBase {
    226228  public:
    227229    /// \e

  • lemon/dfs.h

    r463 r525  
    5050    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    5151    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    52     ///Instantiates a PredMap.
    53 
    54     ///This function instantiates a PredMap.
     52    ///Instantiates a \c PredMap.
     53
     54    ///This function instantiates a \ref PredMap.
    5555    ///\param g is the digraph, to which we would like to define the
    56     ///PredMap.
     56    ///\ref PredMap.
    5757    static PredMap *createPredMap(const Digraph &g)
    5858    {
    … …  
    6565    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    6666    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    67     ///Instantiates a ProcessedMap.
    68 
    69     ///This function instantiates a ProcessedMap.
     67    ///Instantiates a \c ProcessedMap.
     68
     69    ///This function instantiates a \ref ProcessedMap.
    7070    ///\param g is the digraph, to which
    71     ///we would like to define the ProcessedMap
     71    ///we would like to define the \ref ProcessedMap.
    7272#ifdef DOXYGEN
    7373    static ProcessedMap *createProcessedMap(const Digraph &g)
    … …  
    8484    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    8585    typedef typename Digraph::template NodeMap<bool> ReachedMap;
    86     ///Instantiates a ReachedMap.
    87 
    88     ///This function instantiates a ReachedMap.
     86    ///Instantiates a \c ReachedMap.
     87
     88    ///This function instantiates a \ref ReachedMap.
    8989    ///\param g is the digraph, to which
    90     ///we would like to define the ReachedMap.
     90    ///we would like to define the \ref ReachedMap.
    9191    static ReachedMap *createReachedMap(const Digraph &g)
    9292    {
    … …  
    9999    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    100100    typedef typename Digraph::template NodeMap<int> DistMap;
    101     ///Instantiates a DistMap.
    102 
    103     ///This function instantiates a DistMap.
     101    ///Instantiates a \c DistMap.
     102
     103    ///This function instantiates a \ref DistMap.
    104104    ///\param g is the digraph, to which we would like to define the
    105     ///DistMap.
     105    ///\ref DistMap.
    106106    static DistMap *createDistMap(const Digraph &g)
    107107    {
    … …  
    221221    };
    222222    ///\brief \ref named-templ-param "Named parameter" for setting
    223     ///PredMap type.
     223    ///\c PredMap type.
    224224    ///
    225225    ///\ref named-templ-param "Named parameter" for setting
    226     ///PredMap type.
     226    ///\c PredMap type.
    227227    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    228228    template <class T>
    … …  
    241241    };
    242242    ///\brief \ref named-templ-param "Named parameter" for setting
    243     ///DistMap type.
     243    ///\c DistMap type.
    244244    ///
    245245    ///\ref named-templ-param "Named parameter" for setting
    246     ///DistMap type.
     246    ///\c DistMap type.
    247247    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    248248    template <class T>
    … …  
    261261    };
    262262    ///\brief \ref named-templ-param "Named parameter" for setting
    263     ///ReachedMap type.
     263    ///\c ReachedMap type.
    264264    ///
    265265    ///\ref named-templ-param "Named parameter" for setting
    266     ///ReachedMap type.
     266    ///\c ReachedMap type.
    267267    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
    268268    template <class T>
    … …  
    281281    };
    282282    ///\brief \ref named-templ-param "Named parameter" for setting
    283     ///ProcessedMap type.
     283    ///\c ProcessedMap type.
    284284    ///
    285285    ///\ref named-templ-param "Named parameter" for setting
    286     ///ProcessedMap type.
     286    ///\c ProcessedMap type.
    287287    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    288288    template <class T>
    … …  
    299299    };
    300300    ///\brief \ref named-templ-param "Named parameter" for setting
    301     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     301    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    302302    ///
    303303    ///\ref named-templ-param "Named parameter" for setting
    304     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     304    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    305305    ///If you don't set it explicitly, it will be automatically allocated.
    306306    struct SetStandardProcessedMap :
    … …  
    11271127  /// This class defines the interface of the DfsVisit events, and
    11281128  /// it could be the base of a real visitor class.
    1129   template <typename _Digraph>
     1129  template <typename GR>
    11301130  struct DfsVisitor {
    1131     typedef _Digraph Digraph;
     1131    typedef GR Digraph;
    11321132    typedef typename Digraph::Arc Arc;
    11331133    typedef typename Digraph::Node Node;
    … …  
    11651165  };
    11661166#else
    1167   template <typename _Digraph>
     1167  template <typename GR>
    11681168  struct DfsVisitor {
    1169     typedef _Digraph Digraph;
     1169    typedef GR Digraph;
    11701170    typedef typename Digraph::Arc Arc;
    11711171    typedef typename Digraph::Node Node;
    … …  
    12001200  /// Default traits class of DfsVisit class.
    12011201  /// \tparam _Digraph The type of the digraph the algorithm runs on.
    1202   template<class _Digraph>
     1202  template<class GR>
    12031203  struct DfsVisitDefaultTraits {
    12041204
    12051205    /// \brief The type of the digraph the algorithm runs on.
    1206     typedef _Digraph Digraph;
     1206    typedef GR Digraph;
    12071207
    12081208    /// \brief The type of the map that indicates which nodes are reached.
    … …  
    12251225  /// \ingroup search
    12261226  ///
    1227   /// \brief %DFS algorithm class with visitor interface.
     1227  /// \brief DFS algorithm class with visitor interface.
    12281228  ///
    1229   /// This class provides an efficient implementation of the %DFS algorithm
     1229  /// This class provides an efficient implementation of the DFS algorithm
    12301230  /// with visitor interface.
    12311231  ///
    1232   /// The %DfsVisit class provides an alternative interface to the Dfs
     1232  /// The DfsVisit class provides an alternative interface to the Dfs
    12331233  /// class. It works with callback mechanism, the DfsVisit object calls
    12341234  /// the member functions of the \c Visitor class on every DFS event.
    … …  
    12391239  /// instead.
    12401240  ///
    1241   /// \tparam _Digraph The type of the digraph the algorithm runs on.
    1242   /// The default value is
    1243   /// \ref ListDigraph. The value of _Digraph is not used directly by
    1244   /// \ref DfsVisit, it is only passed to \ref DfsVisitDefaultTraits.
    1245   /// \tparam _Visitor The Visitor type that is used by the algorithm.
    1246   /// \ref DfsVisitor "DfsVisitor<_Digraph>" is an empty visitor, which
     1241  /// \tparam GR The type of the digraph the algorithm runs on.
     1242  /// The default type is \ref ListDigraph.
     1243  /// The value of GR is not used directly by \ref DfsVisit,
     1244  /// it is only passed to \ref DfsVisitDefaultTraits.
     1245  /// \tparam VS The Visitor type that is used by the algorithm.
     1246  /// \ref DfsVisitor "DfsVisitor<GR>" is an empty visitor, which
    12471247  /// does not observe the DFS events. If you want to observe the DFS
    12481248  /// events, you should implement your own visitor class.
    1249   /// \tparam _Traits Traits class to set various data types used by the
     1249  /// \tparam TR Traits class to set various data types used by the
    12501250  /// algorithm. The default traits class is
    1251   /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<_Digraph>".
     1251  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
    12521252  /// See \ref DfsVisitDefaultTraits for the documentation of
    12531253  /// a DFS visit traits class.
    12541254#ifdef DOXYGEN
    1255   template <typename _Digraph, typename _Visitor, typename _Traits>
     1255  template <typename GR, typename VS, typename TR>
    12561256#else
    1257   template <typename _Digraph = ListDigraph,
    1258             typename _Visitor = DfsVisitor<_Digraph>,
    1259             typename _Traits = DfsVisitDefaultTraits<_Digraph> >
     1257  template <typename GR = ListDigraph,
     1258            typename VS = DfsVisitor<GR>,
     1259            typename TR = DfsVisitDefaultTraits<GR> >
    12601260#endif
    12611261  class DfsVisit {
    … …  
    12631263
    12641264    ///The traits class.
    1265     typedef _Traits Traits;
     1265    typedef TR Traits;
    12661266
    12671267    ///The type of the digraph the algorithm runs on.
    … …  
    12691269
    12701270    ///The visitor type used by the algorithm.
    1271     typedef _Visitor Visitor;
     1271    typedef VS Visitor;
    12721272
    12731273    ///The type of the map that indicates which nodes are reached.

  • lemon/dijkstra.h

    r463 r525  
    7474    typedef typename LM::Value Value;
    7575
    76     /// Operation traits for Dijkstra algorithm.
     76    /// Operation traits for %Dijkstra algorithm.
    7777
    7878    /// This class defines the operations that are used in the algorithm.
    … …  
    8585    /// Usually it is \c Digraph::NodeMap<int>.
    8686    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
    87     ///Instantiates a \ref HeapCrossRef.
     87    ///Instantiates a \c HeapCrossRef.
    8888
    8989    ///This function instantiates a \ref HeapCrossRef.
    … …  
    9595    }
    9696
    97     ///The heap type used by the Dijkstra algorithm.
     97    ///The heap type used by the %Dijkstra algorithm.
    9898
    9999    ///The heap type used by the Dijkstra algorithm.
    … …  
    102102    ///\sa Dijkstra
    103103    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
    104     ///Instantiates a \ref Heap.
     104    ///Instantiates a \c Heap.
    105105
    106106    ///This function instantiates a \ref Heap.
    … …  
    117117    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    118118    typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
    119     ///Instantiates a PredMap.
    120 
    121     ///This function instantiates a PredMap.
     119    ///Instantiates a \c PredMap.
     120
     121    ///This function instantiates a \ref PredMap.
    122122    ///\param g is the digraph, to which we would like to define the
    123     ///PredMap.
     123    ///\ref PredMap.
    124124    static PredMap *createPredMap(const Digraph &g)
    125125    {
    … …  
    133133    ///By default it is a NullMap.
    134134    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
    135     ///Instantiates a ProcessedMap.
    136 
    137     ///This function instantiates a ProcessedMap.
     135    ///Instantiates a \c ProcessedMap.
     136
     137    ///This function instantiates a \ref ProcessedMap.
    138138    ///\param g is the digraph, to which
    139     ///we would like to define the ProcessedMap
     139    ///we would like to define the \ref ProcessedMap.
    140140#ifdef DOXYGEN
    141141    static ProcessedMap *createProcessedMap(const Digraph &g)
    … …  
    152152    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    153153    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
    154     ///Instantiates a DistMap.
    155 
    156     ///This function instantiates a DistMap.
     154    ///Instantiates a \c DistMap.
     155
     156    ///This function instantiates a \ref DistMap.
    157157    ///\param g is the digraph, to which we would like to define
    158     ///the DistMap
     158    ///the \ref DistMap.
    159159    static DistMap *createDistMap(const Digraph &g)
    160160    {
    … …  
    217217    ///The heap type used by the algorithm.
    218218    typedef typename TR::Heap Heap;
    219     ///The operation traits class.
     219    ///\brief The \ref DijkstraDefaultOperationTraits "operation traits class"
     220    ///of the algorithm.
    220221    typedef typename TR::OperationTraits OperationTraits;
    221222
    … …  
    233234    const Digraph *G;
    234235    //Pointer to the length map.
    235     const LengthMap *length;
     236    const LengthMap *_length;
    236237    //Pointer to the map of predecessors arcs.
    237238    PredMap *_pred;
    … …  
    298299    };
    299300    ///\brief \ref named-templ-param "Named parameter" for setting
    300     ///PredMap type.
     301    ///\c PredMap type.
    301302    ///
    302303    ///\ref named-templ-param "Named parameter" for setting
    303     ///PredMap type.
     304    ///\c PredMap type.
    304305    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    305306    template <class T>
    … …  
    319320    };
    320321    ///\brief \ref named-templ-param "Named parameter" for setting
    321     ///DistMap type.
     322    ///\c DistMap type.
    322323    ///
    323324    ///\ref named-templ-param "Named parameter" for setting
    324     ///DistMap type.
     325    ///\c DistMap type.
    325326    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    326327    template <class T>
    … …  
    340341    };
    341342    ///\brief \ref named-templ-param "Named parameter" for setting
    342     ///ProcessedMap type.
     343    ///\c ProcessedMap type.
    343344    ///
    344345    ///\ref named-templ-param "Named parameter" for setting
    345     ///ProcessedMap type.
     346    ///\c ProcessedMap type.
    346347    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
    347348    template <class T>
    … …  
    359360    };
    360361    ///\brief \ref named-templ-param "Named parameter" for setting
    361     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     362    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    362363    ///
    363364    ///\ref named-templ-param "Named parameter" for setting
    364     ///ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
     365    ///\c ProcessedMap type to be <tt>Digraph::NodeMap<bool></tt>.
    365366    ///If you don't set it explicitly, it will be automatically allocated.
    366367    struct SetStandardProcessedMap
    … …  
    440441    ///
    441442    ///\ref named-templ-param "Named parameter" for setting
    442     ///\ref OperationTraits type.
     443    ///\c OperationTraits type.
    443444    template <class T>
    444445    struct SetOperationTraits
    … …  
    459460
    460461    ///Constructor.
    461     ///\param _g The digraph the algorithm runs on.
    462     ///\param _length The length map used by the algorithm.
    463     Dijkstra(const Digraph& _g, const LengthMap& _length) :
    464       G(&_g), length(&_length),
     462    ///\param g The digraph the algorithm runs on.
     463    ///\param length The length map used by the algorithm.
     464    Dijkstra(const Digraph& g, const LengthMap& length) :
     465      G(&g), _length(&length),
    465466      _pred(NULL), local_pred(false),
    466467      _dist(NULL), local_dist(false),
    … …  
    486487    Dijkstra &lengthMap(const LengthMap &m)
    487488    {
    488       length = &m;
     489      _length = &m;
    489490      return *this;
    490491    }
    … …  
    639640        switch(_heap->state(w)) {
    640641        case Heap::PRE_HEAP:
    641           _heap->push(w,OperationTraits::plus(oldvalue, (*length)[e]));
     642          _heap->push(w,OperationTraits::plus(oldvalue, (*_length)[e]));
    642643          _pred->set(w,e);
    643644          break;
    644645        case Heap::IN_HEAP:
    645646          {
    646             Value newvalue = OperationTraits::plus(oldvalue, (*length)[e]);
     647            Value newvalue = OperationTraits::plus(oldvalue, (*_length)[e]);
    647648            if ( OperationTraits::less(newvalue, (*_heap)[w]) ) {
    648649              _heap->decrease(w, newvalue);

  • lemon/dimacs.h

    r463 r572  
    296296  }
    297297
    298   /// DIMACS plain digraph reader function.
    299   ///
    300   /// This function reads a digraph without any designated nodes and
     298  template<typename Graph>
     299  typename enable_if<lemon::UndirectedTagIndicator<Graph>,void>::type
     300  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,
     301              dummy<0> = 0)
     302  {
     303    g.addEdge(s,t);
     304  }
     305  template<typename Graph>
     306  typename disable_if<lemon::UndirectedTagIndicator<Graph>,void>::type
     307  _addArcEdge(Graph &g, typename Graph::Node s, typename Graph::Node t,
     308              dummy<1> = 1)
     309  {
     310    g.addArc(s,t);
     311  }
     312 
     313  /// DIMACS plain (di)graph reader function.
     314  ///
     315  /// This function reads a (di)graph without any designated nodes and
    301316  /// maps from DIMACS format, i.e. from DIMACS files having a line
    302317  /// starting with
    … …  
    308323  /// If the file type was previously evaluated by dimacsType(), then
    309324  /// the descriptor struct should be given by the \c dest parameter.
    310   template<typename Digraph>
    311   void readDimacsMat(std::istream& is, Digraph &g,
    312                      DimacsDescriptor desc=DimacsDescriptor()) {
    313     typename Digraph::Node u,v;
    314     NullMap<typename Digraph::Arc, int> n;
     325  template<typename Graph>
     326  void readDimacsMat(std::istream& is, Graph &g,
     327                     DimacsDescriptor desc=DimacsDescriptor())
     328  {
    315329    if(desc.type==DimacsDescriptor::NONE) desc=dimacsType(is);
    316330    if(desc.type!=DimacsDescriptor::MAT)
    317331      throw FormatError("Problem type mismatch");
    318     _readDimacs(is, g, n, u, v, desc);
     332
     333    g.clear();
     334    std::vector<typename Graph::Node> nodes;
     335    char c;
     336    int i, j;
     337    std::string str;
     338    nodes.resize(desc.nodeNum + 1);
     339    for (int k = 1; k <= desc.nodeNum; ++k) {
     340      nodes[k] = g.addNode();
     341    }
     342   
     343    while (is >> c) {
     344      switch (c) {
     345      case 'c': // comment line
     346        getline(is, str);
     347        break;
     348      case 'n': // node definition line
     349        break;
     350      case 'a': // arc (arc) definition line
     351        is >> i >> j;
     352        getline(is, str);
     353        _addArcEdge(g,nodes[i], nodes[j]);
     354        break;
     355      }
     356    }
    319357  }
    320358

  • lemon/glpk.cc

    r585 r589  
    541541  }
    542542
    543   GlpkLp* GlpkLp::_newSolver() const { return new GlpkLp; }
    544   GlpkLp* GlpkLp::_cloneSolver() const { return new GlpkLp(*this); }
     543  GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }
     544  GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }
    545545
    546546  const char* GlpkLp::_solverName() const { return "GlpkLp"; }
    … …  
    947947  }
    948948
    949   GlpkMip* GlpkMip::_newSolver() const { return new GlpkMip; }
    950   GlpkMip* GlpkMip::_cloneSolver() const {return new GlpkMip(*this); }
     949  GlpkMip* GlpkMip::newSolver() const { return new GlpkMip; }
     950  GlpkMip* GlpkMip::cloneSolver() const {return new GlpkMip(*this); }
    951951
    952952  const char* GlpkMip::_solverName() const { return "GlpkMip"; }

  • lemon/glpk.h

    r585 r589  
    132132  /// This class implements an interface for the GLPK LP solver.
    133133  ///\ingroup lp_group
    134   class GlpkLp : public GlpkBase, public LpSolver {
     134  class GlpkLp : public LpSolver, public GlpkBase {
    135135  public:
    136136
    … …  
    139139    ///\e
    140140    GlpkLp(const GlpkLp&);
     141
     142    ///\e
     143    virtual GlpkLp* cloneSolver() const;
     144    ///\e
     145    virtual GlpkLp* newSolver() const;
    141146
    142147  private:
    … …  
    148153
    149154  protected:
    150 
    151     virtual GlpkLp* _cloneSolver() const;
    152     virtual GlpkLp* _newSolver() const;
    153155
    154156    virtual const char* _solverName() const;
    … …  
    166168    virtual Value _getDualRay(int i) const;
    167169
    168     ///\todo It should be clarified
    169     ///
    170170    virtual ProblemType _getPrimalType() const;
    171171    virtual ProblemType _getDualType() const;
    … …  
    216216  /// This class implements an interface for the GLPK MIP solver.
    217217  ///\ingroup lp_group
    218   class GlpkMip : public GlpkBase, public MipSolver {
     218  class GlpkMip : public MipSolver, public GlpkBase {
    219219  public:
    220220
    … …  
    224224    GlpkMip(const GlpkMip&);
    225225
    226   protected:
    227 
    228     virtual GlpkMip* _cloneSolver() const;
    229     virtual GlpkMip* _newSolver() const;
     226    virtual GlpkMip* cloneSolver() const;
     227    virtual GlpkMip* newSolver() const;
     228
     229  protected:
    230230
    231231    virtual const char* _solverName() const;

  • lemon/lp_base.h

    r561 r587  
    919919
    920920    //Abstract virtual functions
    921     virtual LpBase* _newSolver() const = 0;
    922     virtual LpBase* _cloneSolver() const = 0;
    923921
    924922    virtual int _addColId(int col) { return cols.addIndex(col); }
    … …  
    987985    /// Virtual destructor
    988986    virtual ~LpBase() {}
    989 
    990     ///Creates a new LP problem
    991     LpBase* newSolver() {return _newSolver();}
    992     ///Makes a copy of the LP problem
    993     LpBase* cloneSolver() {return _cloneSolver();}
    994987
    995988    ///Gives back the name of the solver.
    … …  
    18221815  public:
    18231816
     1817    ///Allocate a new LP problem instance
     1818    virtual LpSolver* newSolver() const = 0;
     1819    ///Make a copy of the LP problem
     1820    virtual LpSolver* cloneSolver() const = 0;
     1821
    18241822    ///\name Solve the LP
    18251823
    … …  
    19361934    ///@}
    19371935
    1938     LpSolver* newSolver() {return _newSolver();}
    1939     LpSolver* cloneSolver() {return _cloneSolver();}
    1940 
    19411936  protected:
    19421937
    1943     virtual LpSolver* _newSolver() const = 0;
    1944     virtual LpSolver* _cloneSolver() const = 0;
    19451938  };
    19461939
    … …  
    19761969    };
    19771970
     1971    ///Allocate a new MIP problem instance
     1972    virtual MipSolver* newSolver() const = 0;
     1973    ///Make a copy of the MIP problem
     1974    virtual MipSolver* cloneSolver() const = 0;
     1975
    19781976    ///\name Solve the MIP
    19791977
    … …  
    20632061    virtual Value _getSolValue() const = 0;
    20642062
    2065   public:
    2066 
    2067     MipSolver* newSolver() {return _newSolver();}
    2068     MipSolver* cloneSolver() {return _cloneSolver();}
    2069 
    2070   protected:
    2071 
    2072     virtual MipSolver* _newSolver() const = 0;
    2073     virtual MipSolver* _cloneSolver() const = 0;
    20742063  };
    20752064

  • lemon/lp_skeleton.cc

    r482 r587  
    106106  { return BASIC; }
    107107
    108   LpSkeleton* LpSkeleton::_newSolver() const
     108  LpSkeleton* LpSkeleton::newSolver() const
    109109  { return static_cast<LpSkeleton*>(0); }
    110110
    111   LpSkeleton* LpSkeleton::_cloneSolver() const
     111  LpSkeleton* LpSkeleton::cloneSolver() const
    112112  { return static_cast<LpSkeleton*>(0); }
    113113
    … …  
    123123  { return UNDEFINED; }
    124124
    125   MipSkeleton* MipSkeleton::_newSolver() const
     125  MipSkeleton* MipSkeleton::newSolver() const
    126126  { return static_cast<MipSkeleton*>(0); }
    127127
    128   MipSkeleton* MipSkeleton::_cloneSolver() const
     128  MipSkeleton* MipSkeleton::cloneSolver() const
    129129  { return static_cast<MipSkeleton*>(0); }
    130130

  • lemon/lp_skeleton.h

    r482 r588  
    1717 */
    1818
    19 #ifndef LEMON_LP_SKELETON
    20 #define LEMON_LP_SKELETON
     19#ifndef LEMON_LP_SKELETON_H
     20#define LEMON_LP_SKELETON_H
    2121
    2222#include <lemon/lp_base.h>
    2323
    2424///\file
    25 ///\brief A skeleton file to implement LP solver interfaces
     25///\brief Skeleton file to implement LP/MIP solver interfaces
     26/// 
     27///The classes in this file do nothing, but they can serve as skeletons when
     28///implementing an interface to new solvers.
    2629namespace lemon {
    2730
    28   ///A skeleton class to implement LP solver interfaces
     31  ///A skeleton class to implement LP/MIP solver base interface
     32 
     33  ///This class does nothing, but it can serve as a skeleton when
     34  ///implementing an interface to new solvers.
    2935  class SkeletonSolverBase : public virtual LpBase {
    3036    int col_num,row_num;
    … …  
    137143  };
    138144
    139   /// \brief Interface for a skeleton LP solver
     145  /// \brief Skeleton class for an LP solver interface
    140146  ///
    141   /// This class implements an interface for a skeleton LP solver.
     147  ///This class does nothing, but it can serve as a skeleton when
     148  ///implementing an interface to new solvers.
     149
    142150  ///\ingroup lp_group
    143   class LpSkeleton : public SkeletonSolverBase, public LpSolver {
     151  class LpSkeleton : public LpSolver, public SkeletonSolverBase {
    144152  public:
    145     LpSkeleton() : SkeletonSolverBase(), LpSolver() {}
    146 
     153    ///\e
     154    LpSkeleton() : LpSolver(), SkeletonSolverBase() {}
     155    ///\e
     156    virtual LpSkeleton* newSolver() const;
     157    ///\e
     158    virtual LpSkeleton* cloneSolver() const;
    147159  protected:
    148160
    … …  
    174186
    175187    ///\e
    176     virtual LpSkeleton* _newSolver() const;
    177     ///\e
    178     virtual LpSkeleton* _cloneSolver() const;
    179     ///\e
    180188    virtual const char* _solverName() const;
    181189
    182190  };
    183191
    184   /// \brief Interface for a skeleton MIP solver
     192  /// \brief Skeleton class for a MIP solver interface
    185193  ///
    186   /// This class implements an interface for a skeleton MIP solver.
     194  ///This class does nothing, but it can serve as a skeleton when
     195  ///implementing an interface to new solvers.
    187196  ///\ingroup lp_group
    188   class MipSkeleton : public SkeletonSolverBase, public MipSolver {
     197  class MipSkeleton : public MipSolver, public SkeletonSolverBase {
    189198  public:
    190     MipSkeleton() : SkeletonSolverBase(), MipSolver() {}
     199    ///\e
     200    MipSkeleton() : MipSolver(), SkeletonSolverBase() {}
     201    ///\e
     202    virtual MipSkeleton* newSolver() const;
     203    ///\e
     204    virtual MipSkeleton* cloneSolver() const;
    191205
    192206  protected:
    193207    ///\e
    194 
    195     ///\bug Wrong interface
    196     ///
    197208    virtual SolveExitStatus _solve();
    198209
    199210    ///\e
    200 
    201     ///\bug Wrong interface
    202     ///
    203211    virtual Value _getSol(int i) const;
    204212
    205213    ///\e
    206 
    207     ///\bug Wrong interface
    208     ///
    209214    virtual Value _getSolValue() const;
    210215
    211216    ///\e
    212 
    213     ///\bug Wrong interface
    214     ///
    215217    virtual ProblemType _getType() const;
    216218
    217219    ///\e
    218     virtual MipSkeleton* _newSolver() const;
    219 
    220     ///\e
    221     virtual MipSkeleton* _cloneSolver() const;
    222     ///\e
    223220    virtual const char* _solverName() const;
    224 
    225221  };
    226222
    227223} //namespace lemon
    228224
    229 #endif // LEMON_LP_SKELETON
     225#endif

  • lemon/preflow.h

    r463 r525  
    3232  ///
    3333  /// Default traits class of Preflow class.
    34   /// \tparam _Digraph Digraph type.
    35   /// \tparam _CapacityMap Capacity map type.
    36   template <typename _Digraph, typename _CapacityMap>
     34  /// \tparam GR Digraph type.
     35  /// \tparam CM Capacity map type.
     36  template <typename GR, typename CM>
    3737  struct PreflowDefaultTraits {
    3838
    3939    /// \brief The type of the digraph the algorithm runs on.
    40     typedef _Digraph Digraph;
     40    typedef GR Digraph;
    4141
    4242    /// \brief The type of the map that stores the arc capacities.
    … …  
    4444    /// The type of the map that stores the arc capacities.
    4545    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
    46     typedef _CapacityMap CapacityMap;
     46    typedef CM CapacityMap;
    4747
    4848    /// \brief The type of the flow values.
    … …  
    105105  /// second phase constructs a feasible maximum flow on each arc.
    106106  ///
    107   /// \tparam _Digraph The type of the digraph the algorithm runs on.
    108   /// \tparam _CapacityMap The type of the capacity map. The default map
    109   /// type is \ref concepts::Digraph::ArcMap "_Digraph::ArcMap<int>".
     107  /// \tparam GR The type of the digraph the algorithm runs on.
     108  /// \tparam CM The type of the capacity map. The default map
     109  /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
    110110#ifdef DOXYGEN
    111   template <typename _Digraph, typename _CapacityMap, typename _Traits>
     111  template <typename GR, typename CM, typename TR>
    112112#else
    113   template <typename _Digraph,
    114             typename _CapacityMap = typename _Digraph::template ArcMap<int>,
    115             typename _Traits = PreflowDefaultTraits<_Digraph, _CapacityMap> >
     113  template <typename GR,
     114            typename CM = typename GR::template ArcMap<int>,
     115            typename TR = PreflowDefaultTraits<GR, CM> >
    116116#endif
    117117  class Preflow {
    … …  
    119119
    120120    ///The \ref PreflowDefaultTraits "traits class" of the algorithm.
    121     typedef _Traits Traits;
     121    typedef TR Traits;
    122122    ///The type of the digraph the algorithm runs on.
    123123    typedef typename Traits::Digraph Digraph;

  • lemon/soplex.cc

    r485 r587  
    2020#include <lemon/soplex.h>
    2121
    22 #include <soplex/soplex.h>
     22#include <soplex.h>
    2323
    2424
    … …  
    5555  }
    5656
    57   SoplexLp* SoplexLp::_newSolver() const {
     57  SoplexLp* SoplexLp::newSolver() const {
    5858    SoplexLp* newlp = new SoplexLp();
    5959    return newlp;
    6060  }
    6161
    62   SoplexLp* SoplexLp::_cloneSolver() const {
     62  SoplexLp* SoplexLp::cloneSolver() const {
    6363    SoplexLp* newlp = new SoplexLp(*this);
    6464    return newlp;

  • lemon/soplex.h

    r485 r587  
    7474    /// \e
    7575    ~SoplexLp();
     76    /// \e
     77    virtual SoplexLp* newSolver() const;
     78    /// \e
     79    virtual SoplexLp* cloneSolver() const;
    7680
    7781  protected:
    78 
    79     virtual SoplexLp* _newSolver() const;
    80     virtual SoplexLp* _cloneSolver() const;
    8182
    8283    virtual const char* _solverName() const;

  • m4/lx_check_soplex.m4

    r480 r586  
    2121      SOPLEX_CXXFLAGS="-I$with_soplex_includedir"
    2222    elif test x"$with_soplex" != x"yes"; then
    23       SOPLEX_CXXFLAGS="-I$with_soplex/include"
     23      SOPLEX_CXXFLAGS="-I$with_soplex/src"
    2424    fi
    2525
    … …  
    3939
    4040    lx_soplex_test_prog='
    41       #include <soplex/soplex.h>
     41      #include <soplex.h>
    4242
    4343      int main(int argc, char** argv)

  • test/CMakeLists.txt

    r569 r575  
    3030  maps_test
    3131  max_matching_test
     32  min_cost_arborescence_test
    3233  path_test
    3334  preflow_test

  • test/Makefile.am

    r569 r575  
    2626        test/maps_test \
    2727        test/max_matching_test \
     28        test/min_cost_arborescence_test \
    2829        test/path_test \
    2930        test/preflow_test \
    … …  
    6768test_mip_test_SOURCES = test/mip_test.cc
    6869test_max_matching_test_SOURCES = test/max_matching_test.cc
     70test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
    6971test_path_test_SOURCES = test/path_test.cc
    7072test_preflow_test_SOURCES = test/preflow_test.cc

  • test/euler_test.cc

    r569 r578  
    2626void checkDiEulerIt(const Digraph& g)
    2727{
    28   typename Digraph::template ArcMap<int> visitationNumber(g);
     28  typename Digraph::template ArcMap<int> visitationNumber(g, 0);
    2929
    3030  DiEulerIt<Digraph> e(g);
    3131  typename Digraph::Node firstNode = g.source(e);
    32   typename Digraph::Node lastNode;
     32  typename Digraph::Node lastNode = g.target(e);
    3333
    3434  for (; e != INVALID; ++e)
    … …  
    5454void checkEulerIt(const Graph& g)
    5555{
    56   typename Graph::template EdgeMap<int> visitationNumber(g);
     56  typename Graph::template EdgeMap<int> visitationNumber(g, 0);
    5757
    5858  EulerIt<Graph> e(g);
    5959  typename Graph::Node firstNode = g.u(e);
    60   typename Graph::Node lastNode;
     60  typename Graph::Node lastNode = g.v(e);
    6161
    6262  for (; e != INVALID; ++e)

  • test/lp_test.cc

    r585 r589  
    198198    check(const_cast<const LpSolver::Expr&>(e)[p2]==0, buf.str());
    199199
     200    //Test for clone/new
     201    LP* lpnew = lp.newSolver();
     202    LP* lpclone = lp.cloneSolver();
     203    delete lpnew;
     204    delete lpclone;
    200205
    201206  }
    … …  
    248253  if (stat ==  LpSolver::OPTIMAL) {
    249254    std::ostringstream sbuf;
    250     sbuf << "Wrong optimal value: the right optimum is " << exp_opt;
     255    sbuf << "Wrong optimal value (" << lp.primal() <<") with "
     256         << lp.solverName() <<"\n     the right optimum is " << exp_opt;
    251257    check(std::abs(lp.primal()-exp_opt) < 1e-3, sbuf.str());
    252258  }
    … …  
    356362}
    357363
     364template<class LP>
     365void cloneTest()
     366{
     367  //Test for clone/new
     368 
     369  LP* lp = new LP();
     370  LP* lpnew = lp->newSolver();
     371  LP* lpclone = lp->cloneSolver();
     372  delete lp;
     373  delete lpnew;
     374  delete lpclone;
     375}
     376
    358377int main()
    359378{
    … …  
    366385    lpTest(lp_glpk1);
    367386    aTest(lp_glpk2);
     387    cloneTest<GlpkLp>();
    368388  }
    369389#endif
    … …  
    382402#endif
    383403  }
     404    cloneTest<CplexLp>();
    384405#endif
    385406
    … …  
    389410    lpTest(lp_soplex1);
    390411    aTest(lp_soplex2);
     412    cloneTest<SoplexLp>();
    391413  }
    392414#endif
    … …  
    397419    lpTest(lp_clp1);
    398420    aTest(lp_clp2);
     421    cloneTest<ClpLp>();
    399422  }
    400423#endif

  • test/mip_test.cc

    r585 r589  
    107107}
    108108
     109template<class MIP>
     110void cloneTest()
     111{
     112 
     113  MIP* mip = new MIP();
     114  MIP* mipnew = mip->newSolver();
     115  MIP* mipclone = mip->cloneSolver();
     116  delete mip;
     117  delete mipnew;
     118  delete mipclone;
     119}
    109120
    110121int main()
    … …  
    115126    GlpkMip mip1;
    116127    aTest(mip1);
     128    cloneTest<GlpkMip>();
    117129  }
    118130#endif
    … …  
    130142#endif
    131143  }
     144  cloneTest<CplexMip>();
    132145#endif
    133146

  • tools/Makefile.am

    r570 r573  
    22
    33bin_PROGRAMS += \
     4        tools/dimacs-solver \
    45        tools/dimacs-to-lgf \
    56        tools/lgf-gen
    … …  
    910endif WANT_TOOLS
    1011
     12tools_dimacs_solver_SOURCES = tools/dimacs-solver.cc
    1113tools_dimacs_to_lgf_SOURCES = tools/dimacs-to-lgf.cc
    1214tools_lgf_gen_SOURCES = tools/lgf-gen.cc
Note: See TracChangeset for help on using the changeset viewer.