diff --git a/Makefile b/Makefile
index c1cae80..c44903f 100755
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
-CONAN_PROFILE = clang
-# CONAN_PROFILE = default
+# CONAN_PROFILE = clang
+CONAN_PROFILE = default
 # CONAN_PROFILE = debug
 
 .PHONY: build package clean
diff --git a/include/melon/algorithm/breadth_first_search.hpp b/include/melon/algorithm/breadth_first_search.hpp
index 9320895..ff915e3 100644
--- a/include/melon/algorithm/breadth_first_search.hpp
+++ b/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];
diff --git a/include/melon/algorithm/depth_first_search.hpp b/include/melon/algorithm/depth_first_search.hpp
index 36cc364..89db2bf 100644
--- a/include/melon/algorithm/depth_first_search.hpp
+++ b/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));
         }
     }
 
diff --git a/include/melon/algorithm/dinitz.hpp b/include/melon/algorithm/dinitz.hpp
index 305809c..789c062 100644
--- a/include/melon/algorithm/dinitz.hpp
+++ b/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();
     }
diff --git a/include/melon/algorithm/edmonds_karp.hpp b/include/melon/algorithm/edmonds_karp.hpp
index b396fb9..f44097c 100644
--- a/include/melon/algorithm/edmonds_karp.hpp
+++ b/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();
     }
diff --git a/include/melon/algorithm/strongly_connected_components.hpp b/include/melon/algorithm/strongly_connected_components.hpp
index 16ee829..a4e9cd1 100644
--- a/include/melon/algorithm/strongly_connected_components.hpp
+++ b/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();
     }
diff --git a/include/melon/algorithm/topological_sort.hpp b/include/melon/algorithm/topological_sort.hpp
index f1bf6a4..6a02b6b 100644
--- a/include/melon/algorithm/topological_sort.hpp
+++ b/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();
     }
 
diff --git a/include/melon/container/mutable_digraph.hpp b/include/melon/container/mutable_digraph.hpp
index 62be185..fe83635 100644
--- a/include/melon/container/mutable_digraph.hpp
+++ b/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));
diff --git a/include/melon/container/static_digraph.hpp b/include/melon/container/static_digraph.hpp
index 697c7b3..f225dde 100644
--- a/include/melon/container/static_digraph.hpp
+++ b/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];
diff --git a/include/melon/container/static_forward_digraph.hpp b/include/melon/container/static_forward_digraph.hpp
index ce08221..3aa0352 100644
--- a/include/melon/container/static_forward_digraph.hpp
+++ b/include/melon/container/static_forward_digraph.hpp
@@ -25,17 +25,17 @@ class static_forward_digraph {
     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>
-    static_forward_digraph(const std::size_t & nb_vertices, S && sources,
+    static_forward_digraph(const std::size_t & num_vertices, S && sources,
                            T && targets) noexcept
-        : _out_arc_begin(nb_vertices, 0), _arc_target(std::move(targets)) {
+        : _out_arc_begin(num_vertices, 0), _arc_target(std::move(targets)) {
         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));
         for(auto && s : sources) ++_out_arc_begin[s];
         std::exclusive_scan(_out_arc_begin.data(),
-                            _out_arc_begin.data() + nb_vertices,
+                            _out_arc_begin.data() + num_vertices,
                             _out_arc_begin.data(), 0);
     }
 
@@ -47,27 +47,27 @@ class static_forward_digraph {
         default;
     static_forward_digraph & operator=(static_forward_digraph &&) = default;
 
-    auto nb_vertices() const noexcept { return _out_arc_begin.size(); }
-    auto nb_arcs() const noexcept { return _arc_target.size(); }
+    auto num_vertices() const noexcept { return _out_arc_begin.size(); }
+    auto num_arcs() const noexcept { return _arc_target.size(); }
 
     bool is_valid_vertex(const vertex & u) const noexcept {
-        return u < nb_vertices();
+        return u < num_vertices();
     }
-    bool is_valid_arc(const arc & u) const noexcept { return u < nb_arcs(); }
+    bool is_valid_arc(const arc & u) const noexcept { return u < num_arcs(); }
 
     auto vertices() const noexcept {
         return std::views::iota(static_cast<vertex>(0),
-                                static_cast<vertex>(nb_vertices()));
+                                static_cast<vertex>(num_vertices()));
     }
     auto arcs() const noexcept {
         return std::views::iota(static_cast<arc>(0),
-                                static_cast<arc>(nb_arcs()));
+                                static_cast<arc>(num_arcs()));
     }
     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()));
     }
     vertex arc_target(const arc & a) const noexcept {
         assert(is_valid_arc(a));
@@ -78,27 +78,27 @@ class static_forward_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>
     static_map<vertex, T> create_vertex_map() const noexcept {
-        return static_map<vertex, T>(nb_vertices());
+        return static_map<vertex, T>(num_vertices());
     }
     template <typename T>
     static_map<vertex, T> 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>
     static_map<arc, T> create_arc_map() const noexcept {
-        return static_map<arc, T>(nb_arcs());
+        return static_map<arc, T>(num_arcs());
     }
     template <typename T>
     static_map<arc, T> 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);
     }
 };
 
diff --git a/include/melon/graph.hpp b/include/melon/graph.hpp
index e8b9468..fae79b9 100644
--- a/include/melon/graph.hpp
+++ b/include/melon/graph.hpp
@@ -58,23 +58,23 @@ using vertex_t = std::ranges::range_value_t<vertices_range_t<_Tp>>;
 
 namespace __cust_access {
 template <typename _Tp>
-concept __member_nb_vertices = requires(const _Tp & __t) {
-    { __t.nb_vertices() } -> std::integral;
+concept __member_num_vertices = requires(const _Tp & __t) {
+    { __t.num_vertices() } -> std::integral;
 };
 
 template <typename _Tp>
-concept __adl_nb_vertices = requires(const _Tp & __t) {
-    { nb_vertices(__t) } -> std::integral;
+concept __adl_num_vertices = requires(const _Tp & __t) {
+    { num_vertices(__t) } -> std::integral;
 };
 
-struct _NbVertices {
+struct _NumVertices {
 private:
     template <typename _Tp>
     static constexpr bool _S_noexcept() {
-        if constexpr(__member_nb_vertices<_Tp>)
-            return noexcept(std::declval<_Tp &>().nb_vertices());
-        else if constexpr(__adl_nb_vertices<_Tp>)
-            return noexcept(nb_vertices(std::declval<_Tp &>()));
+        if constexpr(__member_num_vertices<_Tp>)
+            return noexcept(std::declval<_Tp &>().num_vertices());
+        else if constexpr(__adl_num_vertices<_Tp>)
+            return noexcept(num_vertices(std::declval<_Tp &>()));
         else
             return noexcept(
                 std::ranges::size(melon::vertices(std::declval<_Tp &>())));
@@ -82,14 +82,14 @@ struct _NbVertices {
 
 public:
     template <typename _Tp>
-        requires __member_nb_vertices<_Tp> || __adl_nb_vertices<_Tp> ||
+        requires __member_num_vertices<_Tp> || __adl_num_vertices<_Tp> ||
                  std::ranges::sized_range<vertices_range_t<_Tp>>
     constexpr auto operator() [[nodiscard]] (const _Tp & __t) const
         noexcept(_S_noexcept<_Tp &>()) {
-        if constexpr(__member_nb_vertices<_Tp>)
-            return __t.nb_vertices();
-        else if constexpr(__adl_nb_vertices<_Tp>)
-            return nb_vertices(__t);
+        if constexpr(__member_num_vertices<_Tp>)
+            return __t.num_vertices();
+        else if constexpr(__adl_num_vertices<_Tp>)
+            return num_vertices(__t);
         else
             return std::ranges::size(melon::vertices(__t));
     }
@@ -97,7 +97,7 @@ struct _NbVertices {
 }  // namespace __cust_access
 
 inline namespace __cust {
-inline constexpr __cust_access::_NbVertices nb_vertices{};
+inline constexpr __cust_access::_NumVertices num_vertices{};
 }  // namespace __cust
 
 namespace __cust_access {
@@ -381,37 +381,37 @@ inline constexpr __cust_access::_InDegree in_degree{};
 
 namespace __cust_access {
 template <typename _Tp>
-concept __member_nb_arcs = requires(const _Tp & __t) {
-    { __t.nb_arcs() } -> std::integral;
+concept __member_num_arcs = requires(const _Tp & __t) {
+    { __t.num_arcs() } -> std::integral;
 };
 
 template <typename _Tp>
-concept __adl_nb_arcs = requires(const _Tp & __t) {
-    { nb_arcs(__t) } -> std::integral;
+concept __adl_num_arcs = requires(const _Tp & __t) {
+    { num_arcs(__t) } -> std::integral;
 };
 
-struct _NbArcs {
+struct _NumArcs {
 private:
     template <typename _Tp>
     static constexpr bool _S_noexcept() {
-        if constexpr(__member_nb_arcs<_Tp>)
-            return noexcept(std::declval<_Tp &>().nb_arcs());
-        else if constexpr(__adl_nb_arcs<_Tp>)
-            return noexcept(nb_arcs(std::declval<_Tp &>()));
+        if constexpr(__member_num_arcs<_Tp>)
+            return noexcept(std::declval<_Tp &>().num_arcs());
+        else if constexpr(__adl_num_arcs<_Tp>)
+            return noexcept(num_arcs(std::declval<_Tp &>()));
         else
             return noexcept(std::ranges::size(_Arcs{}(std::declval<_Tp &>())));
     }
 
 public:
     template <typename _Tp>
-        requires __member_nb_arcs<_Tp> || __adl_nb_arcs<_Tp> ||
+        requires __member_num_arcs<_Tp> || __adl_num_arcs<_Tp> ||
                  std::ranges::sized_range<arcs_range_t<_Tp>>
     constexpr auto operator() [[nodiscard]] (const _Tp & __t) const
         noexcept(_S_noexcept<_Tp &>()) {
-        if constexpr(__member_nb_arcs<_Tp>)
-            return __t.nb_arcs();
-        else if constexpr(__adl_nb_arcs<_Tp>)
-            return nb_arcs(__t);
+        if constexpr(__member_num_arcs<_Tp>)
+            return __t.num_arcs();
+        else if constexpr(__adl_num_arcs<_Tp>)
+            return num_arcs(__t);
         else
             return std::ranges::size(_Arcs{}(__t));
     }
@@ -419,7 +419,7 @@ struct _NbArcs {
 }  // namespace __cust_access
 
 inline namespace __cust {
-inline constexpr __cust_access::_NbArcs nb_arcs{};
+inline constexpr __cust_access::_NumArcs num_arcs{};
 }  // namespace __cust
 
 namespace __cust_access {
@@ -772,15 +772,15 @@ template <typename _Tp>
 concept has_vertices = requires(const _Tp & __t) { melon::vertices(__t); };
 
 template <typename _Tp>
-concept has_nb_vertices =
-    has_vertices<_Tp> && requires(const _Tp & __t) { melon::nb_vertices(__t); };
+concept has_num_vertices =
+    has_vertices<_Tp> && requires(const _Tp & __t) { melon::num_vertices(__t); };
 
 template <typename _Tp>
 concept has_arcs = requires(const _Tp & __t) { melon::arcs(__t); };
 
 template <typename _Tp>
-concept has_nb_arcs =
-    has_arcs<_Tp> && requires(const _Tp & __t) { melon::nb_arcs(__t); };
+concept has_num_arcs =
+    has_arcs<_Tp> && requires(const _Tp & __t) { melon::num_arcs(__t); };
 
 template <typename _Tp>
 concept graph = has_vertices<_Tp> && has_arcs<_Tp> &&
diff --git a/include/melon/undirected_graph.hpp b/include/melon/undirected_graph.hpp
index f717feb..bbaa183 100644
--- a/include/melon/undirected_graph.hpp
+++ b/include/melon/undirected_graph.hpp
@@ -68,7 +68,7 @@ concept __adl_nb_edges = requires(const _Tp & __t) {
     { nb_edges(__t) } -> std::integral;
 };
 
-struct _NbEdges {
+struct _NumEdges {
 private:
     template <typename _Tp>
     static constexpr bool _S_noexcept() {
@@ -98,7 +98,7 @@ struct _NbEdges {
 }  // namespace __cust_access
 
 inline namespace __cust {
-inline constexpr __cust_access::_NbEdges nb_edges{};
+inline constexpr __cust_access::_NumEdges nb_edges{};
 }  // namespace __cust
 
 namespace __cust_access {
diff --git a/include/melon/utility/erdos_renyi.hpp b/include/melon/utility/erdos_renyi.hpp
index 748ee91..a5d5ecc 100644
--- a/include/melon/utility/erdos_renyi.hpp
+++ b/include/melon/utility/erdos_renyi.hpp
@@ -11,17 +11,17 @@ namespace fhamonic {
 namespace melon {
 
 template <typename G>
-G erdos_renyi(const std::size_t nb_vertices,
+G erdos_renyi(const std::size_t num_vertices,
                            const double expected_density) {
     using vertex = vertex_t<G>;
 
     static std::uniform_real_distribution<double> distr{0.0, 1.0};
     static std::mt19937 engine{std::random_device{}()};
 
-    static_digraph_builder<G> builder(nb_vertices);
+    static_digraph_builder<G> builder(num_vertices);
 
-    for(std::size_t i = 0; i < nb_vertices; ++i) {
-        for(std::size_t j = 0; j < nb_vertices; ++j) {
+    for(std::size_t i = 0; i < num_vertices; ++i) {
+        for(std::size_t j = 0; j < num_vertices; ++j) {
             if(i == j) continue;
             if(distr(engine) < expected_density)
                 builder.add_arc(vertex(i), vertex(j));
diff --git a/include/melon/utility/static_digraph_builder.hpp b/include/melon/utility/static_digraph_builder.hpp
index 04ac84e..bb7ab99 100644
--- a/include/melon/utility/static_digraph_builder.hpp
+++ b/include/melon/utility/static_digraph_builder.hpp
@@ -21,15 +21,15 @@ class static_digraph_builder {
     using arc = arc_t<G>;
     using property_maps = std::tuple<std::vector<ArcProperty>...>;
 
-    std::size_t _nb_vertices;
+    std::size_t _num_vertices;
     std::vector<vertex> _arc_sources;
     std::vector<vertex> _arc_targets;
     property_maps _arc_property_maps;
 
 public:
-    static_digraph_builder() noexcept : _nb_vertices(0) {}
-    static_digraph_builder(std::size_t nb_vertices_) noexcept
-        : _nb_vertices(nb_vertices_) {}
+    static_digraph_builder() noexcept : _num_vertices(0) {}
+    static_digraph_builder(std::size_t num_vertices_) noexcept
+        : _num_vertices(num_vertices_) {}
 
 private:
     template <class Maps, class Properties, std::size_t... Is>
@@ -41,7 +41,7 @@ class static_digraph_builder {
 public:
     static_digraph_builder & add_arc(vertex u, vertex v,
                                      ArcProperty... properties) noexcept {
-        assert(_nb_vertices > std::max(u, v));
+        assert(_num_vertices > std::max(u, v));
         _arc_sources.push_back(u);
         _arc_targets.push_back(v);
         add_properties(
@@ -66,7 +66,7 @@ class static_digraph_builder {
         return std::apply(
             [this](auto &&... property_map) {
                 return std::make_tuple(
-                    G(_nb_vertices, _arc_sources, _arc_targets),
+                    G(_num_vertices, _arc_sources, _arc_targets),
                     property_map...);
             },
             _arc_property_maps);
diff --git a/include/melon/views/complete_digraph.hpp b/include/melon/views/complete_digraph.hpp
index 2f73d9b..3528060 100644
--- a/include/melon/views/complete_digraph.hpp
+++ b/include/melon/views/complete_digraph.hpp
@@ -21,11 +21,11 @@ class complete_digraph : public graph_view_base {
     using vertex = V;
     using arc = A;
 
-    vertex _nb_vertices;
+    vertex _num_vertices;
 
 public:
     [[nodiscard]] constexpr explicit complete_digraph(const std::size_t n = 0)
-        : _nb_vertices(static_cast<vertex>(n)) {}
+        : _num_vertices(static_cast<vertex>(n)) {}
 
     [[nodiscard]] constexpr complete_digraph(const complete_digraph &) =
         default;
@@ -34,75 +34,75 @@ class complete_digraph : public graph_view_base {
     constexpr complete_digraph & operator=(const complete_digraph &) = default;
     constexpr complete_digraph & operator=(complete_digraph &&) = default;
 
-    [[nodiscard]] constexpr std::size_t nb_vertices() const noexcept {
-        return _nb_vertices;
+    [[nodiscard]] constexpr std::size_t num_vertices() const noexcept {
+        return _num_vertices;
     }
-    [[nodiscard]] constexpr std::size_t nb_arcs() const noexcept {
-        return static_cast<arc>(_nb_vertices) *
-               static_cast<arc>(_nb_vertices - 1);
+    [[nodiscard]] constexpr std::size_t num_arcs() const noexcept {
+        return static_cast<arc>(_num_vertices) *
+               static_cast<arc>(_num_vertices - 1);
     }
 
     [[nodiscard]] constexpr auto vertices() const noexcept {
-        return std::views::iota(vertex(0), _nb_vertices);
+        return std::views::iota(vertex(0), _num_vertices);
     }
     [[nodiscard]] constexpr auto arcs() const noexcept {
-        return std::views::iota(arc(0), nb_arcs());
+        return std::views::iota(arc(0), num_arcs());
     }
 
     [[nodiscard]] constexpr vertex arc_source(const arc a) const noexcept {
-        assert(a < nb_arcs());
-        return static_cast<vertex>(a / (_nb_vertices - 1));
+        assert(a < num_arcs());
+        return static_cast<vertex>(a / (_num_vertices - 1));
     }
     [[nodiscard]] constexpr vertex arc_target(const arc a) const noexcept {
-        assert(a < nb_arcs());
+        assert(a < num_arcs());
         vertex source = arc_source(a);
-        vertex target = a % (_nb_vertices - 1);
+        vertex target = a % (_num_vertices - 1);
         return target + (source <= target);
     }
 
     [[nodiscard]] constexpr auto out_arcs(const vertex u) const noexcept {
-        assert(u < _nb_vertices);
-        return std::views::iota(static_cast<arc>(u * (_nb_vertices - 1)),
-                                static_cast<arc>((u + 1) * (_nb_vertices - 1)));
+        assert(u < _num_vertices);
+        return std::views::iota(static_cast<arc>(u * (_num_vertices - 1)),
+                                static_cast<arc>((u + 1) * (_num_vertices - 1)));
     }
     [[nodiscard]] constexpr auto in_arcs(const vertex u) const noexcept {
-        assert(u < _nb_vertices);
+        assert(u < _num_vertices);
         return ranges::views::concat(
             intrusive_view(
                 static_cast<arc>(u - 1), std::identity(),
-                [offset = static_cast<arc>(_nb_vertices - 1)](const arc a) {
+                [offset = static_cast<arc>(_num_vertices - 1)](const arc a) {
                     return a + offset;
                 },
-                [offset = static_cast<arc>(_nb_vertices - 1), u](const arc a)
+                [offset = static_cast<arc>(_num_vertices - 1), u](const arc a)
                     -> bool { return a < static_cast<arc>(u) * offset; }),
             intrusive_view(
-                static_cast<arc>((u + 1) * _nb_vertices - 1), std::identity(),
-                [offset = static_cast<arc>(_nb_vertices - 1)](const arc a) {
+                static_cast<arc>((u + 1) * _num_vertices - 1), std::identity(),
+                [offset = static_cast<arc>(_num_vertices - 1)](const arc a) {
                     return a + offset;
                 },
-                [m = static_cast<arc>(nb_arcs())](const arc a) -> bool {
+                [m = static_cast<arc>(num_arcs())](const arc a) -> bool {
                     return a < m;
                 }));
     }
 
     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);
     }
 };
 
diff --git a/include/melon/views/dual.hpp b/include/melon/views/dual.hpp
index 5e3e77a..7fa2864 100644
--- a/include/melon/views/dual.hpp
+++ b/include/melon/views/dual.hpp
@@ -28,16 +28,16 @@ class dual {
     constexpr dual & operator=(const dual &) = default;
     constexpr dual & operator=(dual &&) = default;
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const requires
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const requires
         requires(P g) {
-        melon::nb_vertices(g);
+        melon::num_vertices(g);
     }
-    { return melon::nb_vertices(_planar_map.get()); }
-    [[nodiscard]] constexpr decltype(auto) nb_arcs() const noexcept requires
+    { return melon::num_vertices(_planar_map.get()); }
+    [[nodiscard]] constexpr decltype(auto) num_arcs() const noexcept requires
         requires(P g) {
-        melon::nb_arcs(g);
+        melon::num_arcs(g);
     }
-    { return melon::nb_arcs(_planar_map.get()); }
+    { return melon::num_arcs(_planar_map.get()); }
 
     [[nodiscard]] constexpr decltype(auto) vertices() const noexcept {
         return melon::faces(_planar_map.get());
diff --git a/include/melon/views/graph_view.hpp b/include/melon/views/graph_view.hpp
index c0aad3f..46e4c35 100644
--- a/include/melon/views/graph_view.hpp
+++ b/include/melon/views/graph_view.hpp
@@ -41,15 +41,15 @@ class graph_ref_view : public graph_view_base {
 
     constexpr G & base() const { return *_graph; }
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const
-        requires requires(G g) { melon::nb_vertices(g); }
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const
+        requires requires(G g) { melon::num_vertices(g); }
     {
-        return melon::nb_vertices(*_graph);
+        return melon::num_vertices(*_graph);
     }
-    [[nodiscard]] constexpr decltype(auto) nb_arcs() const noexcept
-        requires requires(G g) { melon::nb_arcs(g); }
+    [[nodiscard]] constexpr decltype(auto) num_arcs() const noexcept
+        requires requires(G g) { melon::num_arcs(g); }
     {
-        return melon::nb_arcs(*_graph);
+        return melon::num_arcs(*_graph);
     }
 
     [[nodiscard]] constexpr decltype(auto) vertices() const noexcept {
@@ -167,15 +167,15 @@ class graph_owning_view : public graph_view_base {
         return std::move(_graph);
     }
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const
-        requires requires(G g) { melon::nb_vertices(g); }
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const
+        requires requires(G g) { melon::num_vertices(g); }
     {
-        return melon::nb_vertices(_graph);
+        return melon::num_vertices(_graph);
     }
-    [[nodiscard]] constexpr decltype(auto) nb_arcs() const noexcept
-        requires requires(G g) { melon::nb_arcs(g); }
+    [[nodiscard]] constexpr decltype(auto) num_arcs() const noexcept
+        requires requires(G g) { melon::num_arcs(g); }
     {
-        return melon::nb_arcs(_graph);
+        return melon::num_arcs(_graph);
     }
 
     [[nodiscard]] constexpr decltype(auto) vertices() const noexcept {
diff --git a/include/melon/views/reverse.hpp b/include/melon/views/reverse.hpp
index 5acf4ec..6a3abce 100644
--- a/include/melon/views/reverse.hpp
+++ b/include/melon/views/reverse.hpp
@@ -30,15 +30,15 @@ class reverse : public graph_view_base {
     constexpr reverse & operator=(const reverse &) = default;
     constexpr reverse & operator=(reverse &&) = default;
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const
-        requires requires(_Graph g) { melon::nb_vertices(g); }
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const
+        requires requires(_Graph g) { melon::num_vertices(g); }
     {
-        return melon::nb_vertices(_graph);
+        return melon::num_vertices(_graph);
     }
-    [[nodiscard]] constexpr decltype(auto) nb_arcs() const noexcept
-        requires requires(_Graph g) { melon::nb_arcs(g); }
+    [[nodiscard]] constexpr decltype(auto) num_arcs() const noexcept
+        requires requires(_Graph g) { melon::num_arcs(g); }
     {
-        return melon::nb_arcs(_graph);
+        return melon::num_arcs(_graph);
     }
 
     [[nodiscard]] constexpr decltype(auto) vertices() const noexcept {
diff --git a/include/melon/views/subgraph.hpp b/include/melon/views/subgraph.hpp
index 931b05f..08caaac 100644
--- a/include/melon/views/subgraph.hpp
+++ b/include/melon/views/subgraph.hpp
@@ -44,11 +44,11 @@ class subgraph : public graph_view_base {
     constexpr subgraph & operator=(const subgraph &) = default;
     constexpr subgraph & operator=(subgraph &&) = default;
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const noexcept
-        requires has_nb_vertices<_Graph> &&
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const noexcept
+        requires has_num_vertices<_Graph> &&
                  std::same_as<_VertexFilter, true_map>
     {
-        return melon::nb_vertices(_graph);
+        return melon::num_vertices(_graph);
     }
 
     void disable_vertex(const vertex & v) noexcept
diff --git a/include/melon/views/undirect.hpp b/include/melon/views/undirect.hpp
index 064f513..e9e1d55 100644
--- a/include/melon/views/undirect.hpp
+++ b/include/melon/views/undirect.hpp
@@ -33,15 +33,15 @@ class undirect : public undirected_graph_view_base {
     constexpr undirect & operator=(const undirect &) = default;
     constexpr undirect & operator=(undirect &&) = default;
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const
-        requires requires(_Graph g) { melon::nb_vertices(g); }
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const
+        requires requires(_Graph g) { melon::num_vertices(g); }
     {
-        return melon::nb_vertices(_graph);
+        return melon::num_vertices(_graph);
     }
     [[nodiscard]] constexpr decltype(auto) nb_edges() const noexcept
-        requires requires(_Graph g) { melon::nb_arcs(g); }
+        requires requires(_Graph g) { melon::num_arcs(g); }
     {
-        return melon::nb_arcs(_graph);
+        return melon::num_arcs(_graph);
     }
 
     [[nodiscard]] constexpr decltype(auto) vertices() const noexcept {
diff --git a/include/melon/views/undirected_graph_view.hpp b/include/melon/views/undirected_graph_view.hpp
index 503da86..0e8cc19 100644
--- a/include/melon/views/undirected_graph_view.hpp
+++ b/include/melon/views/undirected_graph_view.hpp
@@ -47,10 +47,10 @@ class undirected_graph_ref_view : public undirected_graph_view_base {
 
     constexpr G & base() const { return *_undirected_graph; }
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const
-        requires requires(G g) { melon::nb_vertices(g); }
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const
+        requires requires(G g) { melon::num_vertices(g); }
     {
-        return melon::nb_vertices(*_undirected_graph);
+        return melon::num_vertices(*_undirected_graph);
     }
     [[nodiscard]] constexpr decltype(auto) nb_edges() const noexcept
         requires requires(G g) { melon::nb_edges(g); }
@@ -143,10 +143,10 @@ class undirected_graph_owning_view : public undirected_graph_view_base {
         return std::move(_undirected_graph);
     }
 
-    [[nodiscard]] constexpr decltype(auto) nb_vertices() const
-        requires requires(G g) { melon::nb_vertices(g); }
+    [[nodiscard]] constexpr decltype(auto) num_vertices() const
+        requires requires(G g) { melon::num_vertices(g); }
     {
-        return melon::nb_vertices(_undirected_graph);
+        return melon::num_vertices(_undirected_graph);
     }
     [[nodiscard]] constexpr decltype(auto) nb_edges() const noexcept
         requires requires(G g) { melon::nb_edges(g); }
diff --git a/test/complete_digraph_test.cpp b/test/complete_digraph_test.cpp
index 0346ffb..e60f05f 100644
--- a/test/complete_digraph_test.cpp
+++ b/test/complete_digraph_test.cpp
@@ -38,8 +38,8 @@ GTEST_TEST(complete_digraph, empty_constructor) {
 GTEST_TEST(complete_digraph, k4) {
     G graph(4);
 
-    ASSERT_EQ(nb_vertices(graph), 4);
-    ASSERT_EQ(nb_arcs(graph), 12);
+    ASSERT_EQ(num_vertices(graph), 4);
+    ASSERT_EQ(num_arcs(graph), 12);
 
     ASSERT_TRUE(EQ_MULTISETS(out_arcs(graph, 0), {0, 1, 2}));
     ASSERT_TRUE(EQ_MULTISETS(out_arcs(graph, 1), {3, 4, 5}));
diff --git a/test/concurrent_dijkstras_test.cpp b/test/concurrent_dijkstras_test.cpp
index 3a9adcf..84df792 100755
--- a/test/concurrent_dijkstras_test.cpp
+++ b/test/concurrent_dijkstras_test.cpp
@@ -79,7 +79,7 @@ auto compute_concurrent_dijkstras_map(const G & g,
 }
 
 GTEST_TEST(concurrent_dijkstras, fuzzy) {
-    static constexpr std::size_t nb_vertices = 15;
+    static constexpr std::size_t num_vertices = 15;
     static constexpr double density = 0.35;
     static constexpr int nb_tests = 1000;
 
@@ -89,7 +89,7 @@ GTEST_TEST(concurrent_dijkstras, fuzzy) {
     std::mt19937 engine{std::random_device{}()};
 
     for(int i = 0; i < nb_tests; ++i) {
-        auto graph = erdos_renyi<static_digraph>(nb_vertices, density);
+        auto graph = erdos_renyi<static_digraph>(num_vertices, density);
         auto lower_length_map = create_arc_map<int>(graph);
         auto upper_length_map = create_arc_map<int>(graph);
         for(const auto & a : arcs(graph)) {
@@ -231,7 +231,7 @@ struct useless_concurrent_dijkstras_traits {
 };
 
 GTEST_TEST(useless_fiber, fuzzy) {
-    static constexpr std::size_t nb_vertices = 15;
+    static constexpr std::size_t num_vertices = 15;
     static constexpr double density = 0.35;
     static constexpr int nb_tests = 1000;
 
@@ -241,7 +241,7 @@ GTEST_TEST(useless_fiber, fuzzy) {
     std::mt19937 engine{std::random_device{}()};
 
     for(int i = 0; i < nb_tests; ++i) {
-        auto graph = erdos_renyi<static_digraph>(nb_vertices, density);
+        auto graph = erdos_renyi<static_digraph>(num_vertices, density);
         auto lower_length_map = create_arc_map<int>(graph);
         auto upper_length_map = create_arc_map<int>(graph);
         for(const auto & a : arcs(graph)) {
diff --git a/test/cpo_test.cpp b/test/cpo_test.cpp
index 1ad866f..7445899 100644
--- a/test/cpo_test.cpp
+++ b/test/cpo_test.cpp
@@ -27,8 +27,8 @@ using namespace fhamonic;
 
 GTEST_TEST(CPO, test) {
     static_assert(melon::graph<G>);
-    static_assert(melon::has_nb_vertices<G>);
-    static_assert(!melon::has_nb_arcs<G>);
+    static_assert(melon::has_num_vertices<G>);
+    static_assert(!melon::has_num_arcs<G>);
     static_assert(melon::has_out_arcs<G>);
     static_assert(melon::has_out_degree<G>);
     static_assert(melon::outward_incidence_graph<G>);
diff --git a/test/dumb_digraph.hpp b/test/dumb_digraph.hpp
index 0129e73..c46ff49 100644
--- a/test/dumb_digraph.hpp
+++ b/test/dumb_digraph.hpp
@@ -58,10 +58,10 @@ class dumb_digraph {
                std::views::transform(
                    [](const arc_struct & as) -> arc { return as.id; });
     }
-    auto nb_vertices() const noexcept {
+    auto num_vertices() const noexcept {
         return std::ranges::distance(vertices());
     }
-    auto nb_arcs() const noexcept { return std::ranges::distance(arcs()); }
+    auto num_arcs() const noexcept { return std::ranges::distance(arcs()); }
     auto arcs_entries() const noexcept {
         return valid_arcs_structs() |
                std::views::transform(
diff --git a/test/erdos_renyi_test.cpp b/test/erdos_renyi_test.cpp
index 4ebaf08..1f77084 100755
--- a/test/erdos_renyi_test.cpp
+++ b/test/erdos_renyi_test.cpp
@@ -9,17 +9,17 @@ using namespace fhamonic::melon;
 
 GTEST_TEST(erdos_renyi, test) {
     auto random_graph1 = erdos_renyi<static_digraph>(100, 0.0);
-    ASSERT_EQ(random_graph1.nb_vertices(), 100);
-    ASSERT_EQ(random_graph1.nb_arcs(), 0);
+    ASSERT_EQ(random_graph1.num_vertices(), 100);
+    ASSERT_EQ(random_graph1.num_arcs(), 0);
 
     auto random_graph2 = erdos_renyi<static_digraph>(100, 1.0);
-    ASSERT_EQ(random_graph2.nb_vertices(), 100);
-    ASSERT_EQ(random_graph2.nb_arcs(), 9900);
+    ASSERT_EQ(random_graph2.num_vertices(), 100);
+    ASSERT_EQ(random_graph2.num_arcs(), 9900);
 
     auto random_graph3 = erdos_renyi<static_digraph>(100, 0.5);
-    ASSERT_EQ(random_graph3.nb_vertices(), 100);
+    ASSERT_EQ(random_graph3.num_vertices(), 100);
     // the probability of the two following tests to fail is 2*10^-60,
     // a billion times more than the number of atoms on Earth...
-    ASSERT_TRUE(random_graph3.nb_arcs() > 1000);
-    ASSERT_TRUE(random_graph3.nb_arcs() < 8900);
+    ASSERT_TRUE(random_graph3.num_arcs() > 1000);
+    ASSERT_TRUE(random_graph3.num_arcs() < 8900);
 }
diff --git a/test/mutable_digraph_test.cpp b/test/mutable_digraph_test.cpp
index 7662a36..a46f72d 100755
--- a/test/mutable_digraph_test.cpp
+++ b/test/mutable_digraph_test.cpp
@@ -136,14 +136,14 @@ GTEST_TEST(mutable_digraph, fuzzy_test) {
             Operation op;
             for(;;) {
                 op = random_element(operations);
-                auto nb_vertices =
+                auto num_vertices =
                     std::ranges::distance(dummy_graph.vertices());
-                auto nb_arcs = std::ranges::distance(dummy_graph.arcs());
-                if(op == REMOVE_VERTEX && nb_vertices == 0) continue;
-                if(op == CREATE_ARC && nb_vertices < 2) continue;
-                if(op == REMOVE_ARC && nb_arcs == 0) continue;
+                auto num_arcs = std::ranges::distance(dummy_graph.arcs());
+                if(op == REMOVE_VERTEX && num_vertices == 0) continue;
+                if(op == CREATE_ARC && num_vertices < 2) continue;
+                if(op == REMOVE_ARC && num_arcs == 0) continue;
                 if((op == CHANGE_SOURCE || op == CHANGE_TARGET) &&
-                   (nb_arcs == 0 || nb_vertices < 2))
+                   (num_arcs == 0 || num_vertices < 2))
                     continue;
                 break;
             }
@@ -192,8 +192,8 @@ GTEST_TEST(mutable_digraph, fuzzy_test) {
 
             ASSERT_TRUE(EQ_MULTISETS(vertices(graph), dummy_graph.vertices()));
             ASSERT_TRUE(EQ_MULTISETS(arcs(graph), dummy_graph.arcs()));
-            ASSERT_EQ(nb_vertices(graph), dummy_graph.nb_vertices());
-            ASSERT_EQ(nb_arcs(graph), dummy_graph.nb_arcs());
+            ASSERT_EQ(num_vertices(graph), dummy_graph.num_vertices());
+            ASSERT_EQ(num_arcs(graph), dummy_graph.num_arcs());
             ASSERT_TRUE(
                 EQ_MULTISETS(arcs_entries(graph), dummy_graph.arcs_entries()));
 
diff --git a/test/reverse_test.cpp b/test/reverse_test.cpp
index 319ab23..6c24a92 100755
--- a/test/reverse_test.cpp
+++ b/test/reverse_test.cpp
@@ -23,18 +23,18 @@ GTEST_TEST(reverse_views, static_graph) {
 
     auto reverse_graph = views::reverse(graph);
 
-    ASSERT_EQ(nb_vertices(graph), reverse_graph.nb_vertices());
-    ASSERT_EQ(nb_arcs(graph), reverse_graph.nb_arcs());
+    ASSERT_EQ(num_vertices(graph), reverse_graph.num_vertices());
+    ASSERT_EQ(num_arcs(graph), reverse_graph.num_arcs());
 
     ASSERT_TRUE(EQ_RANGES(vertices(graph), reverse_graph.vertices()));
     ASSERT_TRUE(EQ_RANGES(arcs(graph), reverse_graph.arcs()));
 
     for(auto u : vertices(graph)) ASSERT_TRUE(is_valid_vertex(graph, u));
     ASSERT_FALSE(
-        is_valid_vertex(graph, vertex_t<static_digraph>(nb_vertices(graph))));
+        is_valid_vertex(graph, vertex_t<static_digraph>(num_vertices(graph))));
 
     for(auto a : arcs(graph)) ASSERT_TRUE(is_valid_arc(graph, a));
-    ASSERT_FALSE(is_valid_arc(graph, arc_t<static_digraph>(nb_arcs(graph))));
+    ASSERT_FALSE(is_valid_arc(graph, arc_t<static_digraph>(num_arcs(graph))));
 
     ASSERT_TRUE(
         EQ_RANGES(out_neighbors(graph, 0), reverse_graph.in_neighbors(0)));
diff --git a/test/static_digraph_test.cpp b/test/static_digraph_test.cpp
index 3095c2a..11edfbd 100755
--- a/test/static_digraph_test.cpp
+++ b/test/static_digraph_test.cpp
@@ -21,8 +21,8 @@ static_assert(melon::has_arc_map<static_digraph>);
 
 GTEST_TEST(static_digraph, empty_constructor) {
     static_digraph graph;
-    ASSERT_EQ(nb_vertices(graph), 0);
-    ASSERT_EQ(nb_arcs(graph), 0);
+    ASSERT_EQ(num_vertices(graph), 0);
+    ASSERT_EQ(num_arcs(graph), 0);
     ASSERT_TRUE(EMPTY(vertices(graph)));
     ASSERT_TRUE(EMPTY(arcs(graph)));
     ASSERT_TRUE(EMPTY(arcs_entries(graph)));
@@ -41,8 +41,8 @@ GTEST_TEST(static_digraph, empty_vectors_constructor) {
     std::vector<vertex_t<static_digraph>> targets;
 
     static_digraph graph(1, std::move(sources), std::move(targets));
-    ASSERT_EQ(nb_vertices(graph), 1);
-    ASSERT_EQ(nb_arcs(graph), 0);
+    ASSERT_EQ(num_vertices(graph), 1);
+    ASSERT_EQ(num_arcs(graph), 0);
     ASSERT_TRUE(EQ_MULTISETS(vertices(graph), {0}));
     ASSERT_TRUE(EMPTY(arcs(graph)));
     ASSERT_TRUE(EMPTY(arcs_entries(graph)));
@@ -67,17 +67,17 @@ GTEST_TEST(static_digraph, vectors_constructor_1) {
     static_digraph graph(
         3, std::ranges::views::keys(std::ranges::views::values(arc_pairs)),
         std::ranges::views::values(std::ranges::views::values(arc_pairs)));
-    ASSERT_EQ(nb_vertices(graph), 3);
-    ASSERT_EQ(nb_arcs(graph), 5);
+    ASSERT_EQ(num_vertices(graph), 3);
+    ASSERT_EQ(num_arcs(graph), 5);
     ASSERT_TRUE(EQ_MULTISETS(vertices(graph), {0, 1, 2}));
     ASSERT_TRUE(EQ_MULTISETS(arcs(graph), {0, 1, 2, 3, 4}));
 
     for(auto u : vertices(graph)) ASSERT_TRUE(is_valid_vertex(graph,u));
     ASSERT_FALSE(
-        is_valid_vertex(graph,vertex_t<static_digraph>(nb_vertices(graph))));
+        is_valid_vertex(graph,vertex_t<static_digraph>(num_vertices(graph))));
 
     for(auto a : arcs(graph)) ASSERT_TRUE(is_valid_arc(graph,a));
-    ASSERT_FALSE(is_valid_arc(graph,arc_t<static_digraph>(nb_arcs(graph))));
+    ASSERT_FALSE(is_valid_arc(graph,arc_t<static_digraph>(num_arcs(graph))));
 
     ASSERT_TRUE(EQ_MULTISETS(out_neighbors(graph,0), {1, 2}));
     ASSERT_TRUE(EQ_MULTISETS(out_neighbors(graph,1), {2}));
@@ -112,18 +112,18 @@ GTEST_TEST(static_digraph, vectors_constructor_2) {
     static_digraph graph(
         8, std::ranges::views::keys(std::ranges::views::values(arc_pairs)),
         std::ranges::views::values(std::ranges::views::values(arc_pairs)));
-    ASSERT_EQ(nb_vertices(graph), 8);
-    ASSERT_EQ(nb_arcs(graph), 9);
+    ASSERT_EQ(num_vertices(graph), 8);
+    ASSERT_EQ(num_arcs(graph), 9);
 
     ASSERT_TRUE(EQ_MULTISETS(vertices(graph), {0, 1, 2, 3, 4, 5, 6, 7}));
     ASSERT_TRUE(EQ_MULTISETS(arcs(graph), {0, 1, 2, 3, 4, 5, 6, 7, 8}));
 
     for(auto u : vertices(graph)) ASSERT_TRUE(is_valid_vertex(graph,u));
     ASSERT_FALSE(
-        is_valid_vertex(graph,vertex_t<static_digraph>(nb_vertices(graph))));
+        is_valid_vertex(graph,vertex_t<static_digraph>(num_vertices(graph))));
 
     for(auto a : arcs(graph)) ASSERT_TRUE(is_valid_arc(graph,a));
-    ASSERT_FALSE(is_valid_arc(graph,arc_t<static_digraph>(nb_arcs(graph))));
+    ASSERT_FALSE(is_valid_arc(graph,arc_t<static_digraph>(num_arcs(graph))));
 
     ASSERT_TRUE(EMPTY(out_neighbors(graph,0)));
     ASSERT_TRUE(EQ_MULTISETS(out_neighbors(graph,1), {2, 6, 7}));
diff --git a/test/static_forward_digraph_test.cpp b/test/static_forward_digraph_test.cpp
index b941686..d61f3f9 100755
--- a/test/static_forward_digraph_test.cpp
+++ b/test/static_forward_digraph_test.cpp
@@ -17,8 +17,8 @@ static_assert(melon::has_arc_map<static_forward_digraph>);
 
 GTEST_TEST(static_forward_digraph, empty_constructor) {
     static_forward_digraph graph;
-    ASSERT_EQ(nb_vertices(graph), 0);
-    ASSERT_EQ(nb_arcs(graph), 0);
+    ASSERT_EQ(num_vertices(graph), 0);
+    ASSERT_EQ(num_arcs(graph), 0);
     ASSERT_TRUE(EMPTY(vertices(graph)));
     ASSERT_TRUE(EMPTY(arcs(graph)));
     ASSERT_TRUE(EMPTY(arcs_entries(graph)));
@@ -35,8 +35,8 @@ GTEST_TEST(static_forward_digraph, empty_vectors_constructor) {
     std::vector<vertex_t<static_forward_digraph>> targets;
 
     static_forward_digraph graph(0, std::move(sources), std::move(targets));
-    ASSERT_EQ(nb_vertices(graph), 0);
-    ASSERT_EQ(nb_arcs(graph), 0);
+    ASSERT_EQ(num_vertices(graph), 0);
+    ASSERT_EQ(num_arcs(graph), 0);
     ASSERT_TRUE(EMPTY(vertices(graph)));
     ASSERT_TRUE(EMPTY(arcs(graph)));
     ASSERT_TRUE(EMPTY(arcs_entries(graph)));
@@ -59,19 +59,19 @@ GTEST_TEST(static_forward_digraph, vectors_constructor_1) {
     static_forward_digraph graph(
         3, std::ranges::views::keys(std::ranges::views::values(arc_pairs)),
         std::ranges::views::values(std::ranges::views::values(arc_pairs)));
-    ASSERT_EQ(nb_vertices(graph), 3);
-    ASSERT_EQ(nb_arcs(graph), 5);
+    ASSERT_EQ(num_vertices(graph), 3);
+    ASSERT_EQ(num_arcs(graph), 5);
 
     ASSERT_TRUE(EQ_RANGES(vertices(graph), {0, 1, 2}));
     ASSERT_TRUE(EQ_RANGES(arcs(graph), {0, 1, 2, 3, 4}));
 
     for(auto u : vertices(graph)) ASSERT_TRUE(is_valid_vertex(graph,u));
     ASSERT_FALSE(is_valid_vertex(graph,
-        vertex_t<static_forward_digraph>(nb_vertices(graph))));
+        vertex_t<static_forward_digraph>(num_vertices(graph))));
 
     for(auto a : arcs(graph)) ASSERT_TRUE(is_valid_arc(graph,a));
     ASSERT_FALSE(
-        is_valid_arc(graph,arc_t<static_forward_digraph>(nb_arcs(graph))));
+        is_valid_arc(graph,arc_t<static_forward_digraph>(num_arcs(graph))));
 
     ASSERT_TRUE(EQ_RANGES(out_neighbors(graph,0), {1, 2}));
     ASSERT_TRUE(EQ_RANGES(out_neighbors(graph,1), {2}));
@@ -99,19 +99,19 @@ GTEST_TEST(static_forward_digraph, vectors_constructor_2) {
     static_forward_digraph graph(
         8, std::ranges::views::keys(std::ranges::views::values(arc_pairs)),
         std::ranges::views::values(std::ranges::views::values(arc_pairs)));
-    ASSERT_EQ(nb_vertices(graph), 8);
-    ASSERT_EQ(nb_arcs(graph), 9);
+    ASSERT_EQ(num_vertices(graph), 8);
+    ASSERT_EQ(num_arcs(graph), 9);
 
     ASSERT_TRUE(EQ_RANGES(vertices(graph), {0, 1, 2, 3, 4, 5, 6, 7}));
     ASSERT_TRUE(EQ_RANGES(arcs(graph), {0, 1, 2, 3, 4, 5, 6, 7, 8}));
 
     for(auto u : vertices(graph)) ASSERT_TRUE(is_valid_vertex(graph,u));
     ASSERT_FALSE(is_valid_vertex(graph,
-        vertex_t<static_forward_digraph>(nb_vertices(graph))));
+        vertex_t<static_forward_digraph>(num_vertices(graph))));
 
     for(auto a : arcs(graph)) ASSERT_TRUE(is_valid_arc(graph,a));
     ASSERT_FALSE(
-        is_valid_arc(graph,arc_t<static_forward_digraph>(nb_arcs(graph))));
+        is_valid_arc(graph,arc_t<static_forward_digraph>(num_arcs(graph))));
 
     ASSERT_TRUE(
         EQ_RANGES(out_neighbors(graph,0),
diff --git a/test/subgraph_test.cpp b/test/subgraph_test.cpp
index 94622cc..cc9f6bb 100755
--- a/test/subgraph_test.cpp
+++ b/test/subgraph_test.cpp
@@ -30,10 +30,10 @@ GTEST_TEST(subgraph_views, static_graph) {
 
     for(auto u : vertices(graph)) ASSERT_TRUE(is_valid_vertex(graph, u));
     ASSERT_FALSE(
-        is_valid_vertex(graph, vertex_t<static_digraph>(nb_vertices(graph))));
+        is_valid_vertex(graph, vertex_t<static_digraph>(num_vertices(graph))));
 
     for(auto a : arcs(graph)) ASSERT_TRUE(is_valid_arc(graph, a));
-    ASSERT_FALSE(is_valid_arc(graph, arc_t<static_digraph>(nb_arcs(graph))));
+    ASSERT_FALSE(is_valid_arc(graph, arc_t<static_digraph>(num_arcs(graph))));
 
     ASSERT_TRUE(
         EQ_RANGES(out_neighbors(graph, 0), subgraph_graph.out_neighbors(0)));
diff --git a/test/undirect_test.cpp b/test/undirect_test.cpp
index 464f044..68f0458 100755
--- a/test/undirect_test.cpp
+++ b/test/undirect_test.cpp
@@ -24,8 +24,8 @@ GTEST_TEST(undirect_views, static_graph) {
 
     auto ugraph = views::undirect(graph);
 
-    ASSERT_EQ(nb_vertices(graph), nb_vertices(ugraph));
-    ASSERT_EQ(nb_arcs(graph), nb_edges(ugraph));
+    ASSERT_EQ(num_vertices(graph), num_vertices(ugraph));
+    ASSERT_EQ(num_arcs(graph), nb_edges(ugraph));
 
     ASSERT_TRUE(EQ_RANGES(vertices(graph), vertices(ugraph)));
     ASSERT_TRUE(EQ_RANGES(arcs(graph), edges(ugraph)));