Release notes

2026-11-12 Version 1.9.0 (abLEMON) released

        Alternative optimal potentials by the dual simplex, the
        certificates taken from the algorithms and judged with their
        tolerances, and the tolerances and the traits of the library used
        consistently

        * New features

          ----: KBestExtremeFlows::potentialMethod( PIVOTS ), the optimal
                potentials reached from those of the optimal vertex by the
                pivots of the dual simplex, breadth first, each a vertex of
                the polyhedron of the optimal potentials
          ----: NetworkSimplex::infeasibleCut() gives the set that the last
                tree proves infeasible, a level set of its potentials under
                the costs of the first phase, as the other three algorithms
                give their own; the maximum flow is left as a fallback
          ----: infeasibleCuts(k) gives first the sets that tie for the
                largest violation, the closed sets of the residual graph of
                one maximum flow (Picard and Queyranne, 1980), and then
                finds the best set of a part of Lawler's partition only
                when the part is the most promising one
          ----: unboundedCycles(k) takes the negative cycles of all the
                strongly connected components from one run of HowardMmc,
                which gives them through componentCycleNum() and
                componentCycle()
          ----: the four minimum cost flow algorithms, KBestFlows and
                KBestExtremeFlows give the tolerances in use with
                flowTolerance() and costTolerance(); KBestFlows and
                KBestExtremeFlows take them with tolerances()
          ----: BellmanFord and Dijkstra keep an object of their operation
                traits, set with operationTraits(); BidirDijkstra, AStar
                and MinCostArborescence take the type of their heap from
                their traits (SetHeap); GomoryHu and NagamochiIbaraki have
                tolerance()
          ----: the concepts of the minimum cost flow, maximum flow and
                minimum mean cycle classes are in lemon/concepts
                (MinCostFlow, MaxFlow and MinMeanCycle)

        * Implementation improvements

          ----: one definition of the default tolerances of the four
                minimum cost flow algorithms; those of NetworkSimplex on
                the flows now count the finite bounds too
          ----: every comparison of cycle canceling and cost scaling with
                zero goes through the tolerance; the inner minimum mean
                cycle of cycle canceling, the maximum flow and the minimum
                mean cycle of the certificates use the tolerances of the
                algorithm
          ----: in floating point NetworkSimplex puts the leaving arc at
                the bound it is nearer, which may change its pivots
          ----: EdmondsKarp::init() of a flow returns whether the flow is
                feasible, as Preflow::init() does

2026-11-05 Version 1.8.1 (abLEMON) released

        A faster generation of the flows by the cycles of least reduced
        cost

        * Implementation improvements

          ----: KBestExtremeFlows::method( CYCLES ) tries only the arcs at a
                bound of a vertex, finds the cycles of zero reduced cost
                through the strongly connected components of the arcs of
                zero reduced cost, and tries the other cycles by increasing
                reduced cost of their arc, each path looked for by a
                Dijkstra's algorithm stopped at its end or at the bound;
                the vertices of larger cost kept are those of the cycles of
                least reduced cost rather than those of least cost, and
                they are found 3 to 20 times faster on the subproblems of a
                multicommodity flow problem

2026-11-05 Version 1.8.0 (abLEMON) released

        The alternative optimal potentials of a minimum cost flow problem

        * New features

          ----: KBestExtremeFlows::runPotentials(k), up to k distinct
                optimal potentials, the vertices of the dual polyhedron
                given by the trees of the shortest paths from and to each
                node on the reduced costs of the residual graph of the
                optimal flow; potentialNum() and potential(i, node) read
                them

        * Miscellaneous

          ----: the code in the prose of the comments is spaced as the
                code, e.g., GR::EdgeMap< bool >

2026-11-04 Version 1.7.0 (abLEMON) released

        The K best integer and extreme flows, several certificates of an
        infeasible or unbounded minimum cost flow problem, and the
        tolerances of the four algorithms set by the caller

        * New algorithms

          ----: KBestFlows, the K integer flows of least cost of a minimum
                cost flow problem in order, by the algorithm of Hamacher
                and the partition of Lawler, from the optimal flow of
                NetworkSimplex or from a given one
          ----: KBestExtremeFlows, the K vertices of least cost of the
                polyhedron of the flows in order, the optimal ones first,
                optionally within a gap, by the ranking of Murty, with a
                limit on the bases expanded in all and for each vertex,
                or by the cycles of least reduced cost from the optimal
                vertices, which enumerates no basis

        * New features

          ----: infeasibleCuts(k) in the four minimum cost flow algorithms,
                the k most violated sets of nodes in order, by the
                partition of Lawler with one maximum flow per part, each
                started from the flow of its parent
          ----: disjointInfeasibleCuts(), the violated weakly connected
                components of the most violated set, which share no node
                and no arc
          ----: unboundedCycles(k), arc-disjoint negative cycles of
                infinite capacity, each of minimum mean cost among the
                arcs not yet taken
          ----: tolerances( flow , cost ), which sets the tolerances on the
                flows and on the reduced costs, a negative value leaving
                them relative to the data as before
          ----: infeasibleCut() of CostScaling, CycleCanceling and
                CapacityScaling gives the set the algorithm has at hand
                when it finds no feasible flow, the maximum flow being
                left as a fallback

        * Bug fixes

          ----: CostScaling with floating-point costs and an integer
                LargeCost never ended its scaling
          ----: MSVC warned of narrowing conversions in ArgParser and in
                the tolerances of an exact type

2026-11-04 Version 1.6.0 (abLEMON) released

        lemon-ng is now abLEMON; the certificates of an infeasible and of
        an unbounded minimum cost flow problem, and the four minimum cost
        flow algorithms on floating-point data

        * The name

          ----: lemon-ng is now abLEMON (a better LEMON, and an able one):
                the repository is https://github.com/dmeoli/abLEMON, the
                packages are ablemon, and the headers, the namespace and
                find_package(LEMON) do not change

        * New features

          ----: infeasibleCut() in NetworkSimplex, CostScaling,
                CapacityScaling and CycleCanceling, a set of nodes whose
                supply exceeds what the arcs out of it can carry, which
                proves an INFEASIBLE answer
          ----: unboundedCycle() in the four, a directed cycle of negative
                cost and infinite capacity, which proves an UNBOUNDED
                answer; NetworkSimplex no longer gives an empty one when
                its pivot cycle goes through an artificial arc
          ----: CostScaling, CapacityScaling and CycleCanceling solve
                problems with floating-point costs, capacities and
                supplies, which they asked to be integer

        * Bug fixes

          ----: CostScaling, CapacityScaling and CycleCanceling answered
                INFEASIBLE on floating-point supplies that sum to zero in
                decimal and not in binary

        * Removed

          ----: runWarm() of the four minimum cost flow algorithms
                (1.4.0 to 1.5.0): a re-optimization belongs to whoever
                knows what has changed, and a second run() solves the
                changed problem

        * Tests

          ----: min_cost_flow_battery_test runs every algorithm and method
                on limit cases and on random instances, with integer and
                floating-point data, and checks each answer by its
                certificate and against the others

2026-11-03 Version 1.5.0 (lemon-ng) released

        The algorithms for bipartite matching, for a shortest path
        between two nodes and for an exact maximum clique, the static
        undirected graph and the C++20 module, with fixes of
        GrossoLocatelliPullanMc and Circulation

        * New data structures

          ----: StaticGraph, the undirected counterpart of StaticDigraph,
                built once from another graph or from a list of edges

        * New algorithms

          #168: HopcroftKarp, a maximum cardinality matching of a
                bipartite graph, with the vertex cover that proves it, and
                MinCostAssignment, a minimum cost matching that covers the
                red nodes, with its dual potentials
          #249: BidirDijkstra and AStar, for a shortest path between two
                nodes, by two searches that meet halfway and by a search
                guided by an admissible heuristic
          ----: TomitaSekiMc, the exact maximum clique algorithm of Tomita
                and Seki, next to the heuristic GrossoLocatelliPullanMc

        * Bug fixes

          ----: GrossoLocatelliPullanMc ran forever on a graph with a loop
          ----: Circulation read past its storage on an empty digraph
          ----: SoplexLp did not compile with SoPlex 5 and later, and gave
                the Farkas proof of the dual as its primal ray

        * Building and installing

          ----: The C++20 module lemon, with -DLEMON_BUILD_MODULE=ON on
                Clang 16 or MSVC 19.34, as the target LEMON::lemon_module
          ----: SoPlex is found through its CMake configuration, which
                brings the libraries that its headers call
          ----: No narrowing of a size_t to an int is left implicit, so
                that MSVC no longer warns of C4267 in LEMON
          ----: The packages of vcpkg, conda and Conan build LEMON as a
                DLL on Windows too
          ----: The documentation no longer names the classes of LEMON
                0.x that were never ported

2026-11-01 Version 1.4.1 (lemon-ng) released

        A release of fixes, among them one of NetworkSimplex::runWarm(),
        which gave a flow that is not feasible on a problem with lower
        bounds

        * Bug fixes

          ----: NetworkSimplex::runWarm() after a change of the costs of a
                problem with lower bounds added the lower bounds to the flow
                a second time, which gave a flow that is not feasible
          ----: The four minimum cost flow algorithms answer UNBOUNDED on
                the same problems, the feasible ones with a cycle of
                negative cost made of arcs of infinite upper bound:
                CostScaling and CycleCanceling no longer answer it on any
                arc of negative cost and infinite upper bound, nor
                CapacityScaling on a feasible problem, and NetworkSimplex
                checks that the problem is feasible first
          #625: Preflow::init() takes the maximum flow of another Preflow
                on large floating-point capacities
          ----: GlpkMip and CbcMip take an integer column whose bounds are
                not integer as the integer values within its bounds, and
                a column without any as an infeasible problem
          ----: ArrayMap moves the values into its larger buffer when it
                grows, rather than copying them

        * Building and installing

          #657: LEMON can be built as a DLL on Windows, with its data
                exported, and the tests find the DLL
          ----: LEMON can be taken in by another project with
                add_subdirectory() or FetchContent
          ----: The installation follows GNUInstallDirs, and lemon.pc
                finds its prefix wherever it is
          ----: The installed configuration names the libraries of the LP
                and MIP solvers by their file names, not by the paths of
                the machine that built LEMON
          ----: The headers of COIN-OR are found also in include/coin-or
          ----: The headers turn off only the warnings of MSVC that they
                give (C4250 and C4267), and mark the types of the
                [DI]GRAPH_TYPEDEFS macros as possibly unused
          ----: The packages declare, besides the Boost Software License,
                the BSD-3-Clause notice of the Mersenne Twister of
                lemon/random.h
          ----: The documentation in the theme of doxygen-awesome, with
                its formulae drawn by MathJax and its citations resolved

2026-11-01 Version 1.4.0 (lemon-ng) released

        This is the first release of lemon-ng, the maintained fork of
        LEMON; it keeps the headers and the namespace of LEMON

        * Portability

          ----: Compiles without warnings from C++11 to C++23 with GCC,
                Clang, AppleClang and MSVC (std::allocator_traits, no
                std::iterator, noexcept, no result_type)
          ----: The headers survive the macros min and max of <windows.h>
                and MIN and MAX of <sys/param.h>, and are self-contained
          ----: The LGF readers and writers compile under C++23

        * Bug fixes

          #646: BinomialHeap could loop in pop(), and truncated fractional
                priorities
          #681: RadixHeap mixed the items of adjacent boxes
          #672, #682: Vf2 and Vf2pp indexed a map with INVALID, and their
                wizards did not compile
          #626: CbcMip reported a proven infeasible problem as feasible
          ----: BellmanFord could delete a map of the user
          ----: The minimum cost flow algorithms reported a digraph without
                nodes as infeasible
          ----: CapacityScaling did not compile on types narrower than int
          ----: The price refinement of CostScaling could write past the end
                of its buckets
          ----: Default-constructed items of the graphs are INVALID, and the
                fields that some classes copied uninitialized are set

        * Minimum cost flow

          ----: NetworkSimplex solves problems with floating-point data,
                compares reduced costs and residual flows against
                tolerances, and gives the cycle that proves a problem
                unbounded (unboundedCycle())
          ----: NetworkSimplex updates the potentials on the smaller side of
                the tree at each pivot
          ----: CostScaling and CycleCanceling find their starting flow on
                their residual network; CapacityScaling uses a 4-ary heap
          ----: runWarm() in the four algorithms solves the problem again
                after a change of the costs, of the upper bounds or of the
                supplies, from the basis, the flow or the potentials of the
                last run

        * Building and installing

          ----: CMake 3.19, CMAKE_CXX_STANDARD, the version from the tag of
                git, options to leave out the tests, the demos, the tools
                and the documentation
          ----: A relocatable CMake configuration with the target
                LEMON::lemon, and a relocatable lemon.pc
          ----: Makefiles for GNU make, with no configuration step
          ----: The code in the style of .clang-format and of
                scripts/format.py
          ----: The documentation on https://dmeoli.github.io/lemon-ng/

2013-08-10 Version 1.3 released

        This is major feature release

        * New data structures

          #69 : Bipartite graph concepts and implementations

        * New algorithms

          #177: Port Edmonds-Karp algorithm
          #380, #405: Heuristic algorithm for the max clique problem
          #386: Heuristic algorithms for symmetric TSP
          ----: Nagamochi-Ibaraki algorithm [5087694945e4]
          #397, #56: Max. cardinality search

        * Other new features

          #223: Thread safe graph and graph map implementations
          #442: Different TimeStamp print formats
          #457: File export functionality to LpBase
          #362: Bidirectional iterator support for radixSort()

        * Implementation improvements

          ----: Network Simplex
                #391: Better update process, pivot rule and arc mixing
                #435: Improved Altering List pivot rule
          #417: Various fine tunings in CostScaling
          #438: Optional iteration limit in HowardMmc
          #436: Ensure strongly polynomial running time for CycleCanceling
                while keeping the same performance
          ----: Make the CBC interface be compatible with latest CBC releases
                [ee581a0ecfbf]

        * CMAKE has become the default build environment (#434)

          ----: Autotool support has been dropped
          ----: Improved LP/MIP configuration
                #465: Enable/disable options for LP/MIP backends
                #446: Better CPLEX discovery
                #460: Add cmake config to find SoPlex
          ----: Allow CPACK configuration on all platforms
          #390: Add 'Maintainer' CMAKE build type
          #388: Add 'check' target.
          #401: Add contrib dir
          #389: Better version string setting in CMAKE
          #433: Support shared library build    
          #416: Support testing with valgrind
  
        * Doc improvements

          #395: SOURCE_BROWSER Doxygen switch is configurable from CMAKE
                update-external-tags CMAKE target
          #455: Optionally use MathJax for rendering the math formulae
          #402, #437, #459, #456, #463: Various doc improvements

        * Bugfixes (compared to release 1.2):

          #432: Add missing doc/template.h and doc/references.bib to release
                tarball
          ----: Intel C++ compatibility fixes
          #441: Fix buggy reinitialization in _solver_bits::VarIndex::clear()
          #444: Bugfix in path copy constructors and assignment operators
          #447: Bugfix in AllArcLookUp<>
          #448: Bugfix in adaptor_test.cc
          #449: Fix clang compilation warnings and errors
          #440: Fix a bug + remove redundant typedefs in dimacs-solver
          #453: Avoid GCC 4.7 compiler warnings
          #445: Fix missing initialization in CplexEnv::CplexEnv()
          #428: Add missing lemon/lemon.pc.cmake to the release tarball
          #393: Create and install lemon.pc
          #429: Fix VS warnings
          #430: Fix LpBase::Constr two-side limit bug
          #392: Bug fix in Dfs::start(s,t)
          #414: Fix wrong initialization in Preflow
          #418: Better Win CodeBlock/MinGW support
          #419: Build environment improvements
                - Build of mip_test and lp_test precede the running of the tests
                - Also search for coin libs under ${COIN_ROOT_DIR}/lib/coin
                - Do not look for COIN_VOL libraries
          #382: Allow lgf file without Arc maps
          #417: Bug fix in CostScaling
          #366: Fix Pred[Matrix]MapPath::empty()
          #371: Bug fix in (di)graphCopy()
                The target graph is cleared before adding nodes and arcs/edges.
          #364: Add missing UndirectedTags
          #368: Fix the usage of std::numeric_limits<>::min() in Network Simplex
          #372: Fix a critical bug in preflow
          #461: Bugfix in assert.h
          #470: Fix compilation issues related to various gcc versions
          #446: Fix #define indicating CPLEX availability
          #294: Add explicit namespace to
                ignore_unused_variable_warning() usages
          #420: Bugfix in IterableValueMap
          #439: Bugfix in biNodeConnected()


2010-03-19 Version 1.2 released

        This is major feature release

        * New algorithms
          * Bellman-Ford algorithm (#51)
          * Minimum mean cycle algorithms (#179)
            * Karp, Hartman-Orlin and Howard algorithms
          * New minimum cost flow algorithms (#180)
            * Cost Scaling algorithms
            * Capacity Scaling algorithm
            * Cycle-Canceling algorithms
          * Planarity related algorithms (#62)
            * Planarity checking algorithm
            * Planar embedding algorithm
            * Schnyder's planar drawing algorithm
            * Coloring planar graphs with five or six colors
          * Fractional matching algorithms (#314)
        * New data structures
          * StaticDigraph structure (#68)
          * Several new priority queue structures (#50, #301)
            * Fibonacci, Radix, Bucket, Pairing, Binomial
              D-ary and fourary heaps (#301)
          * Iterable map structures (#73)
        * Other new tools and functionality
          * Map utility functions (#320)
          * Reserve functions are added to ListGraph and SmartGraph (#311)
          * A resize() function is added to HypercubeGraph (#311)
          * A count() function is added to CrossRefMap (#302)
          * Support for multiple targets in Suurballe using fullInit() (#181)
          * Traits class and named parameters for Suurballe (#323)
          * Separate reset() and resetParams() functions in NetworkSimplex
            to handle graph changes (#327)
          * tolerance() functions are added to HaoOrlin (#306)
        * Implementation improvements
          * Improvements in weighted matching algorithms (#314)
            * Jumpstart initialization
          * ArcIt iteration is based on out-arc lists instead of in-arc lists
            in ListDigraph (#311)
          * Faster add row operation in CbcMip (#203)
          * Better implementation for split() in ListDigraph (#311)
          * ArgParser can also throw exception instead of exit(1) (#332)
        * Miscellaneous
          * A simple interactive bootstrap script
          * Doc improvements (#62,#180,#299,#302,#303,#304,#307,#311,#331,#315,
                #316,#319)
            * BibTeX references in the doc (#184)
          * Optionally use valgrind when running tests
          * Also check ReferenceMapTag in concept checks (#312)
          * dimacs-solver uses long long type by default.
        * Several bugfixes (compared to release 1.1):
          #295: Suppress MSVC warnings using pragmas
          ----: Various CMAKE related improvements
                * Remove duplications from doc/CMakeLists.txt
                * Rename documentation install folder from 'docs' to 'html'
                * Add tools/CMakeLists.txt to the tarball
                * Generate and install LEMONConfig.cmake
                * Change the label of the html project in Visual Studio
                * Fix the check for the 'long long' type
                * Put the version string into config.h
                * Minor CMake improvements
                * Set the version to 'hg-tip' if everything fails
          #311: Add missing 'explicit' keywords
          #302: Fix the implementation and doc of CrossRefMap
          #308: Remove duplicate list_graph.h entry from source list
          #307: Bugfix in Preflow and Circulation
          #305: Bugfix and extension in the rename script
          #312: Also check ReferenceMapTag in concept checks
          #250: Bugfix in pathSource() and pathTarget()
          #321: Use pathCopy(from,to) instead of copyPath(to,from)
          #322: Distribure LEMONConfig.cmake.in
          #330: Bug fix in map_extender.h
          #336: Fix the date field comment of graphToEps() output
          #323: Bug fix in Suurballe
          #335: Fix clear() function in ExtendFindEnum
          #337: Use void* as the LPX object pointer
          #317: Fix (and improve) error message in mip_test.cc
                Remove unnecessary OsiCbc dependency
          #356: Allow multiple executions of weighted matching algorithms (#356)

2009-05-13 Version 1.1 released

        This is the second stable release of the 1.x series. It
        features a better coverage of the tools available in the 0.x
        series, a thoroughly reworked LP/MIP interface plus various
        improvements in the existing tools.

        * Much improved M$ Windows support
          * Various improvements in the CMAKE build system
          * Compilation warnings are fixed/suppressed
        * Support IBM xlC compiler
        * New algorithms
          * Connectivity related algorithms (#61)
          * Euler walks (#65)
          * Preflow push-relabel max. flow algorithm (#176)
          * Circulation algorithm (push-relabel based) (#175)
          * Suurballe algorithm (#47)
          * Gomory-Hu algorithm (#66)
          * Hao-Orlin algorithm (#58)
          * Edmond's maximum cardinality and weighted matching algorithms
            in general graphs (#48,#265)
          * Minimum cost arborescence/branching (#60)
          * Network Simplex min. cost flow algorithm (#234)
        * New data structures
          * Full graph structure (#57)
          * Grid graph structure (#57)
          * Hypercube graph structure (#57)
          * Graph adaptors (#67)
          * ArcSet and EdgeSet classes (#67)
          * Elevator class (#174)
        * Other new tools
          * LP/MIP interface (#44)
            * Support for GLPK, CPLEX, Soplex, COIN-OR CLP and CBC
          * Reader for the Nauty file format (#55)
          * DIMACS readers (#167)
          * Radix sort algorithms (#72)
          * RangeIdMap and CrossRefMap (#160)
        * New command line tools
          * DIMACS to LGF converter (#182)
          * lgf-gen - a graph generator (#45)
          * DIMACS solver utility (#226)
        * Other code improvements
          * Lognormal distribution added to Random (#102)
          * Better (i.e. O(1) time) item counting in SmartGraph (#3)
          * The standard maps of graphs are guaranteed to be
            reference maps (#190)
        * Miscellaneous
          * Various doc improvements
          * Improved 0.x -> 1.x converter script

        * Several bugfixes (compared to release 1.0):
          #170: Bugfix SmartDigraph::split()
          #171: Bugfix in SmartGraph::restoreSnapshot()
          #172: Extended test cases for graphs and digraphs
          #173: Bugfix in Random
                * operator()s always return a double now
                * the faulty real< Num >(Num) and real< Num >(Num,Num)
                  have been removed
          #187: Remove DijkstraWidestPathOperationTraits
          #61:  Bugfix in DfsVisit
          #193: Bugfix in GraphReader::skipSection()
          #195: Bugfix in ConEdgeIt()
          #197: Bugfix in heap unionfind
                * This bug affects Edmond's general matching algorithms
          #207: Fix 'make install' without 'make html' using CMAKE
          #208: Suppress or fix VS2008 compilation warnings
          ----: Update the LEMON icon
          ----: Enable the component-based installer
                (in installers made by CPACK)
          ----: Set the proper version for CMAKE in the tarballs
                (made by autotools)
          ----: Minor clarification in the LICENSE file
          ----: Add missing unistd.h include to time_measure.h
          #204: Compilation bug fixed in graph_to_eps.h with VS2005
          #214,#215: windows.h should never be included by LEMON headers
          #230: Build systems check the availability of 'long long' type
          #229: Default implementation of Tolerance<> is used for integer types
          #211,#212: Various fixes for compiling on AIX
          ----: Improvements in CMAKE config
                - docs is installed in share/doc/
                - detects newer versions of Ghostscript
          #239: Fix missing 'inline' specifier in time_measure.h
          #274,#280: Install lemon/config.h
          #275: Prefix macro names with LEMON_ in lemon/config.h
          ----: Small script for making the release tarballs added
          ----: Minor improvement in unify-sources.sh (a76f55d7d397)

2009-03-27 LEMON joins to the COIN-OR initiative

        COIN-OR (Computational Infrastructure for Operations Research,
        http://www.coin-or.org) project is an initiative to spur the
        development of open-source software for the operations research
        community.

2008-10-13 Version 1.0 released

        This is the first stable release of LEMON. Compared to the 0.x
        release series, it features a considerably smaller but more
        matured set of tools. The API has also completely revised and
        changed in several places.

        * The major name changes compared to the 0.x series (see the
          Migration Guide in the doc for more details)
          * Graph -> Digraph, UGraph -> Graph
          * Edge -> Arc, UEdge -> Edge
          * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)
        * Other improvements
          * Better documentation
          * Reviewed and cleaned up codebase
          * CMake based build system (along with the autotools based one)
        * Contents of the library (ported from 0.x)
          * Algorithms
            * breadth-first search (bfs.h)
            * depth-first search (dfs.h)
            * Dijkstra's algorithm (dijkstra.h)
            * Kruskal's algorithm (kruskal.h)
          * Data structures
            * graph data structures (list_graph.h, smart_graph.h)
            * path data structures (path.h)
            * binary heap data structure (bin_heap.h)
            * union-find data structures (unionfind.h)
            * miscellaneous property maps (maps.h)
            * two dimensional vector and bounding box (dim2.h)
          * Concepts
            * graph structure concepts (concepts/digraph.h, concepts/graph.h,
              concepts/graph_components.h)
            * concepts for other structures (concepts/heap.h, concepts/maps.h,
              concepts/path.h)
          * Tools
            * Mersenne twister random number generator (random.h)
            * tools for measuring cpu and wall clock time (time_measure.h)
            * tools for counting steps and events (counter.h)
            * tool for parsing command line arguments (arg_parser.h)
            * tool for visualizing graphs (graph_to_eps.h)
            * tools for reading and writing data in LEMON Graph Format
              (lgf_reader.h, lgf_writer.h)
            * tools to handle the anomalies of calculations with
              floating point numbers (tolerance.h)
            * tools to manage RGB colors (color.h)
          * Infrastructure
            * extended assertion handling (assert.h)
            * exception classes and error handling (error.h)
            * concept checking (concept_check.h)
            * commonly used mathematical constants (math.h)