View paper

D3126_Overview/tex/overview.tex

@@ -254,6 +254,9 @@ \section{Freestanding}
 Additionally, \tcode{stack} and \tcode{queue} require memory allocation which could throw a \tcode{bad_alloc} 
 exception.
 
+\section{Language Requirements}
+The library targets C++20 as its baseline. The topological sort safe view factories (\tcode{vertices_topological_sort_safe}, \tcode{edges_topological_sort_safe}) use \tcode{std::expected} from C++23. The reference implementation provides backward compatibility to C++20 via an external \tcode{expected} library (e.g., \tcode{tl::expected}), switching to \tcode{std::expected} when C++23 or later is available.
+
 \section{Namespaces}
 Graph containers and their views and algorithms are not interchangeable with existing containers and algorithms.
 Additionally, there are some domain-specific terms that may clash with existing or future names, such as 

D3128_Algorithms/src/bellman_shortest_dists.hpp

@@ -1,18 +1,19 @@
-template <index_adjacency_list G,
-          random_access_range  Distances,
-          class WF      = function<range_value_t<Distances>(const remove_reference_t<G>&,
-                                                            const edge_t<G>&)>,
+template <adjacency_list G,
+          class          Distances,
+          class WF      = function<vertex_property_map_value_t<Distances>(const remove_reference_t<G>&,
+                                                                          const edge_t<G>&)>,
           class Visitor = empty_visitor,
-          class Compare = less<range_value_t<Distances>>,
-          class Combine = plus<range_value_t<Distances>>>
-requires is_arithmetic_v<range_value_t<Distances>> && sized_range<Distances> &&
-         basic_edge_weight_function<G, WF, range_value_t<Distances>, Compare, Combine>
+          class Compare = less<vertex_property_map_value_t<Distances>>,
+          class Combine = plus<vertex_property_map_value_t<Distances>>>
+requires vertex_property_map_for<Distances, G> &&
+         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&
+         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_distances(
       G&&                   g,
       const vertex_id_t<G>& source,
       Distances&            distances,
       WF&&                  weight  = [](const auto&,
-                       const edge_t<G>& uv) { return range_value_t<Distances>(1); },
+                       const edge_t<G>& uv) { return vertex_property_map_value_t<Distances>(1); },
       Visitor&&             visitor = empty_visitor(),
-      Compare&&             compare = less<range_value_t<Distances>>(),
-      Combine&&             combine = plus<range_value_t<Distances>>());
+      Compare&&             compare = less<vertex_property_map_value_t<Distances>>(),
+      Combine&&             combine = plus<vertex_property_map_value_t<Distances>>());

D3128_Algorithms/src/bellman_shortest_dists_multi.hpp

@@ -1,20 +1,21 @@
-template <index_adjacency_list G,
-          input_range          Sources,
-          random_access_range  Distances,
-          class WF      = function<range_value_t<Distances>(const remove_reference_t<G>&,
-                                                            const edge_t<G>&)>,
+template <adjacency_list G,
+          input_range    Sources,
+          class          Distances,
+          class WF      = function<vertex_property_map_value_t<Distances>(const remove_reference_t<G>&,
+                                                                          const edge_t<G>&)>,
           class Visitor = empty_visitor,
-          class Compare = less<range_value_t<Distances>>,
-          class Combine = plus<range_value_t<Distances>>>
-requires convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&
-         is_arithmetic_v<range_value_t<Distances>> && sized_range<Distances> &&
-         basic_edge_weight_function<G, WF, range_value_t<Distances>, Compare, Combine>
+          class Compare = less<vertex_property_map_value_t<Distances>>,
+          class Combine = plus<vertex_property_map_value_t<Distances>>>
+requires vertex_property_map_for<Distances, G> &&
+         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&
+         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&
+         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_distances(
       G&&            g,
       const Sources& sources,
       Distances&     distances,
       WF&&           weight  = [](const auto&,
-                       const edge_t<G>& uv) { return range_value_t<Distances>(1); },
+                       const edge_t<G>& uv) { return vertex_property_map_value_t<Distances>(1); },
       Visitor&&      visitor = empty_visitor(),
-      Compare&&      compare = less<range_value_t<Distances>>(),
-      Combine&&      combine = plus<range_value_t<Distances>>());
+      Compare&&      compare = less<vertex_property_map_value_t<Distances>>(),
+      Combine&&      combine = plus<vertex_property_map_value_t<Distances>>());

D3128_Algorithms/src/bellman_shortest_paths.hpp

@@ -1,22 +1,23 @@
-template <index_adjacency_list G,
-          random_access_range  Distances,
-          random_access_range  Predecessors,
-          class WF      = function<range_value_t<Distances>(const remove_reference_t<G>&,
-                                                            const edge_t<G>&)>,
+template <adjacency_list G,
+          class          Distances,
+          class          Predecessors,
+          class WF      = function<vertex_property_map_value_t<Distances>(const remove_reference_t<G>&,
+                                                                          const edge_t<G>&)>,
           class Visitor = empty_visitor,
-          class Compare = less<range_value_t<Distances>>,
-          class Combine = plus<range_value_t<Distances>>>
-requires is_arithmetic_v<range_value_t<Distances>> &&
-         convertible_to<vertex_id_t<G>, range_value_t<Predecessors>> &&
-         sized_range<Distances> && sized_range<Predecessors> &&
-         basic_edge_weight_function<G, WF, range_value_t<Distances>, Compare, Combine>
+          class Compare = less<vertex_property_map_value_t<Distances>>,
+          class Combine = plus<vertex_property_map_value_t<Distances>>>
+requires vertex_property_map_for<Distances, G> &&
+         vertex_property_map_for<Predecessors, G> &&
+         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&
+         convertible_to<vertex_id_t<G>, vertex_property_map_value_t<Predecessors>> &&
+         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_paths(
       G&&                   g,
       const vertex_id_t<G>& source,
       Distances&            distances,
       Predecessors&         predecessor,
       WF&&                  weight  = [](const auto&,
-                       const edge_t<G>& uv) { return range_value_t<Distances>(1); },
+                       const edge_t<G>& uv) { return vertex_property_map_value_t<Distances>(1); },
       Visitor&&             visitor = empty_visitor(),
-      Compare&&             compare = less<range_value_t<Distances>>(),
-      Combine&&             combine = plus<range_value_t<Distances>>());
+      Compare&&             compare = less<vertex_property_map_value_t<Distances>>(),
+      Combine&&             combine = plus<vertex_property_map_value_t<Distances>>());

D3128_Algorithms/src/bellman_shortest_paths_multi.hpp

@@ -1,24 +1,25 @@
-template <index_adjacency_list G,
-          input_range          Sources,
-          random_access_range  Distances,
-          random_access_range  Predecessors,
-          class WF      = function<range_value_t<Distances>(const remove_reference_t<G>&,
-                                                            const edge_t<G>&)>,
+template <adjacency_list G,
+          input_range    Sources,
+          class          Distances,
+          class          Predecessors,
+          class WF      = function<vertex_property_map_value_t<Distances>(const remove_reference_t<G>&,
+                                                                          const edge_t<G>&)>,
           class Visitor = empty_visitor,
-          class Compare = less<range_value_t<Distances>>,
-          class Combine = plus<range_value_t<Distances>>>
-requires convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&
-         is_arithmetic_v<range_value_t<Distances>> &&
-         convertible_to<vertex_id_t<G>, range_value_t<Predecessors>> &&
-         sized_range<Distances> && sized_range<Predecessors> &&
-         basic_edge_weight_function<G, WF, range_value_t<Distances>, Compare, Combine>
+          class Compare = less<vertex_property_map_value_t<Distances>>,
+          class Combine = plus<vertex_property_map_value_t<Distances>>>
+requires vertex_property_map_for<Distances, G> &&
+         vertex_property_map_for<Predecessors, G> &&
+         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&
+         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&
+         convertible_to<vertex_id_t<G>, vertex_property_map_value_t<Predecessors>> &&
+         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_paths(
       G&&            g,
       const Sources& sources,
       Distances&     distances,
       Predecessors&  predecessor,
       WF&&           weight  = [](const auto&,
-                       const edge_t<G>& uv) { return range_value_t<Distances>(1); },
+                       const edge_t<G>& uv) { return vertex_property_map_value_t<Distances>(1); },
       Visitor&&      visitor = empty_visitor(),
-      Compare&&      compare = less<range_value_t<Distances>>(),
-      Combine&&      combine = plus<range_value_t<Distances>>());
+      Compare&&      compare = less<vertex_property_map_value_t<Distances>>(),
+      Combine&&      combine = plus<vertex_property_map_value_t<Distances>>());

D3128_Algorithms/src/breadth_first_search.hpp

@@ -1,4 +1,4 @@
-template <index_adjacency_list G, class Visitor = empty_visitor>
+template <adjacency_list G, class Visitor = empty_visitor>
 void breadth_first_search(
       G&&            g,            // graph
       vertex_id_t<G> source,       // starting vertex\_id

D3128_Algorithms/src/breadth_first_search_multi.hpp

@@ -1,4 +1,4 @@
-template <index_adjacency_list G, input_range Sources, class Visitor = empty_visitor>
+template <adjacency_list G, input_range Sources, class Visitor = empty_visitor>
 requires convertible_to<range_value_t<Sources>, vertex_id_t<G>>
 void breadth_first_search(G&&            g, // graph
                           const Sources& sources,

D3128_Algorithms/src/connected_components.hpp

@@ -1,36 +1,41 @@
 /*
  * Hopcroft-Tarjan Articulation Points
  */
-template <index_adjacency_list G, class Iter>
+template <adjacency_list G, class Iter>
 requires output_iterator<Iter, vertex_id_t<G>>
 void articulation_points(G&& g, Iter cut_vertices);
 
 /*
  * Hopcroft-Tarjan Biconnected Components
  */
-template <index_adjacency_list G, class OuterContainer>
+template <adjacency_list G, class OuterContainer>
 void biconnected_components(G&& g, OuterContainer& components);
 
 /*
  * Connected Components
  */
-template <index_adjacency_list G, random_access_range Component>
+template <adjacency_list G, class Component>
+requires vertex_property_map_for<Component, G>
 size_t connected_components(G&& g, Component& component);
 
 /*
  * Afforest Connected Components
  */
-template <index_adjacency_list G, random_access_range Component>
+template <adjacency_list G, class Component>
+requires vertex_property_map_for<Component, G>
 void afforest(G&& g, Component& component, const size_t neighbor_rounds = 2);
 
-template <index_adjacency_list G, adjacency_list GT, random_access_range Component>
+template <adjacency_list G, adjacency_list GT, class Component>
+requires vertex_property_map_for<Component, G>
 void afforest(G&& g, GT&& g_t, Component& component, const size_t neighbor_rounds = 2);
 
 /*
  * Kosaraju Strongly Connected Components
  */
-template <index_adjacency_list G, index_adjacency_list GT, random_access_range Component>
+template <adjacency_list G, adjacency_list GT, class Component>
+requires vertex_property_map_for<Component, G>
 void kosaraju(G&& g, GT&& g_t, Component& component);
 
-template <index_bidirectional_adjacency_list G, random_access_range Component>
+template <bidirectional_adjacency_list G, class Component>
+requires vertex_property_map_for<Component, G>
 void kosaraju(G&& g, Component& component);

D3128_Algorithms/src/depth_first_search.hpp

@@ -1,4 +1,4 @@
-template <index_adjacency_list G, class Visitor = empty_visitor>
+template <adjacency_list G, class Visitor = empty_visitor>
 void depth_first_search(
       G&&            g,            // graph
       vertex_id_t<G> source,       // starting vertex\_id

D3128_Algorithms/src/dijkstra_example_mapped.hpp

@@ -0,0 +1,29 @@
+// Example: Dijkstra on a mapped graph (string vertex IDs, double edge weights)
+
+#include <graph/container/dynamic_graph.hpp>
+#include <graph/container/traits/uov_graph_traits.hpp>
+#include <graph/adj_list/vertex_property_map.hpp>
+#include <graph/algorithm/dijkstra_shortest_paths.hpp>
+using namespace graph;
+using namespace graph::adj_list;
+
+using Traits = container::uov_graph_traits<double, void, void, std::string>;
+using G      = container::dynamic_graph<double, void, void, std::string, false, Traits>;
+
+G g({{"a", "b", 4.0}, {"a", "c", 2.0},
+     {"b", "d", 5.0},
+     {"c", "b", 1.0}, {"c", "d", 8.0}});
+
+constexpr double inf = std::numeric_limits<double>::max();
+
+auto dist = make_vertex_property_map<G, double>(g, inf);
+auto pred = make_vertex_property_map<G, vertex_id_t<G>>(g, vertex_id_t<G>{});
+for (auto&& [uid, u] : views::vertexlist(g))
+    pred[uid] = uid;
+
+dijkstra_shortest_paths(g, std::string{"a"}, dist, pred,
+    [](const auto& g, const edge_t<G>& e) { return edge_value(g, e); });
+
+// Shortest a to d: a to c (2) to b (1) to d (5) = 8
+// dist["d"] == 8
+

D3128_Algorithms/src/dijkstra_shortest_dists.hpp

@@ -1,18 +1,19 @@
-template <index_adjacency_list G,
-          random_access_range  Distances,
-          class WF      = function<range_value_t<Distances>(const remove_reference_t<G>&,
-                                                            const edge_t<G>&)>,
+template <adjacency_list G,
+          class          Distances,
+          class WF      = function<vertex_property_map_value_t<Distances>(const remove_reference_t<G>&,
+                                                                          const edge_t<G>&)>,
           class Visitor = empty_visitor,
-          class Compare = less<range_value_t<Distances>>,
-          class Combine = plus<range_value_t<Distances>>>
-requires is_arithmetic_v<range_value_t<Distances>> && sized_range<Distances> &&
-         basic_edge_weight_function<G, WF, range_value_t<Distances>, Compare, Combine>
+          class Compare = less<vertex_property_map_value_t<Distances>>,
+          class Combine = plus<vertex_property_map_value_t<Distances>>>
+requires vertex_property_map_for<Distances, G> &&
+         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&
+         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
 constexpr void dijkstra_shortest_distances(
       G&&                   g,
       const vertex_id_t<G>& source,
       Distances&            distances,
       WF&&                  weight  = [](const auto&,
-                       const edge_t<G>& uv) { return range_value_t<Distances>(1); },
+                       const edge_t<G>& uv) { return vertex_property_map_value_t<Distances>(1); },
       Visitor&&             visitor = empty_visitor(),
-      Compare&&             compare = less<range_value_t<Distances>>(),
-      Combine&&             combine = plus<range_value_t<Distances>>());
+      Compare&&             compare = less<vertex_property_map_value_t<Distances>>(),
+      Combine&&             combine = plus<vertex_property_map_value_t<Distances>>());

D3128_Algorithms/src/dijkstra_shortest_dists_multi.hpp

@@ -1,20 +1,21 @@
-template <index_adjacency_list G,
-          input_range          Sources,
-          random_access_range  Distances,
-          class WF      = function<range_value_t<Distances>(const remove_reference_t<G>&,
-                                                            const edge_t<G>&)>,
+template <adjacency_list G,
+          input_range    Sources,
+          class          Distances,
+          class WF      = function<vertex_property_map_value_t<Distances>(const remove_reference_t<G>&,
+                                                                          const edge_t<G>&)>,
           class Visitor = empty_visitor,
-          class Compare = less<range_value_t<Distances>>,
-          class Combine = plus<range_value_t<Distances>>>
-requires convertible_to<range_value_t<Sources>, vertex_id_t<G>> && sized_range<Distances> &&
-         is_arithmetic_v<range_value_t<Distances>> &&
-         basic_edge_weight_function<G, WF, range_value_t<Distances>, Compare, Combine>
+          class Compare = less<vertex_property_map_value_t<Distances>>,
+          class Combine = plus<vertex_property_map_value_t<Distances>>>
+requires vertex_property_map_for<Distances, G> &&
+         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&
+         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&
+         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
 constexpr void dijkstra_shortest_distances(
       G&&            g,
       const Sources& sources,
       Distances&     distances,
       WF&&           weight  = [](const auto&,
-                       const edge_t<G>& uv) { return range_value_t<Distances>(1); },
+                       const edge_t<G>& uv) { return vertex_property_map_value_t<Distances>(1); },
       Visitor&&      visitor = empty_visitor(),
-      Compare&&      compare = less<range_value_t<Distances>>(),
-      Combine&&      combine = plus<range_value_t<Distances>>());
+      Compare&&      compare = less<vertex_property_map_value_t<Distances>>(),
+      Combine&&      combine = plus<vertex_property_map_value_t<Distances>>());