RhodeCode

	lemon/glpk.h \

	lemon/gomory_hu.h \

	lemon/graph_to_eps.h \

	lemon/grid_graph.h \

	lemon/hypercube_graph.h \

	lemon/kruskal.h \

	lemon/hao_orlin.h \

	lemon/lgf_reader.h \

	lemon/maps.h \

	lemon/matching.h \

	lemon/math.h \

	lemon/min_cost_arborescence.h \

	lemon/nauty_reader.h \

	lemon/network_simplex.h \

	lemon/path.h \

	lemon/preflow.h \

 * purpose.

 *

 */

/// \ingroup shortest_path

///

/// \file

#include <lemon/connectivity.h>

namespace lemon {

  ///

  /// \tparam GR The type of the digraph.

  /// \tparam LEN The type of the length map.

  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.

#ifdef DOXYGEN

#else

  template <typename GR, typename LEN,

    bool integer = std::numeric_limits<typename LEN::Value>::is_integer>

#endif

  {

    /// The type of the digraph

    typedef GR Digraph;

    /// The type of the length map

  };

  // Default traits class for integer value types

  template <typename GR, typename LEN>

  {

    typedef GR Digraph;

    typedef LEN LengthMap;

    typedef typename LengthMap::Value Value;

  /// \brief Implementation of Howard's algorithm for finding a minimum

  /// mean cycle.

  ///

  ///

  /// \tparam GR The type of the digraph the algorithm runs on.

  /// \tparam LEN The type of the length map. The default

  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".

  template <typename GR, typename LEN, typename TR>

#else

  template < typename GR,

             typename LEN = typename GR::template ArcMap<int>,

#endif

  {

  public:

    /// The type of the digraph

    /// \brief The large value type

    ///

    /// The large value type used for internal computations.

    /// it is \c long \c long if the \c Value type is integer,

    /// otherwise it is \c double.

    typedef typename TR::LargeValue LargeValue;

    /// \brief The path type of the found cycles

    ///

    /// The path type of the found cycles.

    /// it is \ref lemon::Path "Path<Digraph>".

    typedef typename TR::Path Path;

    typedef TR Traits;

  private:

    /// \ref named-templ-param "Named parameter" for setting \c LargeValue

    /// type. It is used for internal computations in the algorithm.

    template <typename T>

    struct SetLargeValue

    };

    template <typename T>

    struct SetPathTraits : public Traits {

    /// It must conform to the \ref lemon::concepts::Path "Path" concept

    /// and it must have an \c addBack() function.

    template <typename T>

    struct SetPath

    };

    /// @}

    /// The constructor of the class.

    ///

    /// \param digraph The digraph the algorithm runs on.

    /// \param length The lengths (costs) of the arcs.

      _gr(digraph), _length(length), _cycle_path(NULL), _local_path(false),

      _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph),

      _comp(digraph), _in_arcs(digraph)

    {}

    /// Destructor.

      if (_local_path) delete _cycle_path;

    }

    /// \brief Set the path structure for storing the found cycle.

    /// \note The algorithm calls only the \ref lemon::Path::addBack()

    /// "addBack()" function of the given path structure.

    ///

    /// \return <tt>(*this)</tt>

      if (_local_path) {

        delete _cycle_path;

        _local_path = false;

      }

      }

      return improved;

    }

  ///@}

} //namespace lemon

#include <sstream>

#include <lemon/smart_graph.h>

#include <lemon/lgf_reader.h>

#include <lemon/path.h>

#include <lemon/concepts/digraph.h>

#include <lemon/concept_check.h>

  // Check the interface

  {

    typedef concepts::Digraph GR;

    checkConcept<MmcClassConcept<GR, int>, IntMmcAlg>();

    checkConcept<MmcClassConcept<GR, float>, FloatMmcAlg>();

      arcMap("c3", c3).

      arcMap("c4", c4).

      run();

  }

  return 0;

}