[iss-77]

* Debugged MDI compact

* Debugged MDI compact

* Added fixed points

* New UnorderedSet::compact() version

Author: Kalashnikovni

algorithms/matching/matching.cpp

@@ -214,8 +214,6 @@ void BFSMatching::minReachable()
 
 // Matching --------------------------------------------------------------------
 
-bool notEqId(const Map &sbgmap) { return !(sbgmap.isId()); }
-
 MatchInfo::MatchInfo(Set matched_edges, bool fully_matchedU) 
   : matched_edges_(matched_edges), fully_matchedU_(fully_matchedU) {}
 
@@ -309,10 +307,9 @@ member_imp(BFSMatching, bool, debug);
 
 Set BFSMatching::edgesInPaths() const
 {
-  // Vertices that are successor of other vertices in a path
-  Set succs = smap().filterMap([](const Map &sbgmap) {
-    return notEqId(sbgmap);
-  }).image();
+  // Vertices that are successors of other vertices in a path
+  Set not_fixed = smap().dom().difference(smap().fixedPoints());
+  Set succs = smap().restrict(not_fixed).image();
   // Edges whose endings are successors 
   Set ending_edges = mapD().preImage(succs);
   // Map from a 'successor' edge to its start
@@ -325,13 +322,12 @@ Set BFSMatching::edgesInPaths() const
 
 Set BFSMatching::edgesSameRepLR(const PWMap &rmaprmapd) const
 {
-  PWMap rmap_neq_id = rmap().filterMap([](const Map &sbgmap) {
-    return notEqId(sbgmap);
-  });
+  Set not_fixed = rmap().dom().difference(rmap().fixedPoints());
+  PWMap rmap_neq_id = rmap().restrict(not_fixed);
   PWMap rmapb = rmap_neq_id.composition(mapB());
-  PWMap rmaprmapd_neq_id = rmaprmapd.filterMap([](const Map &sbgmap) {
-    return notEqId(sbgmap);
-  }); 
+
+  not_fixed = rmaprmapd.dom().difference(rmaprmapd.fixedPoints());
+  PWMap rmaprmapd_neq_id = rmaprmapd.restrict(not_fixed);
   PWMap rmaprmapdb = rmaprmapd_neq_id.composition(mapB());
 
   return rmapb.equalImage(rmaprmapdb);

algorithms/misc/causalization_builders.cpp

@@ -26,8 +26,6 @@ namespace MISC {
 
 using namespace SBG::LIB;
 
-bool eqId(const Map &sbgmap) { return sbgmap.isId(); }
-
 DSBG buildSCCFromMatching(const BFSMatching &match)
 {
   const PWMapAF &fact = match.fact();
@@ -74,9 +72,7 @@ DSBG buildSortFromSCC(const SCC &scc, const PWMap &rmap)
   mapD = mapD.compact();
 
   PWMap aux_rmap = rmap.compact();
-  PWMap reps_rmap = aux_rmap.filterMap([](const Map &sbgmap) {
-    return eqId(sbgmap);
-  });
+  PWMap reps_rmap = aux_rmap.restrict(aux_rmap.fixedPoints());
   Set V = reps_rmap.dom();
 
   PWMap Vmap = dsbg.Vmap().restrict(V);

sbg/map.cpp

@@ -136,13 +136,7 @@ std::ostream &operator<<(std::ostream &out, const Map &m)
 
 // Map operations --------------------------------------------------------------
 
-std::size_t Map::arity() const
-{
-  if (dom_.isEmpty())
-    return 0;
-
-  return dom_.arity();
-}
+std::size_t Map::arity() const { return exp_.arity(); }
 
 bool Map::isEmpty() const { return dom_.isEmpty(); }
 
@@ -217,6 +211,26 @@ Map Map::composition(const Map &other) const
   return Map(fact_, res_dom, res_exp);
 }
 
+Set Map::fixedPoints() const
+{
+  Interval univ_one_dim(0, 1, Inf);
+  SetPiece allowed;
+  for (unsigned int j = 0; j < arity(); ++j) {
+    LExp jth = exp_[j];
+
+    if (jth.isId())
+      allowed.emplaceBack(univ_one_dim);
+
+    else if (jth.isConstant())
+      allowed.emplaceBack(Interval(jth.offset().toNat()));
+ 
+    else
+      return fact_.createSet();
+  }
+
+  return dom_.intersection(fact_.createSet(allowed));
+}
+
 // Extra operations ------------------------------------------------------------
 
 Map Map::minInv() const

sbg/map.hpp

@@ -131,6 +131,11 @@ struct Map {
    */
   Map composition(const Map &other) const;
 
+  /**
+   * @brief Calculates the set of elements in the domain such that f(x) = x.
+   */
+  Set fixedPoints() const;
+
   // Extra operations ----------------------------------------------------------
 
   /**

sbg/multidim_inter.cpp

@@ -185,17 +185,19 @@ MaybeMDI MultiDimInter::compact(const MultiDimInter &other) const
   unsigned int j = 0;
   for (; j < arity(); ++j) {
     auto ith = operator[](j).compact(other[j]);
-    if (ith) {
-      res.emplaceBack(ith.value());
-      ++j;
-      break;
-    }
+    if (operator[](j) == other[j])
+      res.emplaceBack(operator[](j));
 
-    else if (operator[](j) != other[j])
-      return {};
+    else {
+      if (ith) {
+        res.emplaceBack(ith.value());
+        ++j;
+        break;
+      }
 
-    else
-      res.emplaceBack(operator[](j));
+      else
+        return {};
+    }
   }
 
   for (; j < arity(); ++j) {

sbg/pw_map.cpp

@@ -166,8 +166,7 @@ PWMapDelegPtr UnordPWMap::operator-(const PWMapDelegate &other) const
   if (isEmpty() || other.isEmpty())
     return res;
 
-  Interval all(0, 1, Inf);
-  Set univ = fact_.createSet(SetPiece(arity(), all));
+  Set univ = fact_.createSet(SetPiece(arity(), Interval(0, 1, Inf)));
 
   UnordPWMapCRef othr = static_cast<UnordPWMapCRef>(other);
   for (const Map &m1 : pieces_) {
@@ -386,6 +385,16 @@ PWMapDelegPtr UnordPWMap::mapInf(unsigned int n) const
 
 PWMapDelegPtr UnordPWMap::mapInf() const { return mapInf(0); }
 
+Set UnordPWMap::fixedPoints() const
+{
+  Set res = fact_.createSet();
+
+  for (const Map &m : pieces_)
+    res = res.disjointCup(m.fixedPoints());
+
+  return res;
+}
+
 // Extra operations ------------------------------------------------------------
 
 PWMapDelegPtr UnordPWMap::concatenation(const PWMapDelegate &other) const
@@ -838,6 +847,8 @@ PWMap PWMap::mapInf(unsigned int n) const { return delegate_->mapInf(n); }
 
 PWMap PWMap::mapInf() const { return delegate_->mapInf(); }
 
+Set PWMap::fixedPoints() const { return delegate_->fixedPoints(); }
+
 PWMap PWMap::concatenation(const PWMap &other) const
 {
   return delegate_->concatenation(*other.delegate_);

sbg/pw_map.hpp

@@ -163,6 +163,11 @@ struct PWMapDelegate {
    */
   virtual PWMapDelegPtr mapInf() const = 0;
 
+  /**
+   * @brief Calculates the set of elements in the domain such that f(x) = x.
+   */
+  virtual Set fixedPoints() const = 0;
+
   // Extra operations ----------------------------------------------------------
 
   /** 
@@ -317,6 +322,7 @@ struct UnordPWMap : public PWMapDelegate {
 
   PWMapDelegPtr mapInf(unsigned int n) const override;
   PWMapDelegPtr mapInf() const override;
+  Set fixedPoints() const override;
 
   // Extra operations ----------------------------------------------------------
 
@@ -399,6 +405,7 @@ struct PWMap {
 
   PWMap mapInf(unsigned int n) const;
   PWMap mapInf() const;
+  Set fixedPoints() const;
 
   // Extra operations ----------------------------------------------------------
 

sbg/set.cpp

@@ -17,6 +17,8 @@
 
  ******************************************************************************/
 
+#include <set>
+
 #include "sbg/set.hpp"
 
 namespace SBG {
@@ -234,8 +236,8 @@ SetDelegPtr UnorderedSet::complementAtom() const
   for (const Interval &i : mdi) dense_mdi.emplaceBack(Interval(i.begin(), 1, i.end()));
   SetPiece during_mdi = dense_mdi;
 
-  Interval univ(0, 1, Inf);
-  SetPiece all(mdi.arity(), univ);
+  Interval univ_one_dim(0, 1, Inf);
+  SetPiece univ(mdi.arity(), univ_one_dim);
 
   unsigned int dim = 0;
   for (const Interval &i : mdi) {
@@ -245,9 +247,9 @@ SetDelegPtr UnorderedSet::complementAtom() const
     if (i.begin() != 0) {
       Interval i_res(0, 1, i.begin() - 1);
       if (!i_res.isEmpty()) {
-        all[dim] = i_res;
-        c.push_back(all);
-        all[dim] = univ;
+        univ[dim] = i_res;
+        c.push_back(univ);
+        univ[dim] = univ_one_dim;
       }
     }
 
@@ -268,12 +270,12 @@ SetDelegPtr UnorderedSet::complementAtom() const
     if (i.end() < Inf) {
       Interval i_res(i.end() + 1, 1, Inf);
       if (!i_res.isEmpty()) {
-        all[dim] = i_res;
-        c.push_back(all);
-        all[dim] = univ;
+        univ[dim] = i_res;
+        c.push_back(univ);
+        univ[dim] = univ_one_dim;
       }
     }
-    all[dim] = dense_mdi[dim];
+    univ[dim] = dense_mdi[dim];
     during_mdi[dim] = i;
 
     // Insert results of current dim
@@ -289,15 +291,17 @@ SetDelegPtr UnorderedSet::complement() const
 {
   SetDelegPtr res = std::make_unique<UnorderedSet>(MDIUnordSet());
 
-  auto first_it = pieces_.begin();
-  SetPiece first = *first_it;
-  res = std::move(UnorderedSet(first).complementAtom());
+  if (!isEmpty()) {
+    auto first_it = pieces_.begin();
+    SetPiece first = *first_it;
+    res = std::move(UnorderedSet(first).complementAtom());
 
-  ++first_it;
-  MDIUnordSet second(first_it, pieces_.end());
-  for (const SetPiece &mdi : second) {
-    SetDelegPtr c = UnorderedSet(mdi).complementAtom();
-    res = std::move(res->intersection(*c));
+    ++first_it;
+    MDIUnordSet second(first_it, pieces_.end());
+    for (const SetPiece &mdi : second) {
+      SetDelegPtr c = UnorderedSet(mdi).complementAtom();
+      res = std::move(res->intersection(*c));
+    }
   }
 
   return res;
@@ -355,27 +359,38 @@ SetDelegPtr UnorderedSet::offset(const MD_NAT &off) const
 
 SetDelegPtr UnorderedSet::compact() const
 {
-  // New idea TODO
-  // MDIUnordSet old_compact = pieces_, compact = old_compact;
-  // SetPiece ith(compact.begin());
-  // do {
-  //  for (const SetPiece &mdi : compact) {
-  //    auto ith_compact = ith.compact(mdi);
-  //    if (ith_compact)
-  //      ith = ith_compact.value();
-  //  }
-  //  MDIUnordSet aux_compact = compact;
-  //  for (const SetPiece &mdi : aux_compact) {
-  //    if (!ith.intersection(mdi).isEmpty())
-  //      compact.erase(mdi);
-  //  }
-  //  compact.emplace(ith);
-  //} while (old_compact != compact);
-
-  // std::shared_ptr<UnorderedSet> res = std::make_shared<UnorderedSet>();
-  // res->pieces_ = pieces_.compact();
-
-  return std::make_unique<UnorderedSet>(pieces_);
+  MDIUnordSet res;
+
+  if (!isEmpty()) {
+    std::set<SetPiece> prev(pieces_.begin(), pieces_.end()), actual = prev;
+    do {
+      prev = actual;
+      actual = std::set<SetPiece>();
+
+      std::set<SetPiece>::iterator ith = prev.begin(), last = prev.end();
+      std::set<SetPiece> to_erase;
+      for (; ith != last; ++ith) {
+        SetPiece ith_compact = *ith;
+        std::set<SetPiece>::iterator next = ith;
+        ++next;
+        for (; next != last; ++next) {
+          MaybeMDI new_compact = ith_compact.compact(*next);
+          if (new_compact) {
+            ith_compact = new_compact.value();
+            to_erase.insert(*next);
+          }
+        }
+
+        if (to_erase.find(ith_compact) == to_erase.end())
+          actual.insert(ith_compact);
+      }
+    } while (actual != prev);
+
+    for (const SetPiece &mdi : actual)
+      res.push_back(mdi);
+  }
+
+  return std::make_unique<UnorderedSet>(res);
 }
 
 ////////////////////////////////////////////////////////////////////////////////