lemon-main: comparison lemon/maps.h

equal deleted inserted replaced

-:82bfc715d7c7
+:a57b20ae1999
 ///
 /// \sa ConstMap
 template<typename K, typename V>
 class NullMap : public MapBase<K, V> {
 public:
-typedef MapBase<K, V> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef K Key;
-typedef typename Parent::Value Value;
+///\e
+typedef V Value;
 /// Gives back a default constructed element.
 Value operator[](const Key&) const { return Value(); }
 /// Absorbs the value.
 void set(const Key&, const Value&) {}
 template<typename K, typename V>
 class ConstMap : public MapBase<K, V> {
 private:
 V _value;
 public:
-typedef MapBase<K, V> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef K Key;
-typedef typename Parent::Value Value;
+///\e
+typedef V Value;
 /// Default constructor
 /// Default constructor.
 /// The value of the map will be default constructed.
 /// \sa NullMap
 /// \sa IdentityMap
 template<typename K, typename V, V v>
 class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
 public:
-typedef MapBase<K, V> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef K Key;
-typedef typename Parent::Value Value;
+///\e
+typedef V Value;
 /// Constructor.
 ConstMap() {}
 /// Gives back the specified value.
 ///
 /// \sa ConstMap
 template <typename T>
 class IdentityMap : public MapBase<T, T> {
 public:
-typedef MapBase<T, T> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef T Key;
-typedef typename Parent::Value Value;
+///\e
+typedef T Value;
 /// Gives back the given value without any modification.
 Value operator[](const Key &k) const {
 return k;
 }
 typedef std::vector<V> Vector;
 Vector _vector;
 public:
-typedef MapBase<int, V> Parent;
 /// Key type
-typedef typename Parent::Key Key;
+typedef int Key;
 /// Value type
-typedef typename Parent::Value Value;
+typedef V Value;
 /// Reference type
 typedef typename Vector::reference Reference;
 /// Const reference type
 typedef typename Vector::const_reference ConstReference;
 /// However keep in mind that it is usually not as efficient as other
 /// maps.
 ///
 /// The simplest way of using this map is through the sparseMap()
 /// function.
-template <typename K, typename V, typename Compare = std::less<K> >
+template <typename K, typename V, typename Comp = std::less<K> >
 class SparseMap : public MapBase<K, V> {
 template <typename K1, typename V1, typename C1>
 friend class SparseMap;
 public:
-typedef MapBase<K, V> Parent;
 /// Key type
-typedef typename Parent::Key Key;
+typedef K Key;
 /// Value type
-typedef typename Parent::Value Value;
+typedef V Value;
 /// Reference type
 typedef Value& Reference;
 /// Const reference type
 typedef const Value& ConstReference;
 typedef True ReferenceMapTag;
 private:
-typedef std::map<K, V, Compare> Map;
+typedef std::map<K, V, Comp> Map;
 Map _map;
 Value _value;
 public:
 template <typename M1, typename M2>
 class ComposeMap : public MapBase<typename M2::Key, typename M1::Value> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M2::Key, typename M1::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M2::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M1::Value Value;
 /// Constructor
 ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 typename MapTraits<M1>::ConstReturnValue
 operator[](const Key &k) const { return _m1[_m2[k]]; }
 };
 /// Returns a \c ComposeMap class
 class CombineMap : public MapBase<typename M1::Key, V> {
 const M1 &_m1;
 const M2 &_m2;
 F _f;
 public:
-typedef MapBase<typename M1::Key, V> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef V Value;
 /// Constructor
 CombineMap(const M1 &m1, const M2 &m2, const F &f = F())
 : _m1(m1), _m2(m2), _f(f) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
 };
 /// Returns a \c CombineMap class
 typename K = typename F::argument_type,
 typename V = typename F::result_type>
 class FunctorToMap : public MapBase<K, V> {
 F _f;
 public:
-typedef MapBase<K, V> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef K Key;
-typedef typename Parent::Value Value;
+///\e
+typedef V Value;
 /// Constructor
 FunctorToMap(const F &f = F()) : _f(f) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _f(k); }
 };
 /// Returns a \c FunctorToMap class
 ///\sa FunctorToMap
 template <typename M>
 class MapToFunctor : public MapBase<typename M::Key, typename M::Value> {
 const M &_m;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
-typedef typename Parent::Key argument_type;
-typedef typename Parent::Value result_type;
+typedef typename M::Key argument_type;
+typedef typename M::Value result_type;
 /// Constructor
 MapToFunctor(const M &m) : _m(m) {}
-/// \e
+///\e
 Value operator()(const Key &k) const { return _m[k]; }
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m[k]; }
 };
 /// Returns a \c MapToFunctor class
 /// function.
 template <typename M, typename V>
 class ConvertMap : public MapBase<typename M::Key, V> {
 const M &_m;
 public:
-typedef MapBase<typename M::Key, V> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef V Value;
 /// Constructor
 /// Constructor.
 /// \param m The underlying map.
 ConvertMap(const M &m) : _m(m) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m[k]; }
 };
 /// Returns a \c ConvertMap class
 template<typename  M1, typename M2>
 class ForkMap : public MapBase<typename M1::Key, typename M1::Value> {
 M1 &_m1;
 M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M1::Value Value;
 /// Constructor
 ForkMap(M1 &m1, M2 &m2) : _m1(m1), _m2(m2) {}
 /// Returns the value associated with the given key in the first map.
 Value operator[](const Key &k) const { return _m1[k]; }
 template<typename M1, typename M2>
 class AddMap : public MapBase<typename M1::Key, typename M1::Value> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M1::Value Value;
 /// Constructor
 AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
 };
 /// Returns an \c AddMap class
 template<typename M1, typename M2>
 class SubMap : public MapBase<typename M1::Key, typename M1::Value> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M1::Value Value;
 /// Constructor
 SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
 };
 /// Returns a \c SubMap class
 template<typename M1, typename M2>
 class MulMap : public MapBase<typename M1::Key, typename M1::Value> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M1::Value Value;
 /// Constructor
 MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
 };
 /// Returns a \c MulMap class
 template<typename M1, typename M2>
 class DivMap : public MapBase<typename M1::Key, typename M1::Value> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M1::Value Value;
 /// Constructor
 DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
 };
 /// Returns a \c DivMap class
 template<typename M, typename C = typename M::Value>
 class ShiftMap : public MapBase<typename M::Key, typename M::Value> {
 const M &_m;
 C _v;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
 /// Constructor
 /// Constructor.
 /// \param m The undelying map.
 /// \param v The constant value.
 ShiftMap(const M &m, const C &v) : _m(m), _v(v) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m[k]+_v; }
 };
 /// Shifts a map with a constant (read-write version).
 template<typename M, typename C = typename M::Value>
 class ShiftWriteMap : public MapBase<typename M::Key, typename M::Value> {
 M &_m;
 C _v;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
 /// Constructor
 /// Constructor.
 /// \param m The undelying map.
 /// \param v The constant value.
 ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m[k]+_v; }
-/// \e
+///\e
 void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
 };
 /// Returns a \c ShiftMap class
 template<typename M, typename C = typename M::Value>
 class ScaleMap : public MapBase<typename M::Key, typename M::Value> {
 const M &_m;
 C _v;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
 /// Constructor
 /// Constructor.
 /// \param m The undelying map.
 /// \param v The constant value.
 ScaleMap(const M &m, const C &v) : _m(m), _v(v) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _v*_m[k]; }
 };
 /// Scales a map with a constant (read-write version).
 template<typename M, typename C = typename M::Value>
 class ScaleWriteMap : public MapBase<typename M::Key, typename M::Value> {
 M &_m;
 C _v;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
 /// Constructor
 /// Constructor.
 /// \param m The undelying map.
 /// \param v The constant value.
 ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _v*_m[k]; }
-/// \e
+///\e
 void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
 };
 /// Returns a \c ScaleMap class
 /// \sa NegWriteMap
 template<typename M>
 class NegMap : public MapBase<typename M::Key, typename M::Value> {
 const M& _m;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
 /// Constructor
 NegMap(const M &m) : _m(m) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return -_m[k]; }
 };
 /// Negative of a map (read-write version)
 /// \sa NegMap
 template<typename M>
 class NegWriteMap : public MapBase<typename M::Key, typename M::Value> {
 M &_m;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
 /// Constructor
 NegWriteMap(M &m) : _m(m) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return -_m[k]; }
-/// \e
+///\e
 void set(const Key &k, const Value &v) { _m.set(k, -v); }
 };
 /// Returns a \c NegMap class
 /// function.
 template<typename M>
 class AbsMap : public MapBase<typename M::Key, typename M::Value> {
 const M &_m;
 public:
-typedef MapBase<typename M::Key, typename M::Value> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef typename M::Value Value;
 /// Constructor
 AbsMap(const M &m) : _m(m) {}
-/// \e
+///\e
 Value operator[](const Key &k) const {
 Value tmp = _m[k];
 return tmp >= 0 ? tmp : -tmp;
 }
 /// \sa FalseMap
 /// \sa ConstMap
 template <typename K>
 class TrueMap : public MapBase<K, bool> {
 public:
-typedef MapBase<K, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef K Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Gives back \c true.
 Value operator[](const Key&) const { return true; }
 };
 /// \sa TrueMap
 /// \sa ConstMap
 template <typename K>
 class FalseMap : public MapBase<K, bool> {
 public:
-typedef MapBase<K, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef K Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Gives back \c false.
 Value operator[](const Key&) const { return false; }
 };
 template<typename M1, typename M2>
 class AndMap : public MapBase<typename M1::Key, bool> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Constructor
 AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
 };
 /// Returns an \c AndMap class
 template<typename M1, typename M2>
 class OrMap : public MapBase<typename M1::Key, bool> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Constructor
 OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
 };
 /// Returns an \c OrMap class
 /// \sa NotWriteMap
 template <typename M>
 class NotMap : public MapBase<typename M::Key, bool> {
 const M &_m;
 public:
-typedef MapBase<typename M::Key, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Constructor
 NotMap(const M &m) : _m(m) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return !_m[k]; }
 };
 /// Logical 'not' of a map (read-write version)
 /// \sa NotMap
 template <typename M>
 class NotWriteMap : public MapBase<typename M::Key, bool> {
 M &_m;
 public:
-typedef MapBase<typename M::Key, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Constructor
 NotWriteMap(M &m) : _m(m) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return !_m[k]; }
-/// \e
+///\e
 void set(const Key &k, bool v) { _m.set(k, !v); }
 };
 /// Returns a \c NotMap class
 template<typename M1, typename M2>
 class EqualMap : public MapBase<typename M1::Key, bool> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Constructor
 EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
 };
 /// Returns an \c EqualMap class
 template<typename M1, typename M2>
 class LessMap : public MapBase<typename M1::Key, bool> {
 const M1 &_m1;
 const M2 &_m2;
 public:
-typedef MapBase<typename M1::Key, bool> Parent;
+///\e
-typedef typename Parent::Key Key;
+typedef typename M1::Key Key;
-typedef typename Parent::Value Value;
+///\e
+typedef bool Value;
 /// Constructor
 LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-/// \e
+///\e
 Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
 };
 /// Returns an \c LessMap class
 /// easily done with LoggerBoolMap.
 ///
 /// The simplest way of using this map is through the loggerBoolMap()
 /// function.
 ///
-/// \tparam It The type of the iterator.
+/// \tparam IT The type of the iterator.
-/// \tparam Ke The key type of the map. The default value set
+/// \tparam KEY The key type of the map. The default value set
 /// according to the iterator type should work in most cases.
 ///
 /// \note The container of the iterator must contain enough space
 /// for the elements or the iterator should be an inserter iterator.
 #ifdef DOXYGEN
-template <typename It, typename Ke>
+template <typename IT, typename KEY>
 #else
-template <typename It,
+template <typename IT,
-typename Ke=typename _maps_bits::IteratorTraits<It>::Value>
+typename KEY = typename _maps_bits::IteratorTraits<IT>::Value>
 #endif
-class LoggerBoolMap {
+class LoggerBoolMap : public MapBase<KEY, bool> {
 public:
-typedef It Iterator;
+///\e
-typedef Ke Key;
+typedef KEY Key;
+///\e
 typedef bool Value;
+///\e
+typedef IT Iterator;
 /// Constructor
 LoggerBoolMap(Iterator it)
 : _begin(it), _end(it) {}
 /// @}
 /// \addtogroup graph_maps
 /// @{
-/// Provides an immutable and unique id for each item in the graph.
+/// \brief Provides an immutable and unique id for each item in a graph.
+///
-/// The IdMap class provides a unique and immutable id for each item of the
+/// IdMap provides a unique and immutable id for each item of the
-/// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
+/// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
-/// different items (nodes) get different ids <li>\b immutable: the id of an
+///  - \b unique: different items get different ids,
-/// item (node) does not change (even if you delete other nodes).  </ul>
+///  - \b immutable: the id of an item does not change (even if you
-/// Through this map you get access (i.e. can read) the inner id values of
+///    delete other nodes).
-/// the items stored in the graph. This map can be inverted with its member
+///
+/// Using this map you get access (i.e. can read) the inner id values of
+/// the items stored in the graph, which is returned by the \c id()
+/// function of the graph. This map can be inverted with its member
 /// class \c InverseMap or with the \c operator() member.
 ///
-template <typename _Graph, typename _Item>
+/// \tparam GR The graph type.
-class IdMap {
+/// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-public:
+/// \c GR::Edge).
-typedef _Graph Graph;
+///
+/// \see DescriptorMap
+template <typename GR, typename K>
+class IdMap : public MapBase<K, int> {
+public:
+/// The graph type of IdMap.
+typedef GR Graph;
+/// The key type of IdMap (\c Node, \c Arc or \c Edge).
+typedef K Item;
+/// The key type of IdMap (\c Node, \c Arc or \c Edge).
+typedef K Key;
+/// The value type of IdMap.
 typedef int Value;
-typedef _Item Item;
-typedef _Item Key;
 /// \brief Constructor.
 ///
 /// Constructor of the map.
 explicit IdMap(const Graph& graph) : _graph(&graph) {}
 /// \brief Gives back the \e id of the item.
 ///
 /// Gives back the immutable and unique \e id of the item.
 int operator[](const Item& item) const { return _graph->id(item);}
-/// \brief Gives back the item by its id.
+/// \brief Gives back the \e item by its id.
 ///
-/// Gives back the item by its id.
+/// Gives back the \e item by its id.
 Item operator()(int id) { return _graph->fromId(id, Item()); }
 private:
 const Graph* _graph;
 public:
-/// \brief The class represents the inverse of its owner (IdMap).
+/// \brief This class represents the inverse of its owner (IdMap).
 ///
-/// The class represents the inverse of its owner (IdMap).
+/// This class represents the inverse of its owner (IdMap).
 /// \see inverse()
 class InverseMap {
 public:
 /// \brief Constructor.
 explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
 /// \brief Gives back the given item from its id.
 ///
 /// Gives back the given item from its id.
-///
 Item operator[](int id) const { return _graph->fromId(id, Item());}
 private:
 const Graph* _graph;
 };
 /// \brief Gives back the inverse of the map.
 ///
 /// Gives back the inverse of the IdMap.
 InverseMap inverse() const { return InverseMap(*_graph);}
+};
-};
+/// \brief General invertable graph map type.
-/// \brief General invertable graph-map type.
+/// This class provides simple invertable graph maps.
-/// This type provides simple invertable graph-maps.
+/// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
-/// The InvertableMap wraps an arbitrary ReadWriteMap
 /// and if a key is set to a new value then store it
 /// in the inverse map.
 ///
 /// The values of the map can be accessed
 /// with stl compatible forward iterator.
 ///
-/// \tparam _Graph The graph type.
+/// \tparam GR The graph type.
-/// \tparam _Item The item type of the graph.
+/// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-/// \tparam _Value The value type of the map.
+/// \c GR::Edge).
+/// \tparam V The value type of the map.
 ///
 /// \see IterableValueMap
-template <typename _Graph, typename _Item, typename _Value>
+template <typename GR, typename K, typename V>
 class InvertableMap
-: protected ItemSetTraits<_Graph, _Item>::template Map<_Value>::Type {
+: protected ItemSetTraits<GR, K>::template Map<V>::Type {
 private:
-typedef typename ItemSetTraits<_Graph, _Item>::
+typedef typename ItemSetTraits<GR, K>::
-template Map<_Value>::Type Map;
+template Map<V>::Type Map;
-typedef _Graph Graph;
+typedef std::map<V, K> Container;
-typedef std::map<_Value, _Item> Container;
 Container _inv_map;
 public:
-/// The key type of InvertableMap (Node, Arc, Edge).
+/// The graph type of InvertableMap.
-typedef typename Map::Key Key;
+typedef GR Graph;
-/// The value type of the InvertableMap.
+/// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
-typedef typename Map::Value Value;
+typedef K Item;
+/// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
+typedef K Key;
+/// The value type of InvertableMap.
+typedef V Value;
 /// \brief Constructor.
 ///
-/// Construct a new InvertableMap for the graph.
+/// Construct a new InvertableMap for the given graph.
-///
 explicit InvertableMap(const Graph& graph) : Map(graph) {}
 /// \brief Forward iterator for values.
 ///
 /// This iterator is an stl compatible forward
 /// iterator on the values of the map. The values can
-/// be accessed in the [beginValue, endValue) range.
+/// be accessed in the <tt>[beginValue, endValue)</tt> range.
-///
 class ValueIterator
 : public std::iterator<std::forward_iterator_tag, Value> {
 friend class InvertableMap;
 private:
 ValueIterator(typename Container::const_iterator _it)
 /// \brief Returns an iterator to the first value.
 ///
 /// Returns an stl compatible iterator to the
 /// first value of the map. The values of the
-/// map can be accessed in the [beginValue, endValue)
+/// map can be accessed in the <tt>[beginValue, endValue)</tt>
 /// range.
 ValueIterator beginValue() const {
 return ValueIterator(_inv_map.begin());
 }
 /// \brief Returns an iterator after the last value.
 ///
 /// Returns an stl compatible iterator after the
 /// last value of the map. The values of the
-/// map can be accessed in the [beginValue, endValue)
+/// map can be accessed in the <tt>[beginValue, endValue)</tt>
 /// range.
 ValueIterator endValue() const {
 return ValueIterator(_inv_map.end());
 }
-/// \brief The setter function of the map.
+/// \brief Sets the value associated with the given key.
 ///
-/// Sets the mapped value.
+/// Sets the value associated with the given key.
 void set(const Key& key, const Value& val) {
 Value oldval = Map::operator[](key);
 typename Container::iterator it = _inv_map.find(oldval);
 if (it != _inv_map.end() && it->second == key) {
 _inv_map.erase(it);
 }
 _inv_map.insert(make_pair(val, key));
 Map::set(key, val);
 }
-/// \brief The getter function of the map.
+/// \brief Returns the value associated with the given key.
 ///
-/// It gives back the value associated with the key.
+/// Returns the value associated with the given key.
 typename MapTraits<Map>::ConstReturnValue
 operator[](const Key& key) const {
 return Map::operator[](key);
 }
 return it != _inv_map.end() ? it->second : INVALID;
 }
 protected:
-/// \brief Erase the key from the map.
+/// \brief Erase the key from the map and the inverse map.
 ///
-/// Erase the key to the map. It is called by the
+/// Erase the key from the map and the inverse map. It is called by the
 /// \c AlterationNotifier.
 virtual void erase(const Key& key) {
 Value val = Map::operator[](key);
 typename Container::iterator it = _inv_map.find(val);
 if (it != _inv_map.end() && it->second == key) {
 _inv_map.erase(it);
 }
 Map::erase(key);
 }
-/// \brief Erase more keys from the map.
+/// \brief Erase more keys from the map and the inverse map.
 ///
-/// Erase more keys from the map. It is called by the
+/// Erase more keys from the map and the inverse map. It is called by the
 /// \c AlterationNotifier.
 virtual void erase(const std::vector<Key>& keys) {
 for (int i = 0; i < int(keys.size()); ++i) {
 Value val = Map::operator[](keys[i]);
 typename Container::iterator it = _inv_map.find(val);
 }
 }
 Map::erase(keys);
 }
-/// \brief Clear the keys from the map and inverse map.
+/// \brief Clear the keys from the map and the inverse map.
 ///
-/// Clear the keys from the map and inverse map. It is called by the
+/// Clear the keys from the map and the inverse map. It is called by the
 /// \c AlterationNotifier.
 virtual void clear() {
 _inv_map.clear();
 Map::clear();
 }
 public:
 /// \brief The inverse map type.
 ///
 /// The inverse of this map. The subscript operator of the map
-/// gives back always the item what was last assigned to the value.
+/// gives back the item that was last assigned to the value.
 class InverseMap {
 public:
-/// \brief Constructor of the InverseMap.
+/// \brief Constructor
 ///
 /// Constructor of the InverseMap.
 explicit InverseMap(const InvertableMap& inverted)
 : _inverted(inverted) {}
 /// The key type of the InverseMap.
 typedef typename InvertableMap::Value Key;
 /// \brief Subscript operator.
 ///
-/// Subscript operator. It gives back always the item
+/// Subscript operator. It gives back the item
-/// what was last assigned to the value.
+/// that was last assigned to the given value.
 Value operator[](const Key& key) const {
 return _inverted(key);
 }
 private:
 const InvertableMap& _inverted;
 };
-/// \brief It gives back the just readable inverse map.
+/// \brief It gives back the read-only inverse map.
 ///
-/// It gives back the just readable inverse map.
+/// It gives back the read-only inverse map.
 InverseMap inverse() const {
 return InverseMap(*this);
 }
 };
 /// \brief Provides a mutable, continuous and unique descriptor for each
-/// item in the graph.
+/// item in a graph.
 ///
-/// The DescriptorMap class provides a unique and continuous (but mutable)
+/// DescriptorMap provides a unique and continuous (but mutable)
-/// descriptor (id) for each item of the same type (e.g. node) in the
+/// descriptor (id) for each item of the same type (\c Node, \c Arc or
-/// graph. This id is <ul><li>\b unique: different items (nodes) get
+/// \c Edge) in a graph. This id is
-/// different ids <li>\b continuous: the range of the ids is the set of
+///  - \b unique: different items get different ids,
-/// integers between 0 and \c n-1, where \c n is the number of the items of
+///  - \b continuous: the range of the ids is the set of integers
-/// this type (e.g. nodes) (so the id of a node can change if you delete an
+///    between 0 and \c n-1, where \c n is the number of the items of
-/// other node, i.e. this id is mutable).  </ul> This map can be inverted
+///    this type (\c Node, \c Arc or \c Edge). So the id of an item can
-/// with its member class \c InverseMap, or with the \c operator() member.
+///    change if you delete an other item of the same type, i.e. this
-///
+///    id is mutable.
-/// \tparam _Graph The graph class the \c DescriptorMap belongs to.
+///
-/// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or
+/// Thus this id is not (necessarily) the same as what can get using
-/// Edge.
+/// the \c id() function of the graph or \ref IdMap.
-template <typename _Graph, typename _Item>
+/// This map can be inverted with its member class \c InverseMap,
+/// or with the \c operator() member.
+///
+/// \tparam GR The graph type.
+/// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+/// \c GR::Edge).
+///
+/// \see IdMap
+template <typename GR, typename K>
 class DescriptorMap
-: protected ItemSetTraits<_Graph, _Item>::template Map<int>::Type {
+: protected ItemSetTraits<GR, K>::template Map<int>::Type {
-typedef _Item Item;
+typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Map;
-typedef typename ItemSetTraits<_Graph, _Item>::template Map<int>::Type Map;
+public:
-public:
+/// The graph type of DescriptorMap.
-/// The graph class of DescriptorMap.
+typedef GR Graph;
-typedef _Graph Graph;
+/// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
+typedef K Item;
-/// The key type of DescriptorMap (Node, Arc, Edge).
+/// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
-typedef typename Map::Key Key;
+typedef K Key;
 /// The value type of DescriptorMap.
-typedef typename Map::Value Value;
+typedef int Value;
 /// \brief Constructor.
 ///
 /// Constructor for descriptor map.
-explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
+explicit DescriptorMap(const Graph& gr) : Map(gr) {
 Item it;
 const typename Map::Notifier* nf = Map::notifier();
 for (nf->first(it); it != INVALID; nf->next(it)) {
 Map::set(it, _inv_map.size());
 _inv_map.push_back(it);
 }
 }
 protected:
-/// \brief Add a new key to the map.
+/// \brief Adds a new key to the map.
 ///
 /// Add a new key to the map. It is called by the
 /// \c AlterationNotifier.
 virtual void add(const Item& item) {
 Map::add(item);
 typedef std::vector<Item> Container;
 Container _inv_map;
 public:
 /// \brief The inverse map type of DescriptorMap.
 ///
 /// The inverse map type of DescriptorMap.
 class InverseMap {
 public:
-/// \brief Constructor of the InverseMap.
+/// \brief Constructor
 ///
 /// Constructor of the InverseMap.
 explicit InverseMap(const DescriptorMap& inverted)
 : _inverted(inverted) {}
 typedef typename DescriptorMap::Value Key;
 /// \brief Subscript operator.
 ///
 /// Subscript operator. It gives back the item
-/// that the descriptor belongs to currently.
+/// that the descriptor currently belongs to.
 Value operator[](const Key& key) const {
 return _inverted(key);
 }
 /// \brief Size of the map.
 const InverseMap inverse() const {
 return InverseMap(*this);
 }
 };
-/// \brief Returns the source of the given arc.
+/// \brief Map of the source nodes of arcs in a digraph.
 ///
-/// The SourceMap gives back the source Node of the given arc.
+/// SourceMap provides access for the source node of each arc in a digraph,
+/// which is returned by the \c source() function of the digraph.
+/// \tparam GR The digraph type.
 /// \see TargetMap
-template <typename Digraph>
+template <typename GR>
 class SourceMap {
 public:
-typedef typename Digraph::Node Value;
+///\e
-typedef typename Digraph::Arc Key;
+typedef typename GR::Arc Key;
+///\e
+typedef typename GR::Node Value;
 /// \brief Constructor
 ///
-/// Constructor
+/// Constructor.
 /// \param digraph The digraph that the map belongs to.
-explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
+explicit SourceMap(const GR& digraph) : _graph(digraph) {}
-/// \brief The subscript operator.
+/// \brief Returns the source node of the given arc.
 ///
-/// The subscript operator.
+/// Returns the source node of the given arc.
-/// \param arc The arc
-/// \return The source of the arc
 Value operator[](const Key& arc) const {
-return _digraph.source(arc);
+return _graph.source(arc);
 }
 private:
-const Digraph& _digraph;
+const GR& _graph;
 };
 /// \brief Returns a \c SourceMap class.
 ///
 /// This function just returns an \c SourceMap class.
 /// \relates SourceMap
-template <typename Digraph>
+template <typename GR>
-inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
+inline SourceMap<GR> sourceMap(const GR& graph) {
-return SourceMap<Digraph>(digraph);
+return SourceMap<GR>(graph);
 }
-/// \brief Returns the target of the given arc.
+/// \brief Map of the target nodes of arcs in a digraph.
 ///
-/// The TargetMap gives back the target Node of the given arc.
+/// TargetMap provides access for the target node of each arc in a digraph,
+/// which is returned by the \c target() function of the digraph.
+/// \tparam GR The digraph type.
 /// \see SourceMap
-template <typename Digraph>
+template <typename GR>
 class TargetMap {
 public:
-typedef typename Digraph::Node Value;
+///\e
-typedef typename Digraph::Arc Key;
+typedef typename GR::Arc Key;
+///\e
+typedef typename GR::Node Value;
 /// \brief Constructor
 ///
-/// Constructor
+/// Constructor.
 /// \param digraph The digraph that the map belongs to.
-explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
+explicit TargetMap(const GR& digraph) : _graph(digraph) {}
-/// \brief The subscript operator.
+/// \brief Returns the target node of the given arc.
 ///
-/// The subscript operator.
+/// Returns the target node of the given arc.
-/// \param e The arc
-/// \return The target of the arc
 Value operator[](const Key& e) const {
-return _digraph.target(e);
+return _graph.target(e);
 }
 private:
-const Digraph& _digraph;
+const GR& _graph;
 };
 /// \brief Returns a \c TargetMap class.
 ///
 /// This function just returns a \c TargetMap class.
 /// \relates TargetMap
-template <typename Digraph>
+template <typename GR>
-inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
+inline TargetMap<GR> targetMap(const GR& graph) {
-return TargetMap<Digraph>(digraph);
+return TargetMap<GR>(graph);
 }
-/// \brief Returns the "forward" directed arc view of an edge.
+/// \brief Map of the "forward" directed arc view of edges in a graph.
 ///
-/// Returns the "forward" directed arc view of an edge.
+/// ForwardMap provides access for the "forward" directed arc view of
+/// each edge in a graph, which is returned by the \c direct() function
+/// of the graph with \c true parameter.
+/// \tparam GR The graph type.
 /// \see BackwardMap
-template <typename Graph>
+template <typename GR>
 class ForwardMap {
 public:
-typedef typename Graph::Arc Value;
+typedef typename GR::Arc Value;
-typedef typename Graph::Edge Key;
+typedef typename GR::Edge Key;
 /// \brief Constructor
 ///
-/// Constructor
+/// Constructor.
 /// \param graph The graph that the map belongs to.
-explicit ForwardMap(const Graph& graph) : _graph(graph) {}
+explicit ForwardMap(const GR& graph) : _graph(graph) {}
-/// \brief The subscript operator.
+/// \brief Returns the "forward" directed arc view of the given edge.
 ///
-/// The subscript operator.
+/// Returns the "forward" directed arc view of the given edge.
-/// \param key An edge
-/// \return The "forward" directed arc view of edge
 Value operator[](const Key& key) const {
 return _graph.direct(key, true);
 }
 private:
-const Graph& _graph;
+const GR& _graph;
 };
 /// \brief Returns a \c ForwardMap class.
 ///
 /// This function just returns an \c ForwardMap class.
 /// \relates ForwardMap
-template <typename Graph>
+template <typename GR>
-inline ForwardMap<Graph> forwardMap(const Graph& graph) {
+inline ForwardMap<GR> forwardMap(const GR& graph) {
-return ForwardMap<Graph>(graph);
+return ForwardMap<GR>(graph);
 }
-/// \brief Returns the "backward" directed arc view of an edge.
+/// \brief Map of the "backward" directed arc view of edges in a graph.
 ///
-/// Returns the "backward" directed arc view of an edge.
+/// BackwardMap provides access for the "backward" directed arc view of
+/// each edge in a graph, which is returned by the \c direct() function
+/// of the graph with \c false parameter.
+/// \tparam GR The graph type.
 /// \see ForwardMap
-template <typename Graph>
+template <typename GR>
 class BackwardMap {
 public:
-typedef typename Graph::Arc Value;
+typedef typename GR::Arc Value;
-typedef typename Graph::Edge Key;
+typedef typename GR::Edge Key;
 /// \brief Constructor
 ///
-/// Constructor
+/// Constructor.
 /// \param graph The graph that the map belongs to.
-explicit BackwardMap(const Graph& graph) : _graph(graph) {}
+explicit BackwardMap(const GR& graph) : _graph(graph) {}
-/// \brief The subscript operator.
+/// \brief Returns the "backward" directed arc view of the given edge.
 ///
-/// The subscript operator.
+/// Returns the "backward" directed arc view of the given edge.
-/// \param key An edge
-/// \return The "backward" directed arc view of edge
 Value operator[](const Key& key) const {
 return _graph.direct(key, false);
 }
 private:
-const Graph& _graph;
+const GR& _graph;
 };
 /// \brief Returns a \c BackwardMap class
 /// This function just returns a \c BackwardMap class.
 /// \relates BackwardMap
-template <typename Graph>
+template <typename GR>
-inline BackwardMap<Graph> backwardMap(const Graph& graph) {
+inline BackwardMap<GR> backwardMap(const GR& graph) {
-return BackwardMap<Graph>(graph);
+return BackwardMap<GR>(graph);
 }
-/// \brief Potential difference map
+/// \brief Map of the in-degrees of nodes in a digraph.
-///
-/// If there is an potential map on the nodes then we
-/// can get an arc map as we get the substraction of the
-/// values of the target and source.
-template <typename Digraph, typename NodeMap>
-class PotentialDifferenceMap {
-public:
-typedef typename Digraph::Arc Key;
-typedef typename NodeMap::Value Value;
-/// \brief Constructor
-///
-/// Contructor of the map
-explicit PotentialDifferenceMap(const Digraph& digraph,
-const NodeMap& potential)
-: _digraph(digraph), _potential(potential) {}
-/// \brief Const subscription operator
-///
-/// Const subscription operator
-Value operator[](const Key& arc) const {
-return _potential[_digraph.target(arc)] -
-_potential[_digraph.source(arc)];
-}
-private:
-const Digraph& _digraph;
-const NodeMap& _potential;
-};
-/// \brief Returns a PotentialDifferenceMap.
-///
-/// This function just returns a PotentialDifferenceMap.
-/// \relates PotentialDifferenceMap
-template <typename Digraph, typename NodeMap>
-PotentialDifferenceMap<Digraph, NodeMap>
-potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
-return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
-}
-/// \brief Map of the node in-degrees.
 ///
 /// This map returns the in-degree of a node. Once it is constructed,
-/// the degrees are stored in a standard NodeMap, so each query is done
+/// the degrees are stored in a standard \c NodeMap, so each query is done
 /// in constant time. On the other hand, the values are updated automatically
 /// whenever the digraph changes.
 ///
-/// \warning Besides addNode() and addArc(), a digraph structure may provide
+/// \warning Besides \c addNode() and \c addArc(), a digraph structure
-/// alternative ways to modify the digraph. The correct behavior of InDegMap
+/// may provide alternative ways to modify the digraph.
-/// is not guarantied if these additional features are used. For example
+/// The correct behavior of InDegMap is not guarantied if these additional
-/// the functions \ref ListDigraph::changeSource() "changeSource()",
+/// features are used. For example the functions
+/// \ref ListDigraph::changeSource() "changeSource()",
 /// \ref ListDigraph::changeTarget() "changeTarget()" and
 /// \ref ListDigraph::reverseArc() "reverseArc()"
 /// of \ref ListDigraph will \e not update the degree values correctly.
 ///
 /// \sa OutDegMap
+template <typename GR>
-template <typename _Digraph>
 class InDegMap
-: protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
+: protected ItemSetTraits<GR, typename GR::Arc>
 ::ItemNotifier::ObserverBase {
 public:
-typedef _Digraph Digraph;
+/// The digraph type
+typedef GR Digraph;
+/// The key type
+typedef typename Digraph::Node Key;
+/// The value type
 typedef int Value;
-typedef typename Digraph::Node Key;
 typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 ::ItemNotifier::ObserverBase Parent;
 private:
 public:
 /// \brief Constructor.
 ///
-/// Constructor for creating in-degree map.
+/// Constructor for creating an in-degree map.
-explicit InDegMap(const Digraph& digraph)
+explicit InDegMap(const Digraph& graph)
-: _digraph(digraph), _deg(digraph) {
+: _digraph(graph), _deg(graph) {
 Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 _deg[it] = countInArcs(_digraph, it);
 }
 }
+/// \brief Gives back the in-degree of a Node.
+///
 /// Gives back the in-degree of a Node.
 int operator[](const Key& key) const {
 return _deg[key];
 }
 const Digraph& _digraph;
 AutoNodeMap _deg;
 };
-/// \brief Map of the node out-degrees.
+/// \brief Map of the out-degrees of nodes in a digraph.
 ///
 /// This map returns the out-degree of a node. Once it is constructed,
-/// the degrees are stored in a standard NodeMap, so each query is done
+/// the degrees are stored in a standard \c NodeMap, so each query is done
 /// in constant time. On the other hand, the values are updated automatically
 /// whenever the digraph changes.
 ///
-/// \warning Besides addNode() and addArc(), a digraph structure may provide
+/// \warning Besides \c addNode() and \c addArc(), a digraph structure
-/// alternative ways to modify the digraph. The correct behavior of OutDegMap
+/// may provide alternative ways to modify the digraph.
-/// is not guarantied if these additional features are used. For example
+/// The correct behavior of OutDegMap is not guarantied if these additional
-/// the functions \ref ListDigraph::changeSource() "changeSource()",
+/// features are used. For example the functions
+/// \ref ListDigraph::changeSource() "changeSource()",
 /// \ref ListDigraph::changeTarget() "changeTarget()" and
 /// \ref ListDigraph::reverseArc() "reverseArc()"
 /// of \ref ListDigraph will \e not update the degree values correctly.
 ///
 /// \sa InDegMap
+template <typename GR>
-template <typename _Digraph>
 class OutDegMap
-: protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
+: protected ItemSetTraits<GR, typename GR::Arc>
 ::ItemNotifier::ObserverBase {
 public:
-typedef _Digraph Digraph;
+/// The digraph type
+typedef GR Digraph;
+/// The key type
+typedef typename Digraph::Node Key;
+/// The value type
 typedef int Value;
-typedef typename Digraph::Node Key;
 typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
 ::ItemNotifier::ObserverBase Parent;
 private:
 public:
 /// \brief Constructor.
 ///
-/// Constructor for creating out-degree map.
+/// Constructor for creating an out-degree map.
-explicit OutDegMap(const Digraph& digraph)
+explicit OutDegMap(const Digraph& graph)
-: _digraph(digraph), _deg(digraph) {
+: _digraph(graph), _deg(graph) {
 Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 for(typename Digraph::NodeIt it(_digraph); it != INVALID; ++it) {
 _deg[it] = countOutArcs(_digraph, it);
 }
 }
+/// \brief Gives back the out-degree of a Node.
+///
 /// Gives back the out-degree of a Node.
 int operator[](const Key& key) const {
 return _deg[key];
 }
 const Digraph& _digraph;
 AutoNodeMap _deg;
 };
+/// \brief Potential difference map
+///
+/// PotentialMap returns the difference between the potentials of the
+/// source and target nodes of each arc in a digraph, i.e. it returns
+/// \code
+///   potential[gr.target(arc)] - potential[gr.source(arc)].
+/// \endcode
+/// \tparam GR The digraph type.
+/// \tparam POT A node map storing the potentials.
+template <typename GR, typename POT>
+class PotentialDifferenceMap {
+public:
+/// Key type
+typedef typename GR::Arc Key;
+/// Value type
+typedef typename POT::Value Value;
+/// \brief Constructor
+///
+/// Contructor of the map.
+explicit PotentialDifferenceMap(const GR& gr,
+const POT& potential)
+: _digraph(gr), _potential(potential) {}
+/// \brief Returns the potential difference for the given arc.
+///
+/// Returns the potential difference for the given arc, i.e.
+/// \code
+///   potential[gr.target(arc)] - potential[gr.source(arc)].
+/// \endcode
+Value operator[](const Key& arc) const {
+return _potential[_digraph.target(arc)] -
+_potential[_digraph.source(arc)];
+}
+private:
+const GR& _digraph;
+const POT& _potential;
+};
+/// \brief Returns a PotentialDifferenceMap.
+///
+/// This function just returns a PotentialDifferenceMap.
+/// \relates PotentialDifferenceMap
+template <typename GR, typename POT>
+PotentialDifferenceMap<GR, POT>
+potentialDifferenceMap(const GR& gr, const POT& potential) {
+return PotentialDifferenceMap<GR, POT>(gr, potential);
+}
 /// @}
 }
 #endif // LEMON_MAPS_H

changeset 562	538b3dd9a2c0
parent 440	88ed40ad0d4f
child 572	be6646ac5d89