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:
2 added
15 edited

Legend:

Unmodified
Added
Removed

  • CMakeLists.txt

    r236 r274  
    11CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
    22
    3 #EXECUTE_PROCESS(
    4 #  COMMAND hg id -i
    5 #  OUTPUT_VARIABLE HG_REVISION
    6 #  OUTPUT_STRIP_TRAILING_WHITESPACE)
    7 
    83SET(PROJECT_NAME "LEMON")
    9 SET(PROJECT_VERSION_MAJOR "0")
    10 SET(PROJECT_VERSION_MINOR "99")
    11 SET(PROJECT_VERSION_PATCH "0")
    12 SET(PROJECT_VERSION
    13   "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
     4SET(PROJECT_VERSION "hg-tip" CACHE STRING "The version string.")
    145
    156PROJECT(${PROJECT_NAME})
    … …  
    4031  SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE")
    4132
    42   SET(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
    43   SET(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
    44   SET(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
    4533  SET(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
    4634
    4735  SET(CPACK_PACKAGE_INSTALL_DIRECTORY
    48     "${PROJECT_NAME} ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
     36    "${PROJECT_NAME} ${PROJECT_VERSION}")
    4937  SET(CPACK_PACKAGE_INSTALL_REGISTRY_KEY
    50     "${PROJECT_NAME} ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
     38    "${PROJECT_NAME} ${PROJECT_VERSION}")
    5139
    5240  # Variables to generate a component-based installer.

  • NEWS

    r5 r262  
     120XX-XX-XX Version 1.0 released
     2
     3        This is the first stable release of LEMON. Compared to the 0.x
     4        release series, it features a considerably smaller but more
     5        matured set of tools. The API has also completely revised and
     6        changed in several places.
     7
     8        * The major name changes compared to the 0.x series
     9          * Graph -> Digraph, UGraph -> Graph
     10          * Edge -> Arc, UEdge -> Edge
     11          * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)
     12        * Other improvements
     13          * Better documentation
     14          * Reviewed and cleaned up codebase
     15          * CMake based build system (along with the autotools based one)
     16        * Contents of the library (ported from 0.x)
     17          * Algorithms
     18            * breadth-first search (bfs.h)
     19            * depth-first search (dfs.h)
     20            * Dijkstra's algorithm (dijkstra.h)
     21            * Kruskal's algorithm (kruskal.h)
     22          * Data structures
     23            * graph data structures (list_graph.h, smart_graph.h)
     24            * path data structures (path.h)
     25            * binary heap data structure (bin_heap.h)
     26            * union-find data structures (unionfind.h)
     27            * miscellaneous property maps (maps.h)
     28            * two dimensional vector and bounding box (dim2.h)
     29          * Concepts
     30            * graph structure concepts (concepts/digraph.h, concepts/graph.h,
     31              concepts/graph_components.h)
     32            * concepts for other structures (concepts/heap.h, concepts/maps.h,
     33              concepts/path.h)
     34          * Tools
     35            * Mersenne twister random number generator (random.h)
     36            * tools for measuring cpu and wall clock time (time_measure.h)
     37            * tools for counting steps and events (counter.h)
     38            * tool for parsing command line arguments (arg_parser.h)
     39            * tool for visualizing graphs (graph_to_eps.h)
     40            * tools for reading and writing data in LEMON Graph Format
     41              (lgf_reader.h, lgf_writer.h)
     42            * tools to handle the anomalies of calculations with
     43              floating point numbers (tolerance.h)
     44            * tools to manage RGB colors (color.h)
     45          * Infrastructure
     46            * extended assertion handling (assert.h)
     47            * exception classes and error handling (error.h)
     48            * concept checking (concept_check.h)
     49            * commonly used mathematical constants (math.h)

  • configure.ac

    r259 r273  
    22
    33dnl Version information.
    4 m4_define([lemon_version_number], [])
     4m4_define([lemon_version_number],
     5        [m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])
     6dnl m4_define([lemon_version_number], [])
     7m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))])
    58m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i]))])
    6 m4_define([lemon_version], [ifelse(lemon_version_number(), [], [lemon_hg_revision()], [lemon_version_number()])])
     9m4_define([lemon_version], [ifelse(lemon_version_number(),
     10                           [],
     11                           [lemon_hg_path().lemon_hg_revision()],
     12                           [lemon_version_number()])])
    713
    814AC_PREREQ([2.59])

  • doc/Makefile.am

    r227 r270  
    77        doc/license.dox \
    88        doc/mainpage.dox \
     9        doc/named-param.dox \
    910        doc/namespaces.dox \
    1011        doc/html \

  • lemon/arg_parser.h

    r214 r261  
    1717 */
    1818
    19 #ifndef LEMON_ARG_PARSER
    20 #define LEMON_ARG_PARSER
     19#ifndef LEMON_ARG_PARSER_H
     20#define LEMON_ARG_PARSER_H
    2121
    2222#include <vector>
    … …  
    383383}
    384384
    385 #endif // LEMON_ARG_PARSER
     385#endif // LEMON_ARG_PARSER_H

  • lemon/assert.h

    r218 r277  
    2828namespace lemon {
    2929
    30   inline void assert_fail_log(const char *file, int line, const char *function,
    31                               const char *message, const char *assertion)
     30  inline void assert_fail_abort(const char *file, int line,
     31                                const char *function, const char* message,
     32                                const char *assertion)
    3233  {
    3334    std::cerr << file << ":" << line << ": ";
    … …  
    3839      std::cerr << " (assertion '" << assertion << "' failed)";
    3940    std::cerr << std::endl;
    40   }
    41 
    42   inline void assert_fail_abort(const char *file, int line,
    43                                 const char *function, const char* message,
    44                                 const char *assertion)
    45   {
    46     assert_fail_log(file, line, function, message, assertion);
    4741    std::abort();
    4842  }
    … …  
    6458
    6559#undef LEMON_ASSERT
    66 #undef LEMON_FIXME
    6760#undef LEMON_DEBUG
    6861
    69 #if (defined(LEMON_ASSERT_LOG) ? 1 : 0) +               \
    70   (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +               \
     62#if (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +               \
    7163  (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1
    7264#error "LEMON assertion system is not set properly"
    7365#endif
    7466
    75 #if ((defined(LEMON_ASSERT_LOG) ? 1 : 0) +              \
    76      (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +            \
     67#if ((defined(LEMON_ASSERT_ABORT) ? 1 : 0) +            \
    7768     (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||     \
    7869     defined(LEMON_ENABLE_ASSERTS)) &&                  \
    … …  
    8374
    8475
    85 #if defined LEMON_ASSERT_LOG
    86 #  undef LEMON_ASSERT_HANDLER
    87 #  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_log
    88 #elif defined LEMON_ASSERT_ABORT
     76#if defined LEMON_ASSERT_ABORT
    8977#  undef LEMON_ASSERT_HANDLER
    9078#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
    … …  
    10896#  elif defined _MSC_VER
    10997#    define LEMON_FUNCTION_NAME (__FUNCSIG__)
     98#  elif __STDC_VERSION__ >= 199901L
     99#    define LEMON_FUNCTION_NAME (__func__)
    110100#  else
    111 #    define LEMON_FUNCTION_NAME (__func__)
     101#    define LEMON_FUNCTION_NAME ("<unknown>")
    112102#  endif
    113103#endif
    … …  
    119109/// \brief Macro for assertion with customizable message
    120110///
    121 /// Macro for assertion with customizable message.  \param exp An
    122 /// expression that must be convertible to \c bool.  If it is \c
    123 /// false, then an assertion is raised. The concrete behaviour depends
    124 /// on the settings of the assertion system.  \param msg A <tt>const
    125 /// char*</tt> parameter, which can be used to provide information
    126 /// about the circumstances of the failed assertion.
     111/// Macro for assertion with customizable message. 
     112/// \param exp An expression that must be convertible to \c bool.  If it is \c
     113/// false, then an assertion is raised. The concrete behaviour depends on the
     114/// settings of the assertion system.
     115/// \param msg A <tt>const char*</tt> parameter, which can be used to provide
     116/// information about the circumstances of the failed assertion.
    127117///
    128118/// The assertions are enabled in the default behaviour.
    … …  
    138128/// The checking is also disabled when the standard macro \c NDEBUG is defined.
    139129///
    140 /// The LEMON assertion system has a wide range of customization
    141 /// properties. As a default behaviour the failed assertion prints a
    142 /// short log message to the standard error and aborts the execution.
    143 ///
    144 /// The following modes can be used in the assertion system:
    145 ///
    146 /// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
    147 ///   message to the standard error and continues the execution.
    148 /// - \c LEMON_ASSERT_ABORT This mode is similar to the \c
    149 ///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
    150 ///   behaviour.
     130/// As a default behaviour the failed assertion prints a short log message to
     131/// the standard error and aborts the execution.
     132///
     133/// However, the following modes can be used in the assertion system:
     134/// - \c LEMON_ASSERT_ABORT The failed assertion prints a short log message to
     135///   the standard error and aborts the program. It is the default behaviour.
    151136/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
    152137///   function.
    … …  
    176161/// \ingroup exceptions
    177162///
    178 /// \brief Macro for mark not yet implemented features.
    179 ///
    180 /// Macro for mark not yet implemented features and outstanding bugs.
    181 /// It is close to be the shortcut of the following code:
    182 /// \code
    183 ///   LEMON_ASSERT(false, msg);
    184 /// \endcode
    185 ///
    186 /// \see LEMON_ASSERT
    187 #  define LEMON_FIXME(msg)                                              \
    188   (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,        \
    189                         ::lemon::_assert_bits::cstringify(msg),         \
    190                         static_cast<const char*>(0)))
    191 
    192 /// \ingroup exceptions
    193 ///
    194163/// \brief Macro for internal assertions
    195164///
    … …  
    223192#  ifndef LEMON_ASSERT_HANDLER
    224193#    define LEMON_ASSERT(exp, msg)  (static_cast<void>(0))
    225 #    define LEMON_FIXME(msg) (static_cast<void>(0))
    226194#    define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
    227195#  else
    … …  
    232200                             ::lemon::_assert_bits::cstringify(msg),    \
    233201                             #exp), 0)))
    234 #    define LEMON_FIXME(msg)                                            \
    235        (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,   \
    236                              ::lemon::_assert_bits::cstringify(msg),    \
    237                              static_cast<const char*>(0)))
    238 
    239202#    if LEMON_ENABLE_DEBUG
    240203#      define LEMON_DEBUG(exp, msg)                                     \

  • lemon/bits/array_map.h

    r209 r263  
    104104    }
    105105
     106  private:
    106107    /// \brief Constructor to copy a map of the same map type.
    107108    ///
    … …  
    151152    }
    152153
     154  public:
    153155    /// \brief The destructor of the map.
    154156    ///

  • lemon/bits/graph_extender.h

    r220 r263  
    228228        : Parent(digraph, value) {}
    229229
     230    private:
    230231      NodeMap& operator=(const NodeMap& cmap) {
    231232        return operator=<NodeMap>(cmap);
    … …  
    252253        : Parent(digraph, value) {}
    253254
     255    private:
    254256      ArcMap& operator=(const ArcMap& cmap) {
    255257        return operator=<ArcMap>(cmap);
    … …  
    609611        : Parent(graph, value) {}
    610612
     613    private:
    611614      NodeMap& operator=(const NodeMap& cmap) {
    612615        return operator=<NodeMap>(cmap);
    … …  
    633636        : Parent(graph, value) {}
    634637
     638    private:
    635639      ArcMap& operator=(const ArcMap& cmap) {
    636640        return operator=<ArcMap>(cmap);
    … …  
    658662        : Parent(graph, value) {}
    659663
     664    private:
    660665      EdgeMap& operator=(const EdgeMap& cmap) {
    661666        return operator=<EdgeMap>(cmap);

  • lemon/bits/map_extender.h

    r209 r263  
    6363      : Parent(graph, value) {}
    6464
     65  private:
    6566    MapExtender& operator=(const MapExtender& cmap) {
    6667      return operator=<MapExtender>(cmap);
    … …  
    7374    }
    7475
     76  public:
    7577    class MapIt : public Item {
    7678    public:
    … …  
    201203      : Parent(_graph, _value), graph(_graph) {}
    202204
     205  private:
    203206    SubMapExtender& operator=(const SubMapExtender& cmap) {
    204207      return operator=<MapExtender>(cmap);
    … …  
    215218    }
    216219
     220  public:
    217221    class MapIt : public Item {
    218222    public:

  • lemon/bits/vector_map.h

    r220 r263  
    101101    }
    102102
     103  private:
    103104    /// \brief Copy constructor
    104105    ///

  • lemon/concepts/digraph.h

    r220 r263  
    435435        NodeMap(const Digraph&, T) { }
    436436
     437      private:
    437438        ///Copy constructor
    438439        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
    … …  
    457458        ///\e
    458459        ArcMap(const Digraph&, T) { }
     460      private:
    459461        ///Copy constructor
    460462        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }

  • lemon/concepts/graph.h

    r220 r263  
    513513        NodeMap(const Graph&, T) { }
    514514
     515      private:
    515516        ///Copy constructor
    516517        NodeMap(const NodeMap& nm) : ReadWriteMap< Node, T >(nm) { }
    … …  
    536537        ///\e
    537538        ArcMap(const Graph&, T) { }
     539      private:
    538540        ///Copy constructor
    539541        ArcMap(const ArcMap& em) : ReadWriteMap<Arc,T>(em) { }
    … …  
    559561        ///\e
    560562        EdgeMap(const Graph&, T) { }
     563      private:
    561564        ///Copy constructor
    562565        EdgeMap(const EdgeMap& em) : ReadWriteMap<Edge,T>(em) {}

  • lemon/concepts/graph_components.h

    r220 r263  
    10061006      /// Construct a new map for the graph and initalise the values.
    10071007      GraphMap(const Graph&, const Value&) {}
     1008
     1009    private:
    10081010      /// \brief Copy constructor.
    10091011      ///
    … …  
    10221024      }
    10231025
     1026    public:
    10241027      template<typename _Map>
    10251028      struct Constraints {
    … …  
    10311034          _Map a2(g,t);
    10321035          // Copy constructor.
    1033           _Map b(c);
    1034 
    1035           ReadMap<Key, Value> cmap;
    1036           b = cmap;
    1037 
     1036          // _Map b(c);
     1037
     1038          // ReadMap<Key, Value> cmap;
     1039          // b = cmap;
     1040
     1041          ignore_unused_variable_warning(a);
    10381042          ignore_unused_variable_warning(a2);
    1039           ignore_unused_variable_warning(b);
     1043          // ignore_unused_variable_warning(b);
    10401044        }
    10411045
    … …  
    10831087          : Parent(digraph, value) {}
    10841088
     1089      private:
    10851090        /// \brief Copy constructor.
    10861091        ///
    … …  
    11201125          : Parent(digraph, value) {}
    11211126
     1127      private:
    11221128        /// \brief Copy constructor.
    11231129        ///
    … …  
    12161222          : Parent(graph, value) {}
    12171223
     1224      private:
    12181225        /// \brief Copy constructor.
    12191226        ///

  • test/error_test.cc

    r223 r277  
    4848}
    4949
    50 void fixme_disable() {
    51   LEMON_FIXME("fixme_disable() is fixme!");
    52 }
    53 
    5450void check_assertion_disable() {
    5551  no_assertion_text_disable();
    5652  assertion_text_disable();
    57   fixme_disable();
    5853}
    5954#undef LEMON_DISABLE_ASSERTS
    … …  
    7974}
    8075
    81 void fixme_custom() {
    82   LEMON_FIXME("fixme_custom() is fixme!");
    83 }
    84 
    8576void check_assertion_custom() {
    8677  no_assertion_text_custom();
    8778  assertion_text_custom();
    88   fixme_custom();
    89   check(cnt == 2, "The custom assert handler does not work");
     79  check(cnt == 1, "The custom assert handler does not work");
    9080}
    9181

  • test/graph_test.h

    r228 r263  
    213213    check(s == 0, "Wrong sum.");
    214214
    215     map = constMap<Node>(12);
    216     for (NodeIt it(G); it != INVALID; ++it) {
    217       check(map[it] == 12, "Wrong operator[].");
    218     }
     215    // map = constMap<Node>(12);
     216    // for (NodeIt it(G); it != INVALID; ++it) {
     217    //   check(map[it] == 12, "Wrong operator[].");
     218    // }
    219219  }
    220220
    … …  
    243243    check(s == 0, "Wrong sum.");
    244244
    245     map = constMap<Arc>(12);
    246     for (ArcIt it(G); it != INVALID; ++it) {
    247       check(map[it] == 12, "Wrong operator[].");
    248     }
     245    // map = constMap<Arc>(12);
     246    // for (ArcIt it(G); it != INVALID; ++it) {
     247    //   check(map[it] == 12, "Wrong operator[].");
     248    // }
    249249  }
    250250
    … …  
    273273    check(s == 0, "Wrong sum.");
    274274
    275     map = constMap<Edge>(12);
    276     for (EdgeIt it(G); it != INVALID; ++it) {
    277       check(map[it] == 12, "Wrong operator[].");
    278     }
     275    // map = constMap<Edge>(12);
     276    // for (EdgeIt it(G); it != INVALID; ++it) {
     277    //   check(map[it] == 12, "Wrong operator[].");
     278    // }
    279279  }
    280280
Note: See TracChangeset for help on using the changeset viewer.