[Lemon-commits] Alpar Juttner: Merge
Lemon HG
hg at lemon.cs.elte.hu
Mon Dec 1 15:32:25 CET 2008
details: http://lemon.cs.elte.hu/hg/lemon/rev/59d3aa4f921f
changeset: 419:59d3aa4f921f
user: Alpar Juttner <alpar [at] cs.elte.hu>
date: Mon Dec 01 14:18:40 2008 +0000
description:
Merge
diffstat:
4 files changed, 914 insertions(+)
lemon/Makefile.am | 1
lemon/circulation.h | 755 ++++++++++++++++++++++++++++++++++++++++++++++
test/Makefile.am | 2
test/circulation_test.cc | 156 +++++++++
diffs (truncated from 949 to 300 lines):
diff -r 532f34ea9cf3 -r 59d3aa4f921f lemon/Makefile.am
--- a/lemon/Makefile.am Mon Dec 01 13:49:55 2008 +0000
+++ b/lemon/Makefile.am Mon Dec 01 14:18:40 2008 +0000
@@ -20,6 +20,7 @@
lemon/assert.h \
lemon/bfs.h \
lemon/bin_heap.h \
+ lemon/circulation.h \
lemon/color.h \
lemon/concept_check.h \
lemon/counter.h \
diff -r 532f34ea9cf3 -r 59d3aa4f921f lemon/circulation.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lemon/circulation.h Mon Dec 01 14:18:40 2008 +0000
@@ -0,0 +1,755 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2008
+ * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+#ifndef LEMON_CIRCULATION_H
+#define LEMON_CIRCULATION_H
+
+#include <lemon/tolerance.h>
+#include <lemon/elevator.h>
+
+///\ingroup max_flow
+///\file
+///\brief Push-relabel algorithm for finding a feasible circulation.
+///
+namespace lemon {
+
+ /// \brief Default traits class of Circulation class.
+ ///
+ /// Default traits class of Circulation class.
+ /// \tparam _Diraph Digraph type.
+ /// \tparam _LCapMap Lower bound capacity map type.
+ /// \tparam _UCapMap Upper bound capacity map type.
+ /// \tparam _DeltaMap Delta map type.
+ template <typename _Diraph, typename _LCapMap,
+ typename _UCapMap, typename _DeltaMap>
+ struct CirculationDefaultTraits {
+
+ /// \brief The type of the digraph the algorithm runs on.
+ typedef _Diraph Digraph;
+
+ /// \brief The type of the map that stores the circulation lower
+ /// bound.
+ ///
+ /// The type of the map that stores the circulation lower bound.
+ /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
+ typedef _LCapMap LCapMap;
+
+ /// \brief The type of the map that stores the circulation upper
+ /// bound.
+ ///
+ /// The type of the map that stores the circulation upper bound.
+ /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
+ typedef _UCapMap UCapMap;
+
+ /// \brief The type of the map that stores the lower bound for
+ /// the supply of the nodes.
+ ///
+ /// The type of the map that stores the lower bound for the supply
+ /// of the nodes. It must meet the \ref concepts::ReadMap "ReadMap"
+ /// concept.
+ typedef _DeltaMap DeltaMap;
+
+ /// \brief The type of the flow values.
+ typedef typename DeltaMap::Value Value;
+
+ /// \brief The type of the map that stores the flow values.
+ ///
+ /// The type of the map that stores the flow values.
+ /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+ typedef typename Digraph::template ArcMap<Value> FlowMap;
+
+ /// \brief Instantiates a FlowMap.
+ ///
+ /// This function instantiates a \ref FlowMap.
+ /// \param digraph The digraph, to which we would like to define
+ /// the flow map.
+ static FlowMap* createFlowMap(const Digraph& digraph) {
+ return new FlowMap(digraph);
+ }
+
+ /// \brief The elevator type used by the algorithm.
+ ///
+ /// The elevator type used by the algorithm.
+ ///
+ /// \sa Elevator
+ /// \sa LinkedElevator
+ typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
+
+ /// \brief Instantiates an Elevator.
+ ///
+ /// This function instantiates an \ref Elevator.
+ /// \param digraph The digraph, to which we would like to define
+ /// the elevator.
+ /// \param max_level The maximum level of the elevator.
+ static Elevator* createElevator(const Digraph& digraph, int max_level) {
+ return new Elevator(digraph, max_level);
+ }
+
+ /// \brief The tolerance used by the algorithm
+ ///
+ /// The tolerance used by the algorithm to handle inexact computation.
+ typedef lemon::Tolerance<Value> Tolerance;
+
+ };
+
+ /**
+ \brief Push-relabel algorithm for the network circulation problem.
+
+ \ingroup max_flow
+ This class implements a push-relabel algorithm for the network
+ circulation problem.
+ It is to find a feasible circulation when lower and upper bounds
+ are given for the flow values on the arcs and lower bounds
+ are given for the supply values of the nodes.
+
+ The exact formulation of this problem is the following.
+ Let \f$G=(V,A)\f$ be a digraph,
+ \f$lower, upper: A\rightarrow\mathbf{R}^+_0\f$,
+ \f$delta: V\rightarrow\mathbf{R}\f$. Find a feasible circulation
+ \f$f: A\rightarrow\mathbf{R}^+_0\f$ so that
+ \f[ \sum_{a\in\delta_{out}(v)} f(a) - \sum_{a\in\delta_{in}(v)} f(a)
+ \geq delta(v) \quad \forall v\in V, \f]
+ \f[ lower(a)\leq f(a) \leq upper(a) \quad \forall a\in A. \f]
+ \note \f$delta(v)\f$ specifies a lower bound for the supply of node
+ \f$v\f$. It can be either positive or negative, however note that
+ \f$\sum_{v\in V}delta(v)\f$ should be zero or negative in order to
+ have a feasible solution.
+
+ \note A special case of this problem is when
+ \f$\sum_{v\in V}delta(v) = 0\f$. Then the supply of each node \f$v\f$
+ will be \e equal \e to \f$delta(v)\f$, if a circulation can be found.
+ Thus a feasible solution for the
+ \ref min_cost_flow "minimum cost flow" problem can be calculated
+ in this way.
+
+ \tparam _Digraph The type of the digraph the algorithm runs on.
+ \tparam _LCapMap The type of the lower bound capacity map. The default
+ map type is \ref concepts::Digraph::ArcMap "_Digraph::ArcMap<int>".
+ \tparam _UCapMap The type of the upper bound capacity map. The default
+ map type is \c _LCapMap.
+ \tparam _DeltaMap The type of the map that stores the lower bound
+ for the supply of the nodes. The default map type is
+ \c _Digraph::ArcMap<_UCapMap::Value>.
+ */
+#ifdef DOXYGEN
+template< typename _Digraph,
+ typename _LCapMap,
+ typename _UCapMap,
+ typename _DeltaMap,
+ typename _Traits >
+#else
+template< typename _Digraph,
+ typename _LCapMap = typename _Digraph::template ArcMap<int>,
+ typename _UCapMap = _LCapMap,
+ typename _DeltaMap = typename _Digraph::
+ template NodeMap<typename _UCapMap::Value>,
+ typename _Traits=CirculationDefaultTraits<_Digraph, _LCapMap,
+ _UCapMap, _DeltaMap> >
+#endif
+ class Circulation {
+ public:
+
+ ///The \ref CirculationDefaultTraits "traits class" of the algorithm.
+ typedef _Traits Traits;
+ ///The type of the digraph the algorithm runs on.
+ typedef typename Traits::Digraph Digraph;
+ ///The type of the flow values.
+ typedef typename Traits::Value Value;
+
+ /// The type of the lower bound capacity map.
+ typedef typename Traits::LCapMap LCapMap;
+ /// The type of the upper bound capacity map.
+ typedef typename Traits::UCapMap UCapMap;
+ /// \brief The type of the map that stores the lower bound for
+ /// the supply of the nodes.
+ typedef typename Traits::DeltaMap DeltaMap;
+ ///The type of the flow map.
+ typedef typename Traits::FlowMap FlowMap;
+
+ ///The type of the elevator.
+ typedef typename Traits::Elevator Elevator;
+ ///The type of the tolerance.
+ typedef typename Traits::Tolerance Tolerance;
+
+ private:
+
+ TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+
+ const Digraph &_g;
+ int _node_num;
+
+ const LCapMap *_lo;
+ const UCapMap *_up;
+ const DeltaMap *_delta;
+
+ FlowMap *_flow;
+ bool _local_flow;
+
+ Elevator* _level;
+ bool _local_level;
+
+ typedef typename Digraph::template NodeMap<Value> ExcessMap;
+ ExcessMap* _excess;
+
+ Tolerance _tol;
+ int _el;
+
+ public:
+
+ typedef Circulation Create;
+
+ ///\name Named Template Parameters
+
+ ///@{
+
+ template <typename _FlowMap>
+ struct SetFlowMapTraits : public Traits {
+ typedef _FlowMap FlowMap;
+ static FlowMap *createFlowMap(const Digraph&) {
+ LEMON_ASSERT(false, "FlowMap is not initialized");
+ return 0; // ignore warnings
+ }
+ };
+
+ /// \brief \ref named-templ-param "Named parameter" for setting
+ /// FlowMap type
+ ///
+ /// \ref named-templ-param "Named parameter" for setting FlowMap
+ /// type.
+ template <typename _FlowMap>
+ struct SetFlowMap
+ : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
+ SetFlowMapTraits<_FlowMap> > {
+ typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
+ SetFlowMapTraits<_FlowMap> > Create;
+ };
+
+ template <typename _Elevator>
+ struct SetElevatorTraits : public Traits {
+ typedef _Elevator Elevator;
+ static Elevator *createElevator(const Digraph&, int) {
+ LEMON_ASSERT(false, "Elevator is not initialized");
+ return 0; // ignore warnings
+ }
+ };
+
+ /// \brief \ref named-templ-param "Named parameter" for setting
+ /// Elevator type
+ ///
+ /// \ref named-templ-param "Named parameter" for setting Elevator
+ /// type. If this named parameter is used, then an external
+ /// elevator object must be passed to the algorithm using the
+ /// \ref elevator(Elevator&) "elevator()" function before calling
+ /// \ref run() or \ref init().
+ /// \sa SetStandardElevator
+ template <typename _Elevator>
+ struct SetElevator
+ : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
+ SetElevatorTraits<_Elevator> > {
+ typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
+ SetElevatorTraits<_Elevator> > Create;
+ };
+
+ template <typename _Elevator>
+ struct SetStandardElevatorTraits : public Traits {
+ typedef _Elevator Elevator;
+ static Elevator *createElevator(const Digraph& digraph, int max_level) {
+ return new Elevator(digraph, max_level);
+ }
+ };
+
+ /// \brief \ref named-templ-param "Named parameter" for setting
+ /// Elevator type with automatic allocation
+ ///
+ /// \ref named-templ-param "Named parameter" for setting Elevator
+ /// type with automatic allocation.
+ /// The Elevator should have standard constructor interface to be
+ /// able to automatically created by the algorithm (i.e. the
+ /// digraph and the maximum level should be passed to it).
+ /// However an external elevator object could also be passed to the
+ /// algorithm with the \ref elevator(Elevator&) "elevator()" function
More information about the Lemon-commits
mailing list