First batch of merges from the backlog.

.gitignore

@@ -0,0 +1,8 @@
+cube-fr.dot
+cube.dot
+disconnected-fr.dot
+graphml_test_out.xml
+kevin-bacon2.dat
+random.dot
+triangular-fr.dot
+triangular-kk.dot

doc/grid_graph_export_svg.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/sh
 
 #=======================================================================
 # Copyright 2009 Trustees of Indiana University.
@@ -16,4 +16,4 @@ inkscape --export-png grid_graph_unwrapped.png --export-id g3150 --export-id-onl
 inkscape --export-png grid_graph_wrapped.png grid_graph_unindexed.svg
 
 # Indexed, unwrapped
-inkscape --export-png grid_graph_indexed.png grid_graph_indexed.svg
+inkscape --export-png grid_graph_indexed.png grid_graph_indexed.svg

include/boost/graph/cycle_canceling.hpp

@@ -1,6 +1,6 @@
 //=======================================================================
 // Copyright 2013 University of Warsaw.
-// Authors: Piotr Wygocki 
+// Authors: Piotr Wygocki
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -12,15 +12,14 @@
 // by Ahuja, Magnanti, Orlin.
 
 #ifndef BOOST_GRAPH_CYCLE_CANCELING_HPP
-#define BOOST_GRAPH_CYCLE_CANCELING_HPP 
+#define BOOST_GRAPH_CYCLE_CANCELING_HPP
 
 #include <numeric>
 
 #include <boost/property_map/property_map.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/pending/indirect_cmp.hpp>
-#include <boost/pending/relaxed_heap.hpp>
 #include <boost/graph/bellman_ford_shortest_paths.hpp>
 #include <boost/graph/iteration_macros.hpp>
 #include <boost/graph/detail/augment.hpp>
@@ -32,11 +31,11 @@ namespace boost {
 namespace detail {
 
 template <typename PredEdgeMap, typename Vertex>
-class RecordEdgeMapAndCycleVertex 
+class RecordEdgeMapAndCycleVertex
     : public bellman_visitor<edge_predecessor_recorder<PredEdgeMap, on_edge_relaxed> > {
         typedef edge_predecessor_recorder<PredEdgeMap, on_edge_relaxed> PredRec;
 public:
-    RecordEdgeMapAndCycleVertex(PredEdgeMap pred, Vertex & v) : 
+    RecordEdgeMapAndCycleVertex(PredEdgeMap pred, Vertex & v) :
         bellman_visitor<PredRec>(PredRec(pred)), m_v(v), m_pred(pred) {}
 
     template <typename Graph, typename Edge>
@@ -63,27 +62,27 @@ template <class Graph, class Pred, class Distance, class Reversed, class Residua
 void cycle_canceling(const Graph &g, Weight weight, Reversed rev, ResidualCapacity residual_capacity, Pred pred, Distance distance) {
     typedef filtered_graph<const Graph, is_residual_edge<ResidualCapacity> > ResGraph;
     ResGraph gres = detail::residual_graph(g, residual_capacity);
-    
+
     typedef graph_traits<ResGraph> ResGTraits;
     typedef graph_traits<Graph> GTraits;
     typedef typename ResGTraits::edge_descriptor edge_descriptor;
     typedef typename ResGTraits::vertex_descriptor vertex_descriptor;
-    
+
     typename GTraits::vertices_size_type N = num_vertices(g);
-    
+
     BGL_FORALL_VERTICES_T(v, g, Graph) {
         put(pred, v, edge_descriptor());
         put(distance, v, 0);
     }
 
     vertex_descriptor cycleStart;
-    while(!bellman_ford_shortest_paths(gres, N, 
+    while(!bellman_ford_shortest_paths(gres, N,
             weight_map(weight).
             distance_map(distance).
             visitor(detail::RecordEdgeMapAndCycleVertex<Pred, vertex_descriptor>(pred, cycleStart)))) {
 
         detail::augment(g, cycleStart, cycleStart, pred, residual_capacity, rev);
-        
+
         BGL_FORALL_VERTICES_T(v, g, Graph) {
             put(pred, v, edge_descriptor());
             put(distance, v, 0);
@@ -97,7 +96,7 @@ namespace detail {
 
 template <class Graph, class P, class T, class R, class ResidualCapacity, class Weight, class Reversed, class Pred, class Distance>
 void cycle_canceling_dispatch2(
-        const Graph &g, 
+        const Graph &g,
         Weight weight,
         Reversed rev,
         ResidualCapacity residual_capacity,
@@ -110,7 +109,7 @@ void cycle_canceling_dispatch2(
 //setting default distance map
 template <class Graph, class P, class T, class R, class Pred, class ResidualCapacity, class Weight, class Reversed>
 void cycle_canceling_dispatch2(
-        Graph &g, 
+        Graph &g,
         Weight weight,
         Reversed rev,
         ResidualCapacity residual_capacity,
@@ -121,27 +120,27 @@ void cycle_canceling_dispatch2(
 
     std::vector<D> d_map(num_vertices(g));
 
-    cycle_canceling(g, weight, rev, residual_capacity, pred, 
+    cycle_canceling(g, weight, rev, residual_capacity, pred,
                     make_iterator_property_map(d_map.begin(), choose_const_pmap(get_param(params, vertex_index), g, vertex_index)));
 }
 
 template <class Graph, class P, class T, class R, class ResidualCapacity, class Weight, class Reversed, class Pred>
 void cycle_canceling_dispatch1(
-        Graph &g, 
-        Weight weight, 
+        Graph &g,
+        Weight weight,
         Reversed rev,
         ResidualCapacity residual_capacity,
         Pred pred,
         const bgl_named_params<P, T, R>& params) {
-    cycle_canceling_dispatch2(g, weight, rev,residual_capacity,  pred, 
+    cycle_canceling_dispatch2(g, weight, rev,residual_capacity,  pred,
                                 get_param(params, vertex_distance), params);
 }
 
 //setting default predecessors map
 template <class Graph, class P, class T, class R, class ResidualCapacity, class Weight, class Reversed>
 void cycle_canceling_dispatch1(
-        Graph &g, 
-        Weight weight, 
+        Graph &g,
+        Weight weight,
         Reversed rev,
         ResidualCapacity residual_capacity,
         param_not_found,
@@ -151,20 +150,20 @@ void cycle_canceling_dispatch1(
 
     cycle_canceling_dispatch2(g, weight, rev, residual_capacity,
                               make_iterator_property_map(p_map.begin(), choose_const_pmap(get_param(params, vertex_index), g, vertex_index)),
-                                get_param(params, vertex_distance), params); 
+                                get_param(params, vertex_distance), params);
 }
 
 }//detail
 
 template <class Graph, class  P, class T, class R>
 void cycle_canceling(Graph &g,
         const bgl_named_params<P, T, R>& params) {
-    cycle_canceling_dispatch1(g, 
+    cycle_canceling_dispatch1(g,
            choose_const_pmap(get_param(params, edge_weight), g, edge_weight),
            choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
-           choose_pmap(get_param(params, edge_residual_capacity), 
+           choose_pmap(get_param(params, edge_residual_capacity),
                        g, edge_residual_capacity),
-           get_param(params, vertex_predecessor), 
+           get_param(params, vertex_predecessor),
            params);
 }
 
@@ -178,4 +177,3 @@ void cycle_canceling(Graph &g) {
 }
 
 #endif /* BOOST_GRAPH_CYCLE_CANCELING_HPP */
-

include/boost/graph/detail/adjacency_list.hpp

@@ -267,7 +267,7 @@ namespace boost {
         : Base(static_cast< Base const& >(x)), m_property(const_cast<self&>(x).m_property) { }
       self& operator=(const self& x) {
         // NOTE: avoid 'Base::operator=(x);' broken on SGI MIPSpro (bug 55771 of Mozilla).
-        static_cast<Base&>(*this) = static_cast< Base const& >(x); 
+        static_cast<Base&>(*this) = static_cast< Base const& >(x);
         m_property = const_cast<self&>(x).m_property;
         return *this;
       }
@@ -277,7 +277,7 @@ namespace boost {
         : Base(static_cast< Base&& >(x)), m_property(std::move(x.m_property)) { }
       self& operator=(self&& x) {
         // NOTE: avoid 'Base::operator=(x);' broken on SGI MIPSpro (bug 55771 of Mozilla).
-        static_cast<Base&>(*this) = static_cast< Base&& >(x); 
+        static_cast<Base&>(*this) = static_cast< Base&& >(x);
         m_property = std::move(x.m_property);
         return *this;
       }
@@ -2051,16 +2051,15 @@ namespace boost {
           if ((*ei).get_target() > u)
             --(*ei).get_target();
       }
+
       template <class EdgeList, class vertex_descriptor>
       inline void
       reindex_edge_list(EdgeList& el, vertex_descriptor u,
                         boost::disallow_parallel_edge_tag)
       {
-        typename EdgeList::iterator ei = el.begin(), e_end = el.end();
-        while (ei != e_end) {
-          typename EdgeList::value_type ce = *ei;
-          ++ei;
-          if (ce.get_target() > u) {
+        for(typename EdgeList::iterator ei = el.begin(); ei != el.end(); ++ei) {
+          if (ei->get_target() > u) {
+            typename EdgeList::value_type ce = *ei;
             el.erase(ce);
             --ce.get_target();
             el.insert(ce);

include/boost/graph/dijkstra_shortest_paths.hpp

@@ -22,7 +22,6 @@
 #include <boost/graph/relax.hpp>
 #include <boost/pending/indirect_cmp.hpp>
 #include <boost/graph/exception.hpp>
-#include <boost/pending/relaxed_heap.hpp>
 #include <boost/graph/overloading.hpp>
 #include <boost/smart_ptr.hpp>
 #include <boost/graph/detail/d_ary_heap.hpp>
@@ -53,18 +52,13 @@ namespace boost {
    * @param old_distance  the previous distance to @p vertex
    */
   template<typename Buffer, typename Vertex, typename DistanceType>
-  inline void 
+  inline void
   dijkstra_queue_update(Buffer& Q, Vertex vertex, DistanceType old_distance)
   {
     (void)old_distance;
     Q.update(vertex);
   }
 
-#ifdef BOOST_GRAPH_DIJKSTRA_TESTING
-  // This is a misnomer now: it now just refers to the "default heap", which is
-  // currently d-ary (d=4) but can be changed by a #define.
-  static bool dijkstra_relaxed_heap = true;
-#endif
 
   template <class Visitor, class Graph>
   struct DijkstraVisitorConcept {
@@ -187,7 +181,7 @@ namespace boost {
         // The test here is equivalent to e_weight < 0 if m_combine has a
         // cancellation law, but always returns false when m_combine is a
         // projection operator.
-        if (m_compare(m_combine(m_zero, get(m_weight, e)), m_zero)) 
+        if (m_compare(m_combine(m_zero, get(m_weight, e)), m_zero))
             boost::throw_exception(negative_edge());
         // End of test for negative-weight edges.
 
@@ -345,25 +339,7 @@ namespace boost {
 
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
-#ifdef BOOST_GRAPH_DIJKSTRA_TESTING
-    if (!dijkstra_relaxed_heap) {
-      typedef mutable_queue<Vertex, std::vector<Vertex>, IndirectCmp, IndexMap>
-        MutableQueue;
-
-      MutableQueue Q(num_vertices(g), icmp, index_map);
-      detail::dijkstra_bfs_visitor<DijkstraVisitor, MutableQueue, WeightMap,
-        PredecessorMap, DistanceMap, Combine, Compare>
-      bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero);
-
-      breadth_first_visit(g, s_begin, s_end, Q, bfs_vis, color);
-      return;
-    }
-#endif // BOOST_GRAPH_DIJKSTRA_TESTING
-
-#ifdef BOOST_GRAPH_DIJKSTRA_USE_RELAXED_HEAP
-    typedef relaxed_heap<Vertex, IndirectCmp, IndexMap> MutableQueue;
-    MutableQueue Q(num_vertices(g), icmp, index_map);
-#else // Now the default: use a d-ary heap
+    // Now the default: use a d-ary heap
       boost::scoped_array<std::size_t> index_in_heap_map_holder;
       typedef
         detail::vertex_property_map_generator<Graph, IndexMap, std::size_t>
@@ -374,7 +350,6 @@ namespace boost {
       typedef d_ary_heap_indirect<Vertex, 4, IndexInHeapMap, DistanceMap, Compare>
         MutableQueue;
       MutableQueue Q(distance, index_in_heap, compare);
-#endif // Relaxed heap
 
     detail::dijkstra_bfs_visitor<DijkstraVisitor, MutableQueue, WeightMap,
       PredecessorMap, DistanceMap, Combine, Compare>
@@ -406,7 +381,7 @@ namespace boost {
   template <class VertexListGraph, class SourceInputIter, class DijkstraVisitor,
             class PredecessorMap, class DistanceMap,
             class WeightMap, class IndexMap, class Compare, class Combine,
-            class DistInf, class DistZero, typename T, typename Tag, 
+            class DistInf, class DistZero, typename T, typename Tag,
             typename Base>
   inline void
   dijkstra_shortest_paths
@@ -429,7 +404,7 @@ namespace boost {
   template <class VertexListGraph, class DijkstraVisitor,
             class PredecessorMap, class DistanceMap,
             class WeightMap, class IndexMap, class Compare, class Combine,
-            class DistInf, class DistZero, typename T, typename Tag, 
+            class DistInf, class DistZero, typename T, typename Tag,
             typename Base>
   inline void
   dijkstra_shortest_paths