refactor nb_vertices into num_vertices

Makefile

@@ -1,5 +1,5 @@
-CONAN_PROFILE = clang
-# CONAN_PROFILE = default
+# CONAN_PROFILE = clang
+CONAN_PROFILE = default
 # CONAN_PROFILE = debug
 
 .PHONY: build package clean

include/melon/algorithm/breadth_first_search.hpp

@@ -34,7 +34,7 @@ class breadth_first_search {
  "storing predecessor arcs requires outward_incidence_graph.");
 
  using cursor =
- std::conditional_t<has_nb_vertices<_Graph>,
+ std::conditional_t<has_num_vertices<_Graph>,
  typename std::vector<vertex>::iterator, int>;
 
 private:
@@ -60,8 +60,8 @@ class breadth_first_search {
  , _pred_vertices_map(_graph)
  , _pred_arcs_map(_graph)
  , _dist_map(_graph) {
- if constexpr(has_nb_vertices<_Graph>) {
- _queue.reserve(nb_vertices(_graph));
+ if constexpr(has_num_vertices<_Graph>) {
+ _queue.reserve(num_vertices(_graph));
  _queue_current = _queue.begin();
  } else {
  _queue_current = 0;
@@ -86,7 +86,7 @@ class breadth_first_search {
 
  constexpr breadth_first_search & reset() noexcept {
  _queue.resize(0);
- if constexpr(has_nb_vertices<_Graph>) {
+ if constexpr(has_num_vertices<_Graph>) {
  _queue_current = _queue.begin();
  } else {
  _queue_current = 0;
@@ -104,7 +104,7 @@ class breadth_first_search {
  }
 
  [[nodiscard]] constexpr bool finished() const noexcept {
- if constexpr(has_nb_vertices<_Graph>) {
+ if constexpr(has_num_vertices<_Graph>) {
  return _queue_current == _queue.end();
  } else {
  return _queue_current == _queue.size();
@@ -113,7 +113,7 @@ class breadth_first_search {
 
  [[nodiscard]] constexpr const vertex & current() const noexcept {
  assert(!finished());
- if constexpr(has_nb_vertices<_Graph>) {
+ if constexpr(has_num_vertices<_Graph>) {
  return *_queue_current;
  } else {
  return _queue[_queue_current];

include/melon/algorithm/depth_first_search.hpp

@@ -61,8 +61,8 @@ class depth_first_search {
  , _pred_vertices_map(_graph)
  , _pred_arcs_map(_graph)
  , _dist_map(_graph) {
- if constexpr(has_nb_vertices<_Graph>) {
- _stack.reserve(nb_vertices(_graph));
+ if constexpr(has_num_vertices<_Graph>) {
+ _stack.reserve(num_vertices(_graph));
  }
  }
 

include/melon/algorithm/dinitz.hpp

@@ -49,8 +49,8 @@ class dinitz {
  , _remaining_in_arcs(
  create_vertex_map<consumable_range<in_arcs_range_t<_Graph>>>(
  _graph)) {
- if constexpr(has_nb_vertices<_Graph>) {
- _bfs_queue.reserve(nb_vertices(_graph));
+ if constexpr(has_num_vertices<_Graph>) {
+ _bfs_queue.reserve(num_vertices(_graph));
  }
  reset();
  }

include/melon/algorithm/edmonds_karp.hpp

@@ -41,8 +41,8 @@ class edmonds_karp {
  , _carried_flow_map(create_arc_map<value_t>(_graph))
  , _bfs_reached_map(create_vertex_map<bool>(_graph))
  , _bfs_pred_arc(create_vertex_map<arc>(_graph)) {
- if constexpr(has_nb_vertices<_Graph>) {
- _bfs_queue.reserve(nb_vertices(_graph));
+ if constexpr(has_num_vertices<_Graph>) {
+ _bfs_queue.reserve(num_vertices(_graph));
  }
  reset();
  }

include/melon/algorithm/strongly_connected_components.hpp

@@ -63,9 +63,9 @@ class strongly_connected_components {
  create_vertex_map<component_num>(_graph, INVALID_COMPONENT))
  , _lowlink_map(
  create_vertex_map<component_num>(_graph, INVALID_COMPONENT)) {
- if constexpr(has_nb_vertices<_Graph>) {
- _dfs_stack.reserve(nb_vertices(_graph));
- _tarjan_stack.reserve(nb_vertices(_graph));
+ if constexpr(has_num_vertices<_Graph>) {
+ _dfs_stack.reserve(num_vertices(_graph));
+ _tarjan_stack.reserve(num_vertices(_graph));
  }
  advance();
  }

include/melon/algorithm/topological_sort.hpp

@@ -90,7 +90,7 @@ class topological_sort {
  , _pred_vertices_map(_graph)
  , _pred_arcs_map(_graph)
  , _dist_map(_graph) {
- _queue.reserve(nb_vertices(g));
+ _queue.reserve(num_vertices(g));
  push_start_vertices();
  }
 

include/melon/container/mutable_digraph.hpp

@@ -44,16 +44,16 @@ class mutable_digraph {
  vertex _first_vertex;
  vertex _first_free_vertex;
  arc _first_free_arc;
- std::size_t _nb_vertices;
- std::size_t _nb_arcs;
+ std::size_t _num_vertices;
+ std::size_t _num_arcs;
 
 public:
  [[nodiscard]] constexpr mutable_digraph() noexcept
  : _first_vertex(INVALID_VERTEX)
  , _first_free_vertex(INVALID_VERTEX)
  , _first_free_arc(INVALID_ARC)
- , _nb_vertices(0)
- , _nb_arcs(0){};
+ , _num_vertices(0)
+ , _num_arcs(0){};
  [[nodiscard]] constexpr mutable_digraph(const mutable_digraph & graph) =
  default;
  [[nodiscard]] constexpr mutable_digraph(mutable_digraph && graph) = default;
@@ -70,10 +70,10 @@ class mutable_digraph {
  if(a >= _arcs.size()) return false;
  return _arcs_filter[a];
  }
- [[nodiscard]] constexpr auto nb_vertices() const noexcept {
- return _nb_vertices;
+ [[nodiscard]] constexpr auto num_vertices() const noexcept {
+ return _num_vertices;
  }
- [[nodiscard]] constexpr auto nb_arcs() const noexcept { return _nb_arcs; }
+ [[nodiscard]] constexpr auto num_arcs() const noexcept { return _num_arcs; }
 
  [[nodiscard]] constexpr auto vertices() const noexcept {
  return intrusive_view(
@@ -155,7 +155,7 @@ class mutable_digraph {
  _vertices[_first_vertex].prev_vertex = new_vertex;
  }
  _first_vertex = new_vertex;
- ++_nb_vertices;
+ ++_num_vertices;
  return new_vertex;
  }
 
@@ -183,7 +183,7 @@ class mutable_digraph {
  if(froms.first_out_arc != INVALID_ARC)
  _arcs[froms.first_out_arc].prev_out_arc = new_arc;
  froms.first_out_arc = new_arc;
- ++_nb_arcs;
+ ++_num_arcs;
  return new_arc;
  }
 
@@ -216,7 +216,7 @@ class mutable_digraph {
  last_in_arc = a;
  remove_from_source_out_arcs(a);
  _arcs_filter[a] = false;
- --_nb_arcs;
+ --_num_arcs;
  }
  arc last_out_arc = INVALID_ARC;
  for(const arc & a : out_arcs(v)) {
@@ -225,7 +225,7 @@ class mutable_digraph {
  // once removed from the targets in arcs .next_in_arc is free
  _arcs[a].next_in_arc = _arcs[a].next_out_arc;
  _arcs_filter[a] = false;
- --_nb_arcs;
+ --_num_arcs;
  }
  // out_arcs were linked by .next_out_arc
  // [first_out_arc, last_out_arc] are now linked by .next_in_arc
@@ -255,7 +255,7 @@ class mutable_digraph {
  vs.next_vertex = _first_free_vertex;
  _first_free_vertex = v;
  _vertices_filter[v] = false;
- --_nb_vertices;
+ --_num_vertices;
  }
  constexpr void remove_arc(const arc a) noexcept {
  assert(is_valid_arc(a));
@@ -264,7 +264,7 @@ class mutable_digraph {
  _arcs[a].next_in_arc = _first_free_arc;
  _first_free_arc = a;
  _arcs_filter[a] = false;
- --_nb_arcs;
+ --_num_arcs;
  }
  constexpr void change_arc_target(const arc a, const vertex t) noexcept {
  assert(is_valid_arc(a));

include/melon/container/static_digraph.hpp

@@ -35,42 +35,42 @@ class static_digraph {
  static_digraph & operator=(const static_digraph &) = default;
  static_digraph & operator=(static_digraph &&) = default;
 
- [[nodiscard]] constexpr auto nb_vertices() const noexcept {
+ [[nodiscard]] constexpr auto num_vertices() const noexcept {
  return _out_arc_begin.size();
  }
- [[nodiscard]] constexpr auto nb_arcs() const noexcept {
+ [[nodiscard]] constexpr auto num_arcs() const noexcept {
  return _arc_target.size();
  }
 
  [[nodiscard]] constexpr bool is_valid_vertex(
  const vertex u) const noexcept {
- return u < nb_vertices();
+ return u < num_vertices();
  }
  [[nodiscard]] constexpr bool is_valid_arc(const arc u) const noexcept {
- return u < nb_arcs();
+ return u < num_arcs();
  }
 
  [[nodiscard]] constexpr auto vertices() const noexcept {
  return std::views::iota(static_cast<vertex>(0),
- static_cast<vertex>(nb_vertices()));
+ static_cast<vertex>(num_vertices()));
  }
  [[nodiscard]] constexpr auto arcs() const noexcept {
  return std::views::iota(static_cast<arc>(0),
- static_cast<arc>(nb_arcs()));
+ static_cast<arc>(num_arcs()));
  }
 
  [[nodiscard]] constexpr auto out_arcs(const vertex u) const noexcept {
  assert(is_valid_vertex(u));
  return std::views::iota(
  _out_arc_begin[u],
- (u + 1 < nb_vertices() ? _out_arc_begin[u + 1] : nb_arcs()));
+ (u + 1 < num_vertices() ? _out_arc_begin[u + 1] : num_arcs()));
  }
  [[nodiscard]] constexpr auto in_arcs(const vertex u) const noexcept {
  assert(is_valid_vertex(u));
  return std::span(
  _in_arcs.data() + _in_arc_begin[u],
- (u + 1 < nb_vertices() ? _in_arcs.data() + _in_arc_begin[u + 1]
- : _in_arcs.data() + nb_arcs()));
+ (u + 1 < num_vertices() ? _in_arcs.data() + _in_arc_begin[u + 1]
+ : _in_arcs.data() + num_arcs()));
  }
 
  [[nodiscard]] constexpr vertex arc_source(const arc a) const noexcept {
@@ -93,54 +93,54 @@ class static_digraph {
  assert(is_valid_vertex(u));
  return std::span(
  _arc_target.data() + _out_arc_begin[u],
- (u + 1 < nb_vertices() ? _arc_target.data() + _out_arc_begin[u + 1]
- : _arc_target.data() + nb_arcs()));
+ (u + 1 < num_vertices() ? _arc_target.data() + _out_arc_begin[u + 1]
+ : _arc_target.data() + num_arcs()));
  }
 
  template <typename T>
  [[nodiscard]] constexpr auto create_vertex_map() const noexcept {
- return static_map<vertex, T>(nb_vertices());
+ return static_map<vertex, T>(num_vertices());
  }
  template <typename T>
  [[nodiscard]] constexpr auto create_vertex_map(
  const T & default_value) const noexcept {
- return static_map<vertex, T>(nb_vertices(), default_value);
+ return static_map<vertex, T>(num_vertices(), default_value);
  }
 
  template <typename T>
  [[nodiscard]] constexpr auto create_arc_map() const noexcept {
- return static_map<arc, T>(nb_arcs());
+ return static_map<arc, T>(num_arcs());
  }
  template <typename T>
  [[nodiscard]] constexpr auto create_arc_map(
  const T & default_value) const noexcept {
- return static_map<arc, T>(nb_arcs(), default_value);
+ return static_map<arc, T>(num_arcs(), default_value);
  }
 
 public:
  template <std::ranges::forward_range S, std::ranges::forward_range T>
  requires std::convertible_to<std::ranges::range_value_t<S>, vertex> &&
  std::convertible_to<std::ranges::range_value_t<T>, vertex>
- [[nodiscard]] static_digraph(const std::size_t & nb_vertices, S && sources,
+ [[nodiscard]] static_digraph(const std::size_t & num_vertices, S && sources,
  T && targets) noexcept
- : _out_arc_begin(nb_vertices, 0)
+ : _out_arc_begin(num_vertices, 0)
  , _arc_target(std::forward<T>(targets))
  , _arc_source(std::forward<S>(sources))
- , _in_arc_begin(nb_vertices, 0)
+ , _in_arc_begin(num_vertices, 0)
  , _in_arcs(_arc_target.size()) {
  assert(std::ranges::all_of(
- sources, [n = nb_vertices](auto && v) { return v < n; }));
+ sources, [n = num_vertices](auto && v) { return v < n; }));
  assert(std::ranges::all_of(
- targets, [n = nb_vertices](auto && v) { return v < n; }));
+ targets, [n = num_vertices](auto && v) { return v < n; }));
  assert(std::ranges::is_sorted(sources));
- static_map<vertex, arc> in_arc_count(nb_vertices, 0);
+ static_map<vertex, arc> in_arc_count(num_vertices, 0);
  for(auto && s : sources) ++_out_arc_begin[s];
  for(auto && t : targets) ++in_arc_count[t];
  std::exclusive_scan(_out_arc_begin.data(),
- _out_arc_begin.data() + nb_vertices,
+ _out_arc_begin.data() + num_vertices,
  _out_arc_begin.data(), 0);
  std::exclusive_scan(in_arc_count.data(),
- in_arc_count.data() + nb_vertices,
+ in_arc_count.data() + num_vertices,
  _in_arc_begin.data(), 0);
  for(auto && a : arcs()) {
  vertex t = _arc_target[a];