lemon-0.x: comparison src/hugo/graph

equal deleted inserted replaced

-:fdfe8cdd15b4
+:ef13459c7f53
 ///
 ///\author Marton Makai
 #include <hugo/invalid.h>
 #include <hugo/maps.h>
+#include <hugo/map_defines.h>
 #include <iostream>
 namespace hugo {
 // Graph wrappers
 ///\warning Graph wrappers are in even more experimental state than the other
 ///parts of the lib. Use them at you own risk.
 ///
 /// This wrapper shows a graph with filtered node-set and
 /// edge-set. Given a bool-valued map on the node-set and one on
-/// the edge-set of the graphs, the iterators shows only the objects
+/// the edge-set of the graphs, the iterators show only the objects
 /// having true value.
 /// The quick brown fox iterators jump over
 /// the lazy dog nodes or edges if their values for are false in the
 /// corresponding bool maps.
 ///
 //    KEEP_MAPS(Parent, UndirGraphWrapper);
 };
-/// \brief An undirected graph template.
+//   /// \brief An undirected graph template.
-///
+//   ///
-///\warning Graph wrappers are in even more experimental state than the other
+//   ///\warning Graph wrappers are in even more experimental state than the other
-///parts of the lib. Use them at your own risk.
+//   ///parts of the lib. Use them at your own risk.
-///
+//   ///
-/// An undirected graph template.
+//   /// An undirected graph template.
-/// This class works as an undirected graph and a directed graph of
+//   /// This class works as an undirected graph and a directed graph of
-/// class \c Graph is used for the physical storage.
+//   /// class \c Graph is used for the physical storage.
-/// \ingroup graphs
+//   /// \ingroup graphs
 template<typename Graph>
 class UndirGraph : public UndirGraphWrapper<Graph> {
 typedef UndirGraphWrapper<Graph> Parent;
 protected:
 Graph gr;
 ///
 ///\warning Graph wrappers are in even more experimental state than the other
 ///parts of the lib. Use them at you own risk.
 ///
 /// Suppose that for a directed graph $G=(V, A)$,
-/// two predicates on the edge-set, $forward_filter$, and $backward_filter$
+/// two bool valued maps on the edge-set,
+/// $forward_filter$, and $backward_filter$
 /// is given, and we are dealing with the directed graph
 /// a $G'=(V, \{uv : uv\in A \mbox{ and } forward_filter(uv) \mbox{ is true}\}+\{vu : uv\in A \mbox{ and } backward_filter(uv) \mbox{ is true}\})$.
 /// The purpose of writing + instead of union is because parallel
 /// edges can arose.
 /// In other words, a subgraph of the bidirected graph obtained, which
 /// forward_filter is everywhere false and the backward_filter is
 /// everywhere true. We note that for sake of efficiency,
 /// \c RevGraphWrapper is implemented in a different way.
 /// But BidirGraphWrapper is obtained from
 /// SubBidirGraphWrapper by considering everywhere true
-/// predicates both forward_filter and backward_filter.
+/// valued maps both for forward_filter and backward_filter.
 /// Finally, one of the most important applications of SubBidirGraphWrapper
 /// is ResGraphWrapper, which stands for the residual graph in directed
 /// flow and circulation problems.
 /// As wrappers usually, the SubBidirGraphWrapper implements the
 /// above mentioned graph structure without its physical storage,
 /// that is the whole stuff eats constant memory.
-/// As the oppositely directed edges are logical different,
+/// As the oppositely directed edges are logically different,
 /// the maps are able to attach different values for them.
 template<typename Graph,
 	   typename ForwardFilterMap, typename BackwardFilterMap>
 class SubBidirGraphWrapper : public GraphWrapper<Graph> {
 public:
 typedef typename GraphWrapper<Graph>::Node Node;
 typedef typename Graph::Edge GraphEdge;
 /// SubBidirGraphWrapper<..., ..., ...>::Edge is inherited from
-/// Graph::Edge. It contains an extra bool flag which shows if the
+/// Graph::Edge. It contains an extra bool flag which is true
+/// if and only if the
 /// edge is the backward version of the original edge.
 class Edge : public Graph::Edge {
 friend class SubBidirGraphWrapper<Graph,
 					ForwardFilterMap, BackwardFilterMap>;
 template<typename T> friend class EdgeMap;
 	flow->set(e, (*flow)[e]-a);
 }
 /// \brief Residual capacity map.
 ///
-/// In generic residual graphs the residual capacity can be obtained as a map. Not tested.
+/// In generic residual graphs the residual capacity can be obtained
+/// as a map.
 class ResCap {
 protected:
 const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>* res_graph;
 public:
 typedef Number ValueType;

changeset 910	5a89cacf17f1
parent 906	17f31d280385
child 911	89a4fbb99cad