[iss-45]

Author: LucasCavagna

sbg/af_pwmap.cpp

@@ -51,6 +51,11 @@ PWMap UnordPWMapAF::createPWMap(const Map &m) const
   return PWMap(std::make_unique<UnordPWMap>(map_fact_, m));
 }
 
+
+////////////////////////////////////////////////////////////////////////////////
+// OrdPWMap AF -----------------------------------------------------------------
+////////////////////////////////////////////////////////////////////////////////
+
 OrdPWMapAF::OrdPWMapAF(const MapAF &map_fact) : PWMapAF(map_fact) {}
 
 PWMap OrdPWMapAF::createPWMap() const
@@ -68,6 +73,7 @@ PWMap OrdPWMapAF::createPWMap(const Map &m) const
   return PWMap(std::make_unique<OrdPWMap>(map_fact_, m));
 }
 
+
 } // namespace LIB
 
 } // namespace SBG

sbg/af_pwmap.hpp

@@ -64,6 +64,8 @@ struct OrdPWMapAF : public PWMapAF {
   PWMap createPWMap(const Map &m) const override;
 };
 
+
+
 } // namespace LIB
 
 }  // namespace SBG

sbg/interval.cpp

@@ -143,21 +143,16 @@ Interval Interval::least(const Interval &other) const
 MaybeInterval Interval::compact(const Interval &other) const
 {
   if (step_ == other.step_) {
-    if (end_ + step_ == other.begin_) 
+    if (end_+step_ == other.begin_)
       return Interval(begin_, step_, other.end_);
-    
-    else if (other.end_ + step_ == begin_) 
+
+    else if (other.end_+step_ == begin_)
       return Interval(other.begin_, step_, end_);
-    
-    else {
-      Interval inter = intersection(other);
-      if (!inter.isEmpty()) {
-        if (inter == other)
-          return {};
-        NAT new_b = std::min(begin_, other.begin_);
-        NAT new_e = std::max(end_, other.end_);
-        return Interval(new_b, step_, new_e);
-      }
+
+    else if (!intersection(other).isEmpty()) {
+      NAT new_b = std::min(begin_, other.begin_);
+      NAT new_e = std::max(end_, other.end_);
+      return Interval(new_b, step_, new_e);
     }
   }
 

sbg/map.cpp

@@ -84,9 +84,6 @@ SetPiece image(SetPiece mdi, Exp mdle)
 member_move_imp(Map, Set, dom);
 member_move_imp(Map, Exp, exp);
 
-
-
-
 Map::~Map() {}
 Map::Map(const SetAF &fact) : fact_(fact), dom_(fact.createSet()){}
 Map::Map(const SetAF &fact, MD_NAT x, Exp exp)
@@ -124,51 +121,6 @@ Map &Map::operator=(const Map &other)
   return *this;
 }
 
-bool Map::operator<(const Map &other) const
-{ 
-
-  return minPer() < other.minPer();
-}
-
-
-
-MD_NAT Map::minPer() const
-{
-    MD_NAT minimo(dom_.arity(), Inf);
- 
-    if (dom_.isEmpty()) 
-        return minimo; 
-    
-    for (const SetPiece &mdi : dom_) {
-        MD_NAT candidato = mdi.minElem();
-        
-        for (std::size_t i = 0; i < minimo.arity(); ++i) {
-            minimo[i] = std::min(minimo[i], candidato[i]);
-        }
-    }
-    
-    return minimo;
-}
-
-MD_NAT Map::maxPer() const
-{
-    MD_NAT maximo(dom_.arity(), 0);
-    
-    if (dom_.isEmpty()) 
-        return maximo; 
-        
-    
-    for (const SetPiece &mdi : dom_) {
-        MD_NAT candidato = mdi.maxElem();
-        
-        for (std::size_t i = 0; i < maximo.arity(); ++i) {
-            maximo[i] = std::max(maximo[i], candidato[i]);
-        }
-    }
-  
-    return maximo;
-}
-
 
 Map Map::operator+(const Map &other) const
 {
@@ -300,25 +252,6 @@ MaybeMap Map::compact(const Map &other) const
   return {};
 }
 
-/*
-void Map::calcularMinMaxPer() {
-    MD_NAT maximo(dom_.arity(), 0);
-    MD_NAT minimo(dom_.arity(), Inf); 
-    
-    for (const SetPiece &mdi : dom_) {
-      MD_NAT candidatoMax = mdi.maxElem();
-      MD_NAT candidatoMin = mdi.minElem();
-      
-      for (std::size_t i = 0; i < maximo.arity(); ++i) {
-          maximo[i] = std::max(maximo[i], candidatoMax[i]);
-          minimo[i] = std::min(minimo[i], candidatoMin[i]);
-      }
-    }
-    
-    minPer_ = minimo;
-    maxPer_ = maximo;
-}*/
-
 } // namespace LIB
 
 } // namespace SBG

sbg/map.hpp

@@ -85,10 +85,6 @@ struct Map {
   bool operator==(const Map &other) const;
   bool operator!=(const Map &other) const;
   Map &operator=(const Map &other);
-  bool operator<(const Map &other) const;
-
-  MD_NAT minPer() const;
-  MD_NAT maxPer() const;
 
   /**
    * @brief Calculates the sum of both maps for elements that belong to both
@@ -153,7 +149,6 @@ struct Map {
    */
   MaybeMap compact(const Map &other) const;
 
-  //void calcularMinMaxPer();
 };
 std::ostream &operator<<(std::ostream &out, const Map &s);
 

sbg/multidim_inter.cpp

@@ -186,17 +186,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) {