RhodeCode

      IN_HEAP = 0,    ///< = 0.

      PRE_HEAP = -1,  ///< = -1.

      POST_HEAP = -2  ///< = -2.

      /// \name Base Iteration

      /// \name Class Based Iteration

      /// \name Base Iteration

      /// \name Class Based Iteration

        IN_HEAP = 0,    ///< = 0. The "in heap" state constant.

        PRE_HEAP = -1,  ///< = -1. The "pre heap" state constant.

        POST_HEAP = -2  ///< = -2. The "post heap" state constant.

    ///\name Named Template Parameters

    ///\name Named Template Parameters

    ///\brief DIMACS file type enum

    ///

    ///DIMACS file type enum.

    enum Type {

      NONE,  ///< Undefined type.

      MIN,   ///< DIMACS file type for minimum cost flow problems.

      MAX,   ///< DIMACS file type for maximum flow problems.

      SP,    ///< DIMACS file type for shostest path problems.

      MAT    ///< DIMACS file type for plain graphs and matching problems.

    };

    ///Constructor. It sets the type to \c NONE.

  ///This function starts seeking the beginning of the given file for the

  ///problem type and size info. 

  ///The found data is returned in a special struct that can be evaluated

  ///and passed to the appropriate reader function.

  /// \brief DIMACS minimum cost flow reader function.

  /// \brief DIMACS maximum flow reader function.

  /// \brief DIMACS shortest path reader function.

  /// \brief DIMACS capacitated digraph reader function.

  /// \brief DIMACS plain (di)graph reader function.

  /// This function reads a plain (di)graph without any designated nodes

  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 

  /// DIMACS files having a line starting with

    ///\image latex nodeshape_3.eps "MALE shape (3)" width=2cm

    ///\image latex nodeshape_4.eps "FEMALE shape (4)" width=2cm

  /// \brief Kruskal's algorithm for finding a minimum cost spanning tree of

  /// spanning tree of a graph.

  /// <tt>std::pair<GR::Arc,C></tt> or

  /// <tt>std::pair<GR::Edge,C></tt> as its <tt>value_type</tt>, where

  /// \c C is the type of the costs. The pairs indicates the arcs/edges

  /// - It can be a writable arc/edge map with \c bool value type. After

  /// running the algorithm it will contain the found minimum cost spanning

  template <typename Graph, typename In, typename Out>

  Value kruskal(const Graph& g, const In& in, Out& out)

    /// \name Reading Rules

    /// \name Select Section by Name

    /// \name Using Previously Constructed Node or Arc Set

    /// \name Execution of the Reader

    /// \name Reading Rules

    /// \name Select Section by Name

    /// \name Using Previously Constructed Node or Edge Set

    /// \name Execution of the Reader

    /// \name Section Readers

    /// \name Execution of the Reader

    /// \name Node Sections

    /// \name Arc/Edge Sections

    /// \name Attribute Sections

    /// \name Extra Sections

    /// \name Execution of the Contents Reader

    /// \name Writing Rules

    /// \name Section Captions

    /// \name Skipping Section

    /// \name Execution of the Writer

    /// \name Writing Rules

    /// \name Section Captions

    /// \name Skipping Section

    /// \name Execution of the Writer

    /// \name Section Writers

    /// \name Execution of the Writer

      /// = 0. It means that the problem has been successfully solved: either

      /// = 1. Any other case (including the case when some user specified

      ///limit has been exceeded).

      /// No output (default value).

      /// Error messages only.

      /// Warnings.

      /// Normal output.

      /// Verbose output.

    ///\name Build Up and Modify the LP

      /// = 0. Feasible solution hasn't been found (but may exist).

      /// = 1. The problem has no feasible solution.

      /// = 2. Feasible solution found.

      /// = 3. Optimal solution exists and found.

      /// = 4. The cost function is unbounded.

    ///\name Obtain the Solution

      /// = 0. Feasible solution hasn't been found (but may exist).

      /// = 1. The problem has no feasible solution.

      /// = 2. Feasible solution found.

      /// = 3. Optimal solution exists and found.

      /// = 4. The cost function is unbounded.

      ///The Mip or at least the relaxed problem is unbounded.

    ///\name Set Column Type

      /// = 0. Continuous variable (default).

      /// = 1. Integer variable.

    ///\name Obtain the Solution

  /// PotentialDifferenceMap returns the difference between the potentials of

  /// the source and target nodes of each arc in a digraph, i.e. it returns

  /// \brief Minimum Cost Arborescence algorithm class.

  /// Minimum Cost Arborescence algorithm. The arborescence is a tree

    /// \name Named Template Parameters

    /// \name Execution Control

    ///\name Uniform Distributions

    ///\name Non-uniform Distributions

    ///\name Two Dimensional Distributions

    /// \name Execution Control

    ///\name Control the State of the Timer

    ///\name Query Functions for the Ellapsed Time

/// \code

///   dimacs-solver --help

/// \endcode

/// \code

///   dimacs-to-lgf --help

/// \endcode

/// for more info on the usage.

/// \code

///   lgf-gen --help

/// \endcode