Added copy for Bipartite SBGs

Author: Kalashnikovni

eval/visitors/func_evaluator.cpp

@@ -703,12 +703,10 @@ ExprBaseType BuiltInFunctions::matchingEvaluator(const EBTList& args)
   LIB::Matching match_impl = LIB::MATCH_FACT.createMatchAlgorithm();
   const auto matching_evaluator = Util::Overload {
     [&match_impl](LIB::BipartiteSBG a, LIB::NAT b) { 
-      // TODO return ExprBaseType{match_impl.calculate(a.copy(b))};
-      return ExprBaseType{match_impl.calculate(a)};
+      return ExprBaseType{match_impl.calculate(copy(b, a))};
     },
     [&match_impl](LIB::BipartiteSBG a, LIB::MD_NAT b) { 
-      // TODO return ExprBaseType{match_impl.calculate(a.copy(b[0]))};
-      return ExprBaseType{match_impl.calculate(a)};
+      return ExprBaseType{match_impl.calculate(copy(b[0], a))};
     },
     [](auto a, auto b) {
       Util::ERROR("matchingEvaluator: wrong arguments ", a, ", ", b
@@ -784,14 +782,12 @@ ExprBaseType BuiltInFunctions::matchSCCEvaluator(const EBTList& args)
   LIB::SCC scc_impl = LIB::SCC_FACT.createSCCAlgorithm();
   const auto match_scc_evaluator = Util::Overload {
     [&match_impl, &scc_impl](LIB::BipartiteSBG a, LIB::NAT b) { 
-      // TODO LIB::MatchData match_result = match_impl.calculate(a.copy(b));
-      LIB::MatchData match_result = match_impl.calculate(a);
+      LIB::MatchData match_result = match_impl.calculate(copy(b, a));
       LIB::DirectedSBG dsbg = misc::buildSCCFromMatching(match_result);
       return ExprBaseType{scc_impl.calculate(dsbg).rmap()};
     },
     [&match_impl, &scc_impl](LIB::BipartiteSBG a, LIB::MD_NAT b) { 
-      // TODO LIB::MatchData match_result = match_impl.calculate(a.copy(b[0]));
-      LIB::MatchData match_result = match_impl.calculate(a);
+      LIB::MatchData match_result = match_impl.calculate(copy(b[0], a));
       LIB::DirectedSBG dsbg = misc::buildSCCFromMatching(match_result);
       return ExprBaseType{scc_impl.calculate(dsbg).rmap()};
     },

sbg/bipartite_sbg.cpp

@@ -67,7 +67,8 @@ void BipartiteSBG::addSetVertex(const Set& X, const Set& Y)
 {
   Set vertices = X.cup(Y);
   if (!vertices.intersection(_V).isEmpty()) {
-    Util::ERROR("Trying to add existing vertices: ", vertices, " to SBG\n");
+    Util::ERROR("BipartiteSBG::addSetVertex: trying to add existing vertices: "
+      , vertices, " to SBG\n");
   } else if (!vertices.isEmpty()) {
     _V = _V.cup(vertices);
     Set set_vertices = _Vmap.image();
@@ -86,8 +87,8 @@ void BipartiteSBG::addSetEdge(const PWMap& pw1, const PWMap& pw2)
   Set edges1 = pw1.domain();
   Set edges2 = pw2.domain();
   if (edges1 != edges2) {
-    // TODO
-    Util::ERROR("The domain of ", edges1, " is different from ", edges2, "\n");
+    Util::ERROR("BipartiteSBG::addSetEdge: ", edges1, " is different from "
+      , edges2, "\n");
   } else if (edges1.intersection(_E).isEmpty()) {
     Set edges = edges1;
     if (!edges.isEmpty()) {
@@ -102,7 +103,8 @@ void BipartiteSBG::addSetEdge(const PWMap& pw1, const PWMap& pw2)
       _Emap.emplace(edges, max + one_all_dims);
     }
   } else {
-    Util::ERROR("Trying to add existing edges: ", edges1, " to SBG\n");
+    Util::ERROR("BipartiteSBG::addSetEdge: trying to add existing edges: "
+      , edges1, " to SBG\n");
   }
 }
 
@@ -122,6 +124,67 @@ std::ostream& operator<<(std::ostream& out, const BipartiteSBG& g)
   return out;
 }
 
+// Extra operations ------------------------------------------------------------
+
+BipartiteSBG copy(unsigned int copies, BipartiteSBG sbg)
+{
+  if (copies == 0) {
+    Util::ERROR("BipartiteSBG::copy: zeros copies is not allowed\n");
+  }
+
+  Set X = sbg.X();
+  Set Y = sbg.Y();
+  Set V = sbg.V();
+  PWMap Vmap = sbg.Vmap();
+  PWMap map1 = sbg.map1();
+  PWMap map2 = sbg.map2();
+  PWMap Emap = sbg.Emap();
+  Set E = sbg.E();
+
+  for (unsigned int j = 1; j < copies; ++j) {
+    MD_NAT max_v = sbg.V().maxElem();
+    Set set_vertices = Vmap.image();
+    while (!set_vertices.isEmpty()) {
+      Set min_elem_set = SET_FACT.createSet(set_vertices.minElem());
+      Set vertices = Vmap.preImage(min_elem_set);
+      Set jth_X = vertices.intersection(X);
+      Set jth_Y = vertices.intersection(Y);
+      sbg.addSetVertex(jth_X.offset(max_v), jth_Y.offset(max_v));
+
+      set_vertices = set_vertices.difference(min_elem_set);
+    }
+
+    Expression offset_v;
+    for (std::size_t k = 0; k < max_v.arity(); ++k) {
+      offset_v = offset_v.cartesianProduct(Expression{1, max_v[k]});
+    }
+    PWMap offset_pw_v = PWMAP_FACT.createPWMap(Map{V, offset_v});
+
+    MD_NAT max_e = sbg.E().maxElem();
+    Expression offset_e;
+    for (std::size_t k = 0; k < max_e.arity(); ++k) {
+      offset_e = offset_e.cartesianProduct(Expression{1, max_e[k]});
+    }
+    PWMap offset_pw_e = PWMAP_FACT.createPWMap(Map{E, offset_e});
+    PWMap inverse_offset_pw_e = offset_pw_e.inverse();
+
+    Set set_edges = Emap.image();
+    while (!set_edges.isEmpty()) {
+      Set min_elem_set = SET_FACT.createSet(set_edges.minElem());
+      Set edges = Emap.preImage(min_elem_set);
+      PWMap pw1 = map1.restrict(edges);
+      PWMap pw2 = map2.restrict(edges);
+      pw1 = offset_pw_v.composition(pw1.composition(inverse_offset_pw_e));
+      pw2 = offset_pw_v.composition(pw2.composition(inverse_offset_pw_e));
+      sbg.addSetEdge(pw1, pw2);
+
+      set_edges = set_edges.difference(min_elem_set);
+    }
+  }
+
+  return sbg;
+}
+
 } // namespace LIB
 
 } // namespace SBG

sbg/bipartite_sbg.hpp

@@ -97,6 +97,8 @@ class BipartiteSBG {
 
 std::ostream& operator<<(std::ostream& out, const BipartiteSBG& g);
 
+BipartiteSBG copy(unsigned int copies, BipartiteSBG sbg);
+
 } // namespace LIB
 
 }  // namespace SBG