n_vertices -> order

Author: SpectraL519

README.md

@@ -101,7 +101,7 @@ int main() {
     graph.add_edge(4, 3);
 
     // print the size of the graph
-    std::cout << std::format("number of vertices: {}\n", graph.n_vertices())
+    std::cout << std::format("number of vertices: {}\n", graph.order())
               << std::format("number of edges: {}\n", graph.n_edges());
 }
 ```

docs/graph.md

@@ -123,7 +123,7 @@ Based on the specified traits, the `graph` class defines the following types:
 
 ### Size Operations
 
-- **`graph.n_vertices() const noexcept`**:
+- **`graph.order() const noexcept`**:
   - *Description*: Returns the total number of vertices in the graph.
   - *Returned value*: $|V|$ where $V$ is the vertex set of the graph
   - *Return type*: `types::size_type`

include/gl/algorithm/breadth_first_search.hpp

@@ -24,8 +24,8 @@ impl::alg_return_type<ResultDiscriminator, predecessors_descriptor> breadth_firs
     using vertex_type = typename GraphType::vertex_type;
     using edge_type = typename GraphType::edge_type;
 
-    std::vector<bool> visited(graph.n_vertices(), false);
-    std::vector<types::id_type> sources(graph.n_vertices());
+    std::vector<bool> visited(graph.order(), false);
+    std::vector<types::id_type> sources(graph.order());
 
     auto pd = impl::init_return_value<ResultDiscriminator, predecessors_descriptor>(graph);
 

include/gl/algorithm/coloring.hpp

@@ -23,7 +23,7 @@ template <
     using edge_type = typename GraphType::edge_type;
 
     std::optional<bicoloring_type> coloring_opt;
-    coloring_opt.emplace(graph.n_vertices(), bin_color_value::unset);
+    coloring_opt.emplace(graph.order(), bin_color_value::unset);
     auto& coloring = coloring_opt.value();
 
     for (const auto root_id : graph.vertex_ids()) {
@@ -78,7 +78,7 @@ requires(type_traits::c_binary_color_properties_type<typename GraphType::vertex_
 bool apply_coloring(GraphType& graph, const ColorRange& color_range) {
     using color_type = typename GraphType::vertex_properties_type::color_type;
 
-    if (std::ranges::size(color_range) != graph.n_vertices())
+    if (std::ranges::size(color_range) != graph.order())
         return false;
 
     auto vertices = graph.vertices(); // store the view to extend its lifetime

include/gl/algorithm/depth_first_search.hpp

@@ -23,8 +23,8 @@ impl::alg_return_type<ResultDiscriminator, predecessors_descriptor> depth_first_
     using vertex_type = typename GraphType::vertex_type;
     using edge_type = typename GraphType::edge_type;
 
-    std::vector<bool> visited(graph.n_vertices(), false);
-    std::vector<types::id_type> sources(graph.n_vertices());
+    std::vector<bool> visited(graph.order(), false);
+    std::vector<types::id_type> sources(graph.order());
 
     auto pd = impl::init_return_value<ResultDiscriminator, predecessors_descriptor>(graph);
 
@@ -70,8 +70,8 @@ impl::alg_return_type<ResultDiscriminator, predecessors_descriptor> recursive_de
     using vertex_type = typename GraphType::vertex_type;
     using edge_type = typename GraphType::edge_type;
 
-    std::vector<bool> visited(graph.n_vertices(), false);
-    std::vector<types::id_type> sources(graph.n_vertices());
+    std::vector<bool> visited(graph.order(), false);
+    std::vector<types::id_type> sources(graph.order());
 
     auto pd = impl::init_return_value<ResultDiscriminator, predecessors_descriptor>(graph);
 

include/gl/algorithm/dijkstra.hpp

@@ -59,7 +59,7 @@ template <type_traits::c_graph GraphType>
 [[nodiscard]] gl_attr_force_inline paths_descriptor_type<GraphType> make_paths_descriptor(
     const GraphType& graph
 ) {
-    return paths_descriptor_type<GraphType>{graph.n_vertices()};
+    return paths_descriptor_type<GraphType>{graph.order()};
 }
 
 template <

include/gl/algorithm/impl/common.hpp

@@ -18,7 +18,7 @@ template <
 init_return_value(const GraphType& graph) {
     using return_type = alg_return_type_non_void<ResultDiscriminator, ReturnType>;
     if constexpr (ResultDiscriminator == algorithm::ret)
-        return return_type(graph.n_vertices());
+        return return_type(graph.order());
     else
         return return_type();
 }

include/gl/algorithm/mst.hpp

@@ -47,7 +47,7 @@ template <type_traits::c_undirected_graph GraphType>
     using queue_type = std::priority_queue<edge_type, std::vector<edge_type>, edge_comparator>;
 
     // prepare the necessary utility
-    const auto n_vertices = graph.n_vertices();
+    const auto n_vertices = graph.order();
     mst_descriptor<GraphType> mst(n_vertices);
     std::vector<bool> visited(n_vertices, false);
     queue_type edge_queue;
@@ -96,7 +96,7 @@ requires type_traits::c_has_numeric_limits_max<types::vertex_distance_type<Graph
     using distance_type = types::vertex_distance_type<GraphType>;
 
     // Prepare the necessary utility
-    const auto n_vertices = graph.n_vertices();
+    const auto n_vertices = graph.order();
     mst_descriptor<GraphType> mst(n_vertices);
 
     std::vector<bool> in_mst(n_vertices, false);

include/gl/algorithm/topological_sort.hpp

@@ -25,15 +25,15 @@ template <
 
     // prepare the initial queue content (source vertices)
     std::vector<algorithm::vertex_info> source_vertex_list;
-    source_vertex_list.reserve(graph.n_vertices());
+    source_vertex_list.reserve(graph.order());
     for (const auto id : graph.vertex_ids())
         if (in_degree_map[id] == 0uz)
             source_vertex_list.emplace_back(id);
 
     std::optional<std::vector<types::id_type>> topological_order_opt =
         std::vector<types::id_type>{};
     auto& topological_order = topological_order_opt.value();
-    topological_order.reserve(graph.n_vertices());
+    topological_order.reserve(graph.order());
 
     impl::bfs(
         graph,
@@ -55,7 +55,7 @@ template <
         post_visit
     );
 
-    if (topological_order.size() != graph.n_vertices())
+    if (topological_order.size() != graph.order())
         return std::nullopt;
 
     return topological_order_opt;

include/gl/graph.hpp

@@ -59,7 +59,7 @@ class graph final {
 
     // --- general methods ---
 
-    [[nodiscard]] gl_attr_force_inline types::size_type n_vertices() const noexcept {
+    [[nodiscard]] gl_attr_force_inline types::size_type order() const noexcept {
         return this->_n_vertices;
     }
 
@@ -568,7 +568,7 @@ class graph final {
         os << std::format(
             "type: {}\nnumber of vertices: {}\nnumber of edges: {}\nvertices:\n",
             _directed_type_str(),
-            this->n_vertices(),
+            this->order(),
             this->n_edges()
         );
 
@@ -580,7 +580,7 @@ class graph final {
     }
 
     void _concise_write(std::ostream& os) const {
-        os << std::format("{} {} {}\n", _directed_type_str(), this->n_vertices(), this->n_edges());
+        os << std::format("{} {} {}\n", _directed_type_str(), this->order(), this->n_edges());
 
         for (const auto& vertex : this->vertices()) {
             os << "- " << vertex << " :";
@@ -600,7 +600,7 @@ class graph final {
         os << std::format(
             "{} {} {} {} {}\n",
             static_cast<int>(type_traits::c_directed_edge<edge_type>),
-            this->n_vertices(),
+            this->order(),
             this->n_edges(),
             static_cast<int>(with_vertex_properties),
             static_cast<int>(with_edge_properties)