Upd

Author: NeiroYT

include/graph/graph.hpp

@@ -77,20 +77,6 @@ class Graph {
     split_distribution_ = std::move(split_dist);
   }
 
-  [[nodiscard]] int getVertexValue(size_t layerID) const {
-    if (layerID >= arrayV_.size()) {
-      throw std::invalid_argument("ArrayV does not contain this ID.");
-    }
-    return arrayV_[layerID];
-  }
-
-  [[nodiscard]] int getEdgeValue(size_t pos) const {
-    if (pos >= arrayE_.size()) {
-      throw std::invalid_argument("ArrayE does not contain this.");
-    }
-    return arrayE_[pos];
-  }
-
   [[nodiscard]] size_t getInputsSize(size_t layerID) const {
     if (layerID >= in_edges_.size()) {
       throw std::invalid_argument("Input edges array do not contain this ID.");
@@ -105,6 +91,21 @@ class Graph {
     return in_edges_[layerID];
   }
 
+  [[nodiscard]] size_t getOutputsSize(size_t layerID) const {
+    if (layerID >= layers_.size()) {
+      throw std::invalid_argument("Layers array do not contain this ID.");
+    }
+    return arrayV_[layerID + 1] - arrayV_[layerID];
+  }
+
+  [[nodiscard]] std::vector<int> getOutLayers(size_t layerID) const {
+    if (layerID >= layers_.size()) {
+      throw std::invalid_argument("Input edges array do not contain this ID.");
+    }
+    return std::vector<int>(arrayE_.begin() + arrayV_[layerID],
+                            arrayE_.begin() + arrayV_[layerID + 1]);
+  }
+
   [[nodiscard]] int getLayersCount() const { return V_; }
 
   [[nodiscard]] std::shared_ptr<Layer> getLayerFromID(size_t layerID) const {
@@ -231,8 +232,9 @@ class Graph {
     }
     // remove outputs
     int amount_connected = arrayV_[id + 1] - arrayV_[id];
+    std::vector<int> arrayE_copy = arrayE_;
     for (int i = 0; i < amount_connected; i++) {
-      removeConnection(id, arrayE_[arrayV_[id] + i]);
+      removeConnection(id, arrayE_copy[arrayV_[id] + i]);
     }
     // remove vertex
     in_edges_.erase(in_edges_.begin() + id);

include/graph_transformations/graph_transformations.hpp

@@ -2,9 +2,26 @@
 #include <vector>
 
 #include "graph/graph.hpp"
+#include "layers/EWLayer.hpp"
 #include "layers/Layer.hpp"
 
 namespace it_lab_ai {
+
+struct IOOrder {
+  std::vector<int> in_order;
+  std::vector<int> out_order;
+  void fill_empty(size_t in_size, size_t out_size) {
+    if (in_order.empty()) {
+      in_order.resize(in_size);
+      std::iota(in_order.begin(), in_order.end(), 0);
+    }
+    if (out_order.empty()) {
+      out_order.resize(out_size);
+      std::iota(out_order.begin(), out_order.end(), 0);
+    }
+  }
+};
+
 std::vector<std::vector<int>> find_subgraphs(const Graph& graph,
                                              const Graph& subgraph);
 bool has_edge(const Graph& graph, int id_from, int id_to);
@@ -13,4 +30,14 @@ bool is_leaf(const Graph& graph, int id);
 bool run_search(const Graph& graph, const Graph& subgraph,
                 std::vector<int>& assignments,
                 std::vector<std::vector<int>>& results);
+
+void change_ids(std::vector<std::vector<int>>& vec, int id);
+bool does_intersect(const std::vector<int>& vec1, const std::vector<int>& vec2);
+void changed_subgraphs(const Graph& graph, const Graph& subgraph_from,
+                       Graph& new_graph, Tensor& out,
+                       const RuntimeOptions& options = RuntimeOptions());
+void changed_subgraphs(const Graph& graph, const Graph& subgraph_from,
+                       const Graph& subgraph_to, Graph& new_graph, Tensor& out,
+                       const RuntimeOptions& options = RuntimeOptions(),
+                       IOOrder order = IOOrder());
 }  // namespace it_lab_ai

src/graph_transformations/CMakeLists.txt

@@ -1,4 +1,4 @@
 file(GLOB_RECURSE graphT_src *.cpp)
 add_library(graphT_lib STATIC "${GRAPHT_HEADERS}" "${graphT_src}")
-target_link_libraries(graphT_lib PUBLIC TBB_unified)
+target_link_libraries(graphT_lib PUBLIC graph_lib TBB_unified)
 add_dependencies(graphT_lib kokkos_external)