RhodeCode

 * purpose.

 *

 */

namespace lemon {

/**

@defgroup datas Data Structures

*/

/**

@defgroup graphs Graph Structures

@ingroup datas

\brief Graph structures implemented in LEMON.

The implementation of combinatorial algorithms heavily relies on

\endcode

*/

/**

@defgroup semi_adaptors Semi-Adaptor Classes for Graphs

@ingroup graphs

\brief Graph types between real graphs and graph adaptors.

These classes wrap graphs to give new functionality as the adaptors do it.

On the other hand they are not light-weight structures as the adaptors.

*/

/**

@defgroup maps Maps

@ingroup datas

\brief Map structures implemented in LEMON.

LEMON provides several special purpose maps and map adaptors that e.g. combine

new maps from existing ones.

<b>See also:</b> \ref map_concepts "Map Concepts".

*/

/**

@defgroup graph_maps Graph Maps

@ingroup maps

\brief Special graph-related maps.

values to the nodes and arcs/edges of graphs.

If you are looking for the standard graph maps (\c NodeMap, \c ArcMap,

\c EdgeMap), see the \ref graph_concepts "Graph Structure Concepts".

*/

/**

\defgroup map_adaptors Map Adaptors

\ingroup maps

\brief Tools to create new maps from existing ones

maps from other maps.

Most of them are \ref concepts::ReadMap "read-only maps".

They can make arithmetic and logical operations between one or two maps

(negation, shifting, addition, multiplication, logical 'and', 'or',

'not' etc.) or e.g. convert a map to another one of different Value type.

The typical usage of this classes is passing implicit maps to

\c Dijkstra algorithm.

*/

/**

@defgroup matrices Matrices

@ingroup datas

\brief Two dimensional data storages implemented in LEMON.

*/

/**

@defgroup paths Path Structures

@ingroup datas

\brief %Path structures implemented in LEMON.

LEMON provides flexible data structures to work with paths.

All of them have similar interfaces and they can be copied easily with

assignment operators and copy constructors. This makes it easy and

efficient to have e.g. the Dijkstra algorithm to store its result in

any kind of path structure.

\sa lemon::concepts::Path

*/

/**

@defgroup auxdat Auxiliary Data Structures

@ingroup datas

\brief Auxiliary data structures implemented in LEMON.

order to make it easier to implement combinatorial algorithms.

*/

/**

@defgroup algs Algorithms

implemented in LEMON.

implemented in LEMON.

*/

/**

@defgroup search Graph Search

@ingroup algs

\brief Common graph search algorithms.

\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).

*/

/**

@defgroup shortest_path Shortest Path Algorithms

@ingroup algs

\brief Algorithms for finding shortest paths.

 - \ref Dijkstra algorithm for finding shortest paths from a source node

   when all arc lengths are non-negative.

 - \ref BellmanFord "Bellman-Ford" algorithm for finding shortest paths

   from a source node when arc lenghts can be either positive or negative,

   but the digraph should not contain directed cycles with negative total

   length.

 - \ref FloydWarshall "Floyd-Warshall" and \ref Johnson "Johnson" algorithms

   arc-disjoint paths between two nodes having minimum total length.

*/

/**

@defgroup max_flow Maximum Flow Algorithms

@ingroup algs

\brief Algorithms for finding maximum flows.

feasible circulations.

The \e maximum \e flow \e problem is to find a flow of maximum value between

a single source and a single target. Formally, there is a \f$G=(V,A)\f$

digraph, a \f$cap:A\rightarrow\mathbf{R}^+_0\f$ capacity function and

\f$s, t \in V\f$ source and target nodes.

A maximum flow is an \f$f:A\rightarrow\mathbf{R}^+_0\f$ solution of the

following optimization problem.

*/

/**

@defgroup min_cost_flow Minimum Cost Flow Algorithms

@ingroup algs

\brief Algorithms for finding minimum cost flows and circulations.

circulations.

The \e minimum \e cost \e flow \e problem is to find a feasible flow of

minimum total cost from a set of supply nodes to a set of demand nodes

in a network with capacity constraints and arc costs.

Formally, let \f$G=(V,A)\f$ be a digraph,

\f$lower, upper: A\rightarrow\mathbf{Z}^+_0\f$ denote the lower and

upper bounds for the flow values on the arcs,

*/

/**

@defgroup min_cut Minimum Cut Algorithms

@ingroup algs

\brief Algorithms for finding minimum cut in graphs.

The \e minimum \e cut \e problem is to find a non-empty and non-complete

\f$X\f$ subset of the nodes with minimum overall capacity on

outgoing arcs. Formally, there is a \f$G=(V,A)\f$ digraph, a

\f$cap: A\rightarrow\mathbf{R}^+_0\f$ capacity function. The minimum

cut is the \f$X\f$ solution of the next optimization problem:

\f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}

    \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]

LEMON contains several algorithms related to minimum cut problems:

- \ref HaoOrlin "Hao-Orlin algorithm" for calculating minimum cut

  in directed graphs.

- \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for

  calculating minimum cut in undirected graphs.

  all-pairs minimum cut in undirected graphs.

If you want to find minimum cut just between two distinict nodes,

see the \ref max_flow "maximum flow problem".

*/

/**

@defgroup graph_prop Connectivity and Other Graph Properties

@ingroup algs

\brief Algorithms for discovering the graph properties

like connectivity, bipartiteness, euler property, simplicity etc.

\image html edge_biconnected_components.png

\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth

*/

/**

@defgroup planar Planarity Embedding and Drawing

@ingroup algs

\brief Algorithms for planarity checking, embedding and drawing

embedding and drawing.

\image html planar.png

\image latex planar.eps "Plane graph" width=\textwidth

*/

/**

@defgroup matching Matching Algorithms

\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth

*/

/**

@defgroup spantree Minimum Spanning Tree Algorithms

@ingroup algs

\brief Algorithms for finding a minimum cost spanning tree in a graph.

tree in a graph.

*/

/**

@defgroup auxalg Auxiliary Algorithms

@ingroup algs

\brief Auxiliary algorithms implemented in LEMON.

in order to make it easier to implement complex algorithms.

*/

/**

@defgroup approx Approximation Algorithms

@ingroup algs

\brief Approximation algorithms.

implemented in LEMON.

*/

/**

@defgroup gen_opt_group General Optimization Tools

implemented in LEMON.

implemented in LEMON.

*/

/**

@defgroup lp_group Lp and Mip Solvers

@ingroup gen_opt_group

\brief Lp and Mip solver interfaces for LEMON.

various LP solvers could be used in the same manner with this

interface.

*/

/**

@defgroup lp_utils Tools for Lp and Mip Solvers

@ingroup lp_group

\brief Helper tools to the Lp and Mip solvers.

implemented in LEMON.

*/

/**

@defgroup metah Metaheuristics

@ingroup gen_opt_group

\brief Metaheuristics for LEMON library.

*/

/**

@defgroup utils Tools and Utilities

\brief Tools and utilities for programming in LEMON

Tools and utilities for programming in LEMON.

*/

/**

@defgroup gutils Basic Graph Utilities

@ingroup utils

\brief Simple basic graph utilities.

*/

/**

@defgroup misc Miscellaneous Tools

@ingroup utils

\brief Tools for development, debugging and testing.

debugging and testing.

*/

/**

@defgroup timecount Time Measuring and Counting

@ingroup misc

\brief Simple tools for measuring the performance of algorithms.

of algorithms.

*/

/**

@defgroup exceptions Exceptions

@ingroup utils

\brief Exceptions defined in LEMON.

*/

/**

@defgroup io_group Input-Output

\brief Graph Input-Output methods

and graph related data. Now it supports the \ref lgf-format

"LEMON Graph Format", the \c DIMACS format and the encapsulated

postscript (EPS) format.

*/

/**

@defgroup lemon_io LEMON Graph Format

@ingroup io_group

\brief Reading and writing LEMON Graph Format.

\ref lgf-format "LEMON Graph Format".

*/

/**

@defgroup eps_io Postscript Exporting

@ingroup io_group

\brief General \c EPS drawer and graph exporter

graph exporting tools.

*/

/**

@defgroup dimacs_group DIMACS format

@ingroup io_group

\brief Read and write files in DIMACS format

Tool to read graphs from \e Nauty format data.

*/

/**

@defgroup concept Concepts

\brief Skeleton classes and concept checking classes

classes implemented in LEMON.

The purpose of the classes in this group is fourfold.

- These classes contain the documentations of the %concepts. In order

  to avoid document multiplications, an implementation of a concept

  simply refers to the corresponding concept class.

- Finally, They can serve as a skeleton of a new implementation of a concept.

*/

/**

@defgroup graph_concepts Graph Structure Concepts

@ingroup concept

\brief Skeleton and concept checking classes for graph structures

graph structures and helper classes used to implement these.

*/

/**

@defgroup map_concepts Map Concepts

@ingroup concept

\brief Skeleton and concept checking classes for maps

*/

/**

\anchor demoprograms

@defgroup demos Demo Programs

Some demo programs are listed here. Their full source codes can be found in

</b>

\subsection howtoread How to read the documentation

If you want to get a quick start and see the most important features then

take a look at our \ref quicktour

"Quick Tour to LEMON" which will guide you along.

If you know what you are looking for then try to find it under the

If you are a user of the old (0.x) series of LEMON, please check out the

\ref migration "Migration Guide" for the backward incompatibilities.

*/

    Undirector(DGR& digraph) {

      initialize(digraph);

    }

    /// \brief Arc map combined from two original arc maps

    ///

    /// This map adaptor class adapts two arc maps of the underlying

    /// digraph to get an arc map of the undirected graph.

    class CombinedArcMap {

    public:

      /// The key type of the map

      typedef typename Parent::Arc Key;

      /// The value type of the map

      /// Constructor

        : _forward(&forward), _backward(&backward) {}

      /// Sets the value associated with the given key.

      void set(const Key& e, const Value& a) {

        if (Parent::direction(e)) {

          _forward->set(e, a);

        } else {

          _backward->set(e, a);

          return (*_forward)[e];

        } else {

          return (*_backward)[e];

        }

      }

    protected:

    };

    /// \brief Returns a combined arc map

    ///

    /// This function just returns a combined arc map.

    }

    }

    }

    }

  };

  /// \brief Returns a read-only Undirector adaptor

  ///

  /// This function just returns a read-only \ref Undirector adaptor.

  /// \ingroup graph_adaptors

    static Arc arc(const DigraphArc& a) {

      return Parent::arc(a);

    }

    /// \brief Node map combined from two original node maps

    ///

    /// This map adaptor class adapts two node maps of the original digraph

    /// to get a node map of the split digraph.

    class CombinedNodeMap {

    public:

      /// The key type of the map

      typedef Node Key;

      /// The value type of the map

      /// Constructor

        : _in_map(in_map), _out_map(out_map) {}

      /// Returns the value associated with the given key.

      Value operator[](const Key& key) const {

        if (SplitNodesBase<const DGR>::inNode(key)) {

          return _in_map[key];

        } else {

          return _out_map[key];

          _in_map.set(key, value);

        } else {

          _out_map.set(key, value);

        }

      }

    private:

    };

    /// \brief Returns a combined node map

    ///

    /// This function just returns a combined node map.

    }

    }

    }

    }

    /// \brief Arc map combined from an arc map and a node map of the

    /// original digraph.

    ///

    /// This map adaptor class adapts an arc map and a node map of the

    /// original digraph to get an arc map of the split digraph.

    class CombinedArcMap {

    public:

      /// The key type of the map

      typedef Arc Key;

      /// The value type of the map

      /// Constructor

        : _arc_map(arc_map), _node_map(node_map) {}

      /// Returns the value associated with the given key.

      Value operator[](const Key& arc) const {

        if (SplitNodesBase<const DGR>::origArc(arc)) {

          return _arc_map[arc];

        } else {

          return _node_map[arc];

        if (SplitNodesBase<const DGR>::origArc(arc)) {

          _arc_map.set(arc, val);

        } else {

          _node_map.set(arc, val);

        }

      }

    private:

    };

    /// \brief Returns a combined arc map

    ///

    /// This function just returns a combined arc map.

    template <typename ArcMap, typename NodeMap>

    static CombinedArcMap<ArcMap, NodeMap>

    combinedArcMap(ArcMap& arc_map, NodeMap& node_map) {

#include <functional>

namespace lemon {

  ///\ingroup auxdat

  ///

  ///\brief A Binary Heap implementation.

  ///

  ///

  ///to handle the cross references.

  ///

  ///\sa FibHeap

  ///\sa Dijkstra

  class BinHeap {

  public:

    ///\e

    ///\e

    ///\e

    typedef typename ItemIntMap::Key Item;

    ///\e

    typedef std::pair<Item,Prio> Pair;

    ///\e

    /// \brief Type to represent the items states.

    ///

    /// Each Item element have a state associated to it. It may be "in heap",

    /// "pre heap" or "post heap". The latter two are indifferent from the

    /// heap's point of view, but may be useful to the user.

    ///

    enum State {

    };

  private:

  public:

    /// \brief The constructor.

    ///

    /// The constructor.

    /// internally to handle the cross references. The value of the map

    /// \brief The constructor.

    ///

    /// The constructor.

    /// internally to handle the cross references. The value of the map

    /// should be PRE_HEAP (-1) for each element.

    ///

    /// The number of items stored in the heap.

    ///

    /// \brief Returns the number of items stored in the heap.

    /// \brief Checks if the heap stores no items.

    ///

    /// Returns \c true if and only if the heap stores no items.

    /// \brief Make empty this heap.

    ///

    /// Make empty this heap. It does not change the cross reference map.

    /// If you want to reuse what is not surely empty you should first clear

    /// the heap and after that you should set the cross reference map for

    /// each item to \c PRE_HEAP.

    void clear() {

    }

  private:

    static int parent(int i) { return (i-1)/2; }

    static int second_child(int i) { return 2*i+2; }

    bool less(const Pair &p1, const Pair &p2) const {

    }

    int bubble_up(int hole, Pair p) {

      int par = parent(hole);

        hole = par;

        par = parent(hole);

      }

      move(p, hole);

      return hole;

    }

    int bubble_down(int hole, Pair p, int length) {

      int child = second_child(hole);

      while(child < length) {

          --child;

        }

          goto ok;

        hole = child;

        child = second_child(hole);

      }

      child--;

        hole=child;

      }

    ok:

      move(p, hole);

      return hole;

    }

    void move(const Pair &p, int i) {

    }

  public:

    /// \brief Insert a pair of item and priority into the heap.

    ///

    /// Adds \c p.first to the heap with priority \c p.second.

    /// \param p The pair to insert.

    void push(const Pair &p) {

      bubble_up(n, p);

    }

    /// \brief Insert an item into the heap with the given heap.

    ///

    /// Adds \c i to the heap with priority \c p.

    /// \param i The item to insert.

    /// \param p The priority of the item.

    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }

    /// \brief Returns the item with minimum priority relative to \c Compare.

    ///

    /// This method returns the item with minimum priority relative to \c

    /// Compare.

    /// \pre The heap must be nonempty.

    Item top() const {

    }

    /// \brief Returns the minimum priority relative to \c Compare.

    ///

    /// It returns the minimum priority relative to \c Compare.

    /// \pre The heap must be nonempty.

    Prio prio() const {

    }

    /// \brief Deletes the item with minimum priority relative to \c Compare.

    ///

    /// This method deletes the item with minimum priority relative to \c

    /// Compare from the heap.

    /// \pre The heap must be non-empty.

    void pop() {

      if (n > 0) {

      }

    }

    /// \brief Deletes \c i from the heap.

    ///

    /// This method deletes item \c i from the heap.

    /// \param i The item to erase.

    /// \pre The item should be in the heap.

    void erase(const Item &i) {

      if( h < n ) {

        }

      }