Version 1.36.0
New algorithms and components
diff --git a/doc/is_bipartite.html b/doc/is_bipartite.html
new file mode 100644
index 00000000..f0a5c93e
--- /dev/null
+++ b/doc/is_bipartite.html
@@ -0,0 +1,127 @@
+
+
+
+
+Boost Graph Library: is_bipartite
+
+
+
+
+
+is_bipartite
+
+
+
+// Version with a colormap to retrieve the bipartition
+template <typename Graph, typename IndexMap, typename PartitionMap>
+bool is_bipartite (const Graph& graph, const IndexMap index_map, PartitionMap partition_map)
+
+template <typename Graph, typename IndexMap>
+bool is_bipartite (const Graph& graph, const IndexMap index_map)
+
+// Version which uses the internal index map
+template <typename Graph>
+bool is_bipartite (const Graph& graph);
+
+
+
+The is_bipartite() functions tests a given graph for
+bipartiteness using a DFS-based coloring approach.
+
+
+
+An undirected graph is bipartite if one can partition its set of vertices
+into two sets "left" and "right", such that each edge goes from either side
+to the other. Obviously, a two-coloring of the graph is exactly the same as
+a two-partition. is_bipartite() tests whether such a two-coloring
+is possible and can return it in a given property map.
+
+
+
+The bipartition is recorded in the color map partition_map,
+which will contain a two-coloring of the graph, i.e. an assignment of
+black and white to the vertices such that no edge is monochromatic.
+The predicate whether the graph is bipartite is the return value of the function.
+
+
+Where Defined
+
+
+boost/graph/bipartite.hpp
+
+
+Parameters
+
+
+IN: const Graph& graph
+
+
+An undirected graph. The graph type must be a model of Vertex List Graph and Incidence Graph.
+
+
+
+IN: const IndexMap index_map
+
+
+This maps each vertex to an integer in the range [0,
+num_vertices(graph)). The type VertexIndexMap
+must be a model of Readable Property
+Map. The value type of the map must be an integer type. The
+vertex descriptor type of the graph needs to be usable as the key
+type of the map.
+
+
+
+
+OUT: PartitionMap partition_map
+
+
+The algorithm tests whether the graph is bipartite and assigns each
+vertex either a white or a black color, according to the partition.
+The PartitionMap type must be a model of
+Readable Property
+Map and
+Writable Property
+Map The value type must model ColorValue.
+
+
+
+Complexity
+
+
+The time complexity for the algorithm is O(V + E).
+
+
+See Also
+
+
+find_odd_cycle()
+
+
+Example
+
+
+The file examples/bipartite.cpp
+contains an example of testing an undirected graph for bipartiteness.
+
+
+
+
+
+
+Copyright © 2010 Matthias Walter
+(xammy@xammy.homelinux.net)
+
+
+
+
diff --git a/doc/maximum_matching.html b/doc/maximum_matching.html
index e16c87fb..fa54cb04 100644
--- a/doc/maximum_matching.html
+++ b/doc/maximum_matching.html
@@ -27,7 +27,7 @@ template <typename Graph, typename MateMap, typename VertexIndexMap>
bool checked_edmonds_maximum_cardinality_matching(const Graph& g, MateMap mate, VertexIndexMap vm);
-A matching is a subset of the edges
+A matching is a subset of the edges
of a graph such that no two edges share a common vertex.
Two different matchings in the same graph are illustrated below (edges in the
matching are colored blue.) The matching on the left is a maximal matching,
@@ -38,9 +38,9 @@ over all matchings in the graph.
diff --git a/doc/planar_canonical_ordering.html b/doc/planar_canonical_ordering.html
index c5311d17..035475fd 100644
--- a/doc/planar_canonical_ordering.html
+++ b/doc/planar_canonical_ordering.html
@@ -82,6 +82,16 @@ IN: Graph& g
An undirected graph. The graph type must be a model of
VertexAndEdgeListGraph.
+The graph must:
+
+- Be maximal planar.
+- Have at least two vertices.
+- Have the edge {v0, v1} on its outer face,
+where v0 is *vertices(g).first and
+v1 is the first element of
+adjacent_vertices(v0, g) distinct from
+v0.
+
IN: PlanarEmbedding
diff --git a/doc/planar_graphs.html b/doc/planar_graphs.html
index ad6914b2..47e66fd6 100644
--- a/doc/planar_graphs.html
+++ b/doc/planar_graphs.html
@@ -88,7 +88,7 @@ into the plane separates it into two faces: the region inside the triangle and
the (unbounded) region outside the triangle. The unbounded region outside the
graph's embedding is called the outer face. Every embedding yields
one outer face and zero or more inner faces. A famous result called
-Euler's formula states that for any
+Euler's formula states that for any
planar graph with n vertices, e edges, f faces, and
c connected components,
diff --git a/doc/predecessor_recorder.html b/doc/predecessor_recorder.html
index ab1d4d47..75fe44a6 100644
--- a/doc/predecessor_recorder.html
+++ b/doc/predecessor_recorder.html
@@ -27,7 +27,7 @@ map. This is particularly useful in graph search algorithms where
recording the predecessors is an efficient way to encode the search
tree that was traversed during the search. The predecessor recorder is
typically used with the on_tree_edge or
-on_relax_edge events, and cannot be used with vertex events.
+on_relax_edge events and cannot be used with vertex events.
predecessor_recorder can be used with graph algorithms by
@@ -40,12 +40,12 @@ visitor can be combined with other event visitors using
Algorithms such as Dijkstra's and breadth-first search will not assign
a predecessor to the source vertex (which is the root of the search
-tree). Often times it is useful to initialize the source vertex's
+tree). It is often useful to initialize the source vertex's
predecessor to itself, thereby identifying the root vertex as the only
vertex which is its own parent. When using an algorithm like
-depth-first search that creates a forest (multiple search trees), it
-is useful to intialize the predecessor of every vertex to itself, so
-that all the root nodes can be distinguished.
+depth-first search that creates a forest (multiple search trees) it
+is useful to intialize the predecessor of every vertex to itself. This
+way all the root nodes can be distinguished.
Example
@@ -74,7 +74,7 @@ See the example for bfs_visitor.
| PredecessorMap |
A WritablePropertyMap,
+href="../../property_map/doc/WritablePropertyMap.html">WritablePropertyMap
where the key type and the value type are the vertex descriptor type
of the graph.
|
diff --git a/doc/property_put.html b/doc/property_put.html
new file mode 100644
index 00000000..9f0ebd8a
--- /dev/null
+++ b/doc/property_put.html
@@ -0,0 +1,190 @@
+
+
+
+Boost Graph Library: property_put
+
+
+
+
+
+
+
+property_put<PropertyMap, EventTag>
+
+
+
+This is an EventVisitor that can be
+used to write a fixed value to a property map when a vertex or edge is
+visited at some event-point within an algorithm. For example, this
+visitor can be used as an alternative to a loop to initialize a
+property map, or it can be used to mark only back edges with a
+property.
+
+
+property_put can be used with graph algorithms by
+wrapping it with the algorithm-specific adaptor, such as bfs_visitor and dfs_visitor. Also, this event
+visitor can be combined with other event visitors using
+std::pair to form an EventVisitorList.
+
+
Example
+
+
+ boost::depth_first_search
+ (G, boost::visitor(
+ boost::make_dfs_visitor(
+ boost::put_property(is_back_edge, boost::on_back_edge()))));
+
+
+Model of
+
+EventVisitor
+
+
+Where Defined
+
+
+
+boost/graph/visitors.hpp
+
+
Template Parameters
+
+
+
+
+| Parameter | Description | Default |
+
+
+| PropertyMap |
+
+A WritablePropertyMap,
+where the key_type is the vertex descriptor type or edge
+descriptor of the graph (depending on the kind of event tag).
+ |
+ |
+
+
+| EventTag |
+
+The tag to specify when the property_put should be
+applied during the graph algorithm.
+ |
+ |
+
+
+
+
+Associated Types
+
+
+
+
+| Type | Description |
+
+
+
+| property_put::event_filter |
+
+This will be the same type as the template parameter EventTag.
+ |
+
+
+
+
+Member Functions
+
+
+
+
+
+| Member | Description |
+
+
+
+|
+property_put(PropertyMap pa, property_traits::value_type val);
+ |
+
+Construct a property put object with the property map
+pa and constant value val.
+ |
+
+
+
+
+template <class X, class Graph>
+void operator()(X x, const Graph& g);
+ |
+
+This puts the value val into the property map for the vertex
+or edge x.
+ |
+
+
+
+
+Non-Member Functions
+
+
+
+| Function | Description |
+
+
+
+template <class PropertyMap, class EventTag>
+property_put<PropertyMap, EventTag>
+put_property(PropertyMap pa,
+ typename property_traits::value_type val,
+ EventTag);
+ |
+A convenient way to create a property_put.
+ |
+
+
+
+See Also
+
+Visitor concepts
+
+The following are other event visitors: distance_recorder,
+predecessor_recorder,
+and time_stamper.
+
+
+
+
+
+
+
+
+
+
diff --git a/doc/property_writer.html b/doc/property_writer.html
index 8ce39189..fce17995 100644
--- a/doc/property_writer.html
+++ b/doc/property_writer.html
@@ -27,7 +27,7 @@ within an algorithm.
property_writer can be used with graph algorithms by
-wrapping it with the algorithm specific adaptor, such as bfs_visitor and dfs_visitor. Also, this event
visitor can be combined with other event visitors using
@@ -74,9 +74,9 @@ href="../example/dave.cpp">examples/dave.cpp.
| PropertyMap |
A ReadablePropertyMap,
+href="../../property_map/doc/ReadablePropertyMap.html">ReadablePropertyMap
where the key_type is the vertex descriptor type or edge
-descriptor of the graph (depending on the kind of event tag), and
+descriptor of the graph (depending on the kind of event tag) and
the value_type of the property is convertible
to the value_type of the OutputIterator.
|
@@ -145,7 +145,7 @@ template <class X, class Graph>
void operator()(X x, const Graph& g);
-This writs the property value for x to the output iterator.
+This writes the property value for x to the output iterator.
*out++ = get(pa, x);
|
diff --git a/doc/random_layout.html b/doc/random_layout.html
index 667d8d01..a0ad5324 100644
--- a/doc/random_layout.html
+++ b/doc/random_layout.html
@@ -82,7 +82,7 @@ IN/UTIL: RandomNumberGenerator& gen
A random number generator that will be used to place vertices. The
type RandomNumberGenerator must model the NumberGenerator
+href="../../random/doc/html/boost_random/reference.html#boost_random.reference.concepts.number_generator">NumberGenerator
