refactor(pruning): move pruning methods to deglib::optimization with tests

- Add cpp/deglib/include/deglib/optimization/pruning.h with 4 pruning methods
- Expose via optimization.h high-level API
- Update benchmark to use new optimization::pruning methods
- Add unit tests for all pruning methods

Author: Neiko2002

.zcode/plans/plan-sess_5999e92a-c5fa-456b-849a-c24469b7d07d.md

@@ -0,0 +1,51 @@
+## Refactoring Plan: Move Pruning Methods to `cpp/deglib/include/optimization`
+
+### Goal
+Consolidate pruning logic from `cpp/benchmark/src/deglib_build_bench.cpp` and `examples/knng/main.py` into a new `cpp/deglib/include/deglib/optimization/pruning.h` file, and expose it through `optimization.h` as a high-level API.
+
+### Current Pruning Methods Found
+
+| Method | Location | Strategy |
+|--------|----------|----------|
+| `remove_non_mrng_edges` (multi-threaded) | `builder.h:1841` | Parallel MRNG conformance pruning (current core impl) |
+| `remove_non_mrng_edges_1` (iterative) | `deglib_build_bench.cpp:102` | Per-vertex iterative removal, single-threaded |
+| `remove_non_mrng_edges_2` (weight-sorted) | `deglib_build_bench.cpp:61` | Collect all non-RNG edges, sort by weight, remove, single-threaded |
+| `remove_non_mrng_edges` (file wrapper) | `deglib_build_bench.cpp:166` | Loads graph from file, calls builder version, saves |
+| `prune_worst_edges` | `main.py:40` | Prunes worst N (highest-weight) neighbors per vertex (Python only) |
+
+### New File: `cpp/deglib/include/deglib/optimization/pruning.h`
+
+A new header with `deglib::optimization::pruning` namespace containing:
+
+1. **`prune_worst_edges(MutableGraph& graph, uint8_t prune_worst, size_t numThreads = 0)`**
+   - C++ port of the Python `prune_worst_edges()`.
+   - For each vertex: sort neighbors by descending weight, replace top `prune_worst` with self-loops (index=u, weight=0.0), re-sort by index.
+   - Multi-threaded via `parallel_for`.
+
+2. **`remove_non_mrng_edges(MutableGraph& graph, size_t numThreads = 0)`**
+   - The multi-threaded MRNG pruning (moved from `builder.h`), now in optimization namespace.
+   - Uses `analysis::checkRNG()` + `parallel_for`.
+
+3. **`remove_non_mrng_edges_weight_sorted(MutableGraph& graph, size_t numThreads = 0)`**
+   - Benchmark variant 2: collect all non-RNG edges, sort by weight ascending, remove in order.
+   - Multi-threaded collection, single-threaded sorted removal.
+
+4. **`remove_non_mrng_edges_iterative(MutableGraph& graph, size_t numThreads = 0)`**
+   - Benchmark variant 1: per-vertex iterative removal in a do-while loop until stable.
+   - Multi-threaded per-vertex.
+
+### Modified: `cpp/deglib/include/deglib/optimization.h`
+
+- Add `#include "deglib/optimization/pruning.h"`
+- Add inline wrapper functions in `deglib::optimization` namespace delegating to `deglib::optimization::pruning::*`.
+
+### Modified: `cpp/benchmark/src/deglib_build_bench.cpp`
+
+- Replace local `remove_non_mrng_edges_1`, `remove_non_mrng_edges_2`, and wrapper with calls to `deglib::optimization::pruning::remove_non_mrng_edges_iterative()` and `deglib::optimization::pruning::remove_non_mrng_edges_weight_sorted()`.
+- Keep `remove_non_mrng_edges()` wrapper calling `deglib::optimization::pruning::remove_non_mrng_edges()`.
+
+### Backward Compatibility
+
+- `deglib::builder::remove_non_mrng_edges` and `deglib::builder::optimize_edges` remain unchanged.
+- `GraphEdge` struct stays in `builder.h`.
+- `deglib.h` already includes `optimization.h`, so the new API is automatically available.

cpp/benchmark/src/deglib_build_bench.cpp

@@ -61,102 +61,23 @@ void change_features(const std::string initial_graph_file, const std::string rep
 void remove_non_mrng_edges_2(const std::string initial_graph_file, const std::string graph_file) {
     fmt::print("Load graph {} \n", initial_graph_file);
     auto graph = deglib::graph::load_sizebounded_graph(initial_graph_file.c_str());
-    fmt::print("Graph with {} vertices and containing {} non-RNG edges\n", graph.size(), deglib::analysis::calc_non_rng_edges(graph));
+    fmt::print("Graph with {} vertices and containing {} non-RNG edges \n", graph.size(), deglib::analysis::calc_non_rng_edges(graph));
 
-    const auto vertex_count = graph.size();
-    const auto edge_per_vertex = graph.getEdgesPerVertex();
-
-    const auto start = std::chrono::steady_clock::now();
-    std::vector<deglib::builder::GraphEdge> nonMRNG_edges;
-    for (uint32_t i = 0; i < vertex_count; i++) {
-        const auto vertex_index = i;
-        const auto neighbor_indices = graph.getNeighborIndices(vertex_index);
-        const auto neighbor_weights = graph.getNeighborWeights(vertex_index);
-
-        // find all none rng conform neighbors
-        for (uint32_t n = 0; n < edge_per_vertex; n++) {
-            const auto neighbor_index = neighbor_indices[n];
-            const auto neighbor_weight = neighbor_weights[n];
-            if(deglib::analysis::checkRNG(graph, edge_per_vertex, vertex_index, neighbor_index, neighbor_weight) == false) 
-                nonMRNG_edges.emplace_back(vertex_index, neighbor_index, neighbor_weight);
-        }
-    }
-    std::sort(nonMRNG_edges.begin(), nonMRNG_edges.end(), [](const auto& x, const auto& y){return x.weight < y.weight;});
-
-    size_t removed_rng_edges = 0;
-    for (size_t i = 0; i < nonMRNG_edges.size(); i++) {
-        const deglib::builder::GraphEdge& edge = nonMRNG_edges[i];
-        if(deglib::analysis::checkRNG(graph, edge_per_vertex, edge.from_vertex, edge.to_vertex, edge.weight) == false) {
-            graph.changeEdge(edge.from_vertex, edge.to_vertex, edge.from_vertex, 0);
-            removed_rng_edges++;
-        }
-    }
-    const auto duration_ms = uint32_t(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count());
+    deglib::optimization::remove_non_mrng_edges_weight_sorted(graph);
 
     // store the graph
     graph.saveGraph(graph_file.c_str());
-
-    fmt::print("Removed {} edges in {} ms. Final graph contains {} non-RNG edges\n", removed_rng_edges, duration_ms, deglib::analysis::calc_non_rng_edges(graph));
 }
 
 void remove_non_mrng_edges_1(const std::string initial_graph_file, const std::string graph_file) {
     fmt::print("Load graph {} \n", initial_graph_file);
     auto graph = deglib::graph::load_sizebounded_graph(initial_graph_file.c_str());
-    fmt::print("Graph with {} vertices and containing {} non-RNG edges\n", graph.size(), deglib::analysis::calc_non_rng_edges(graph));
+    fmt::print("Graph with {} vertices and containing {} non-RNG edges \n", graph.size(), deglib::analysis::calc_non_rng_edges(graph));
 
-    const auto vertex_count = graph.size();
-    const auto edge_per_vertex = graph.getEdgesPerVertex();
-
-    const auto start = std::chrono::steady_clock::now();
-    size_t removed_rng_edges = 0;
-    for (uint32_t i = 0; i < vertex_count; i++) {
-        const auto vertex_index = i;
-
-        // sort neighbors by their weight (highest to lowest)
-        std::vector<std::pair<uint32_t, float>> neighbors;
-        {
-            const auto neighbor_indices = graph.getNeighborIndices(vertex_index);
-            const auto neighbor_weights = graph.getNeighborWeights(vertex_index);
-            for (uint32_t n = 0; n < edge_per_vertex; n++) {
-                const auto neighbor_index = neighbor_indices[n];
-                const auto neighbor_weight = neighbor_weights[n];
-                neighbors.emplace_back(neighbor_index, neighbor_weight);
-            }
-            std::sort(neighbors.begin(), neighbors.end(), [](const auto& x, const auto& y){return x.second < y.second;});
-        }
-
-        // find all none rng conform neighbors
-        std::vector<uint32_t> nonMRNG_edges;
-        for (uint32_t n = 0; n < neighbors.size(); n++) {
-            const auto neighbor_index = neighbors[n].first;
-            const auto neighbor_weight = neighbors[n].second;
-            if(deglib::analysis::checkRNG(graph, edge_per_vertex, vertex_index, neighbor_index, neighbor_weight) == false) 
-                nonMRNG_edges.emplace_back(n);
-        }
-
-        bool removed_edge = false;
-        do {
-            removed_edge = false;
-            for (uint32_t n = 0; n < nonMRNG_edges.size(); n++) {
-                const auto neighbor_index = neighbors[nonMRNG_edges[n]].first;
-                const auto neighbor_weight = neighbors[nonMRNG_edges[n]].second;
-
-                if(deglib::analysis::checkRNG(graph, edge_per_vertex, vertex_index, neighbor_index, neighbor_weight) == false) {
-                    nonMRNG_edges.erase(nonMRNG_edges.begin() + n);
-                    graph.changeEdge(vertex_index, neighbor_index, vertex_index, 0);
-                    removed_rng_edges++;
-                    removed_edge = true;
-                    break;
-                }
-            }
-        } while(removed_edge);
-    }
-    const auto duration_ms = uint32_t(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count());
+    deglib::optimization::remove_non_mrng_edges_iterative(graph);
 
     // store the graph
     graph.saveGraph(graph_file.c_str());
-
-    fmt::print("Removed {} edges in {} ms. Final graph contains {} non-RNG edges\n", removed_rng_edges, duration_ms, deglib::analysis::calc_non_rng_edges(graph));
 }
 
 
@@ -168,7 +89,7 @@ void remove_non_mrng_edges(const std::string initial_graph_file, const std::stri
     auto graph = deglib::graph::load_sizebounded_graph(initial_graph_file.c_str());
     fmt::print("Graph with {} vertices and containing {} non-RNG edges\n", graph.size(), deglib::analysis::calc_non_rng_edges(graph));
 
-    deglib::builder::remove_non_mrng_edges(graph);
+    deglib::optimization::remove_non_mrng_edges(graph);
 
     // store the graph
     graph.saveGraph(graph_file.c_str());
@@ -186,7 +107,7 @@ void optimize_graph(const std::string initial_graph_file, const std::string grap
     auto graph = deglib::graph::load_sizebounded_graph(initial_graph_file.c_str());
     fmt::print("Graph with {} vertices and an avg edge weight of {} \n", graph.size(), deglib::analysis::calc_avg_edge_weight(graph, 100));
 
-    deglib::builder::optimize_edges(graph, k_opt, eps_opt, i_opt, iterations);
+    deglib::optimization::optimize_edges(graph, k_opt, eps_opt, i_opt, iterations);
 
     // store the graph
     graph.saveGraph(graph_file.c_str());

cpp/deglib/include/deglib/builder.h

@@ -1830,100 +1830,5 @@ class EvenRegularGraphBuilder {
     }
 };
 
-/**
- * @brief Removes all edges from the graph that will never be in a MRNG (Monotonic Relative Neighborhood Graph).
- *
- * This function iterates over all vertices and their neighbors, removing any edge that does not satisfy the MRNG condition.
- * The process is parallelized across available hardware threads for efficiency.
- *
- * @param graph Reference to the MutableGraph to be processed.
- */
-void remove_non_mrng_edges(deglib::graph::MutableGraph& graph) {
-
-  const auto vertex_count = graph.size();
-  const auto edge_per_vertex = graph.getEdgesPerVertex();
-
-  const auto start = std::chrono::steady_clock::now();
-  const auto thread_count = std::thread::hardware_concurrency();
-  auto removed_rng_edges_per_thread = std::vector<uint32_t>(thread_count);
-  deglib::concurrent::parallel_for(0, vertex_count, thread_count, [&] (size_t vertex_index, size_t thread_id) {
-    uint32_t removed_rng_edges = 0;
-
-    const auto neighbor_indices = graph.getNeighborIndices(vertex_index);
-    const auto neighbor_weights = graph.getNeighborWeights(vertex_index);
-
-    // find all none rng conform neighbors
-    std::vector<uint32_t> remove_neighbor_ids;
-    for (uint32_t n = 0; n < edge_per_vertex; n++) {
-      const auto neighbor_index = neighbor_indices[n];
-      const auto neighbor_weight = neighbor_weights[n];
-
-      if(deglib::analysis::checkRNG(graph, edge_per_vertex, vertex_index, neighbor_index, neighbor_weight) == false) {
-        remove_neighbor_ids.emplace_back(neighbor_index);
-      }
-    }
-
-    for (uint32_t n = 0; n < remove_neighbor_ids.size(); n++) {
-      graph.changeEdge(vertex_index, remove_neighbor_ids[n], vertex_index, 0);
-      removed_rng_edges++;
-    }
-    removed_rng_edges_per_thread[thread_id] += removed_rng_edges;
-  });
-
-  // aggregate
-  uint32_t removed_rng_edges = 0;
-  for (uint32_t i = 0; i < thread_count; i++) 
-    removed_rng_edges += removed_rng_edges_per_thread[i];
-
-  const auto duration_ms = uint32_t(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count());
-
-	std::cout << "Removed " << removed_rng_edges << " edges in " << duration_ms << " ms. Final graph contains " << deglib::analysis::calc_non_rng_edges(graph) << " non-RNG edges\n";
-}
-
-
-/**
- * @brief Optimizes the edges of the graph using the builder's improvement routines.
- *
- * This function creates a builder and repeatedly attempts to improve the graph's edges for a given number of iterations.
- * It reports progress and statistics during the optimization process.
- *
- * @param graph Reference to the MutableGraph to be optimized.
- * @param k_opt Number of neighbors to consider during optimization.
- * @param eps_opt Epsilon value for neighbor search during optimization.
- * @param i_opt Number of improvement attempts per build step.
- * @param iterations Number of optimization iterations to perform.
- */
-void optimize_edges(deglib::graph::MutableGraph& graph, const uint8_t k_opt, const float eps_opt, const uint8_t i_opt, const uint32_t iterations) {
-    
-  auto rnd = std::mt19937(7);                         // default 7
-
-  // create a graph builder to add vertices to the new graph and improve its edges
-	std::cout << "Start graph builder\n";
-  auto builder = deglib::builder::EvenRegularGraphBuilder(graph, rnd, deglib::builder::StreamingData, 0, 0.0f, k_opt, eps_opt, i_opt, 1, 0);
-  
-  // check the integrity of the graph during the graph build process
-  auto start = std::chrono::steady_clock::now();
-  uint64_t duration_ms = 0;
-  const auto improvement_callback = [&](deglib::builder::BuilderStatus& status) {
-    const auto size = graph.size();
-
-    if(status.step % (iterations/10) == 0) {    
-      duration_ms += uint32_t(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count());
-      auto avg_edge_weight = deglib::analysis::calc_avg_edge_weight(graph, 100);
-      auto valid_weights = deglib::analysis::check_graph_weights(graph) && deglib::analysis::check_graph_regularity(graph, uint32_t(size), true);
-      auto connected = deglib::analysis::check_graph_connectivity(graph);
-
-      auto duration = duration_ms / 1000;
-	    std::cout << std::setw(7) << status.step << " step, " << std::setw(5) << duration << "s, AEW: " << std::fixed << std::setprecision(2) << std::setw(4) << avg_edge_weight << ", " << (connected ? "" : "not") << " connected, " << (valid_weights ? "valid" : "invalid") << "\n";
-      start = std::chrono::steady_clock::now();
-    }
-
-    if(status.step > iterations)
-      builder.stop();
-  };
-
-  // start the build process
-  builder.build(improvement_callback, true);
-}
-
 } // end namespace deglib::builder
+