Delegation+AbsFact for Sets [unfinished]

Author: Kalashnikovni

parser/expr.cpp

@@ -305,8 +305,7 @@ ExprRule<Iterator>::ExprRule(Iterator &it) :
 
   // ------------ //
 
-  inter_times = interval[phx::push_back(qi::_val, qi::_1)]
-    >> *(CARTPROD >> interval)[phx::push_back(qi::_val, qi::_1)];
+  inter_times = interval % CARTPROD;
 
   md_inter = inter_times[qi::_val = phx::construct<AST::MultiDimInter>(qi::_1)];
 
@@ -336,9 +335,9 @@ ExprRule<Iterator>::ExprRule(Iterator &it) :
     [qi::_val = phx::construct<AST::SetUnaryOp>(qi::_1, qi::_2)]; 
 
   set_binary = (OPAREN
-    >> set
+    >> set_expr
     >> set_bin
-    >> set 
+    >> set_expr
     >> CPAREN)[qi::_val = phx::construct<AST::SetBinOp>(qi::_1, qi::_2, qi::_3)];
 
   set_expr = set_unary[qi::_val = qi::_1]
@@ -361,19 +360,18 @@ ExprRule<Iterator>::ExprRule(Iterator &it) :
          , phx::construct<AST::UnaryOp>(AST::UnOp::neg, qi::_1))]
     | lexp_left[qi::_val = phx::construct<AST::LinearExp>(qi::_1, 0)];
 
-  lexp_binary = OPAREN
-    >> lexp[qi::_val = qi::_1] 
-    >> CPAREN 
-    >> *(lexp_bin > OPAREN >> lexp >> CPAREN)
-    [qi::_val = phx::construct<AST::LExpBinOp>(qi::_val, qi::_1, qi::_2)];
+  lexp_binary = (OPAREN
+    >> lexp_expr
+    >> lexp_bin
+    >> lexp_expr
+    >> CPAREN)
+    [qi::_val = phx::construct<AST::LExpBinOp>(qi::_1, qi::_2, qi::_3)];
 
   lexp_expr = lexp_binary[qi::_val = qi::_1]
     | lexp[qi::_val = qi::_1];
 
   // ------------ //
 
-  //lexp_pipe = lexp[phx::push_back(qi::_val, qi::_1)]
-  //  >> *(PIPE >> lexp)[phx::push_back(qi::_val, qi::_1)];
   lexp_pipe = lexp % PIPE;
 
   mdlexp = lexp_pipe[qi::_val = phx::construct<AST::MDLExp>(qi::_1)];
@@ -402,7 +400,7 @@ ExprRule<Iterator>::ExprRule(Iterator &it) :
 
   // ------------ //
 
-  sbg = (V >> set 
+  sbg = (V >> set_expr 
       >> VMAP >> pwl_expr 
       >> MAP1 >> pwl_expr 
       >> MAP2 >> pwl_expr 
@@ -411,7 +409,7 @@ ExprRule<Iterator>::ExprRule(Iterator &it) :
       [qi::_val = phx::construct<AST::SBG>(
          qi::_1, qi::_2, qi::_3, qi::_4, qi::_5, qi::_6
       )]
-   | (V >> set 
+   | (V >> set_expr
       >> VMAP >> pwl_expr 
       >> MAP1 >> pwl_expr 
       >> MAP2 >> pwl_expr 

parser/main.cpp

@@ -72,7 +72,8 @@ void usage()
   std::cout << "\n";
   std::cout << "  * A SBG program starts with a list (possibly empty) of\n";
   std::cout << "    assignments, and then continues with a list (possibly\n";
-  std::cout << "    empty) of expressions.\n";
+  std::cout << "    empty) of expressions, each one separated by a\n";
+  std::cout << "    semicolon.\n";
   std::cout << "  * Each assignment or expression should be ended with a\n";
   std::cout << "    semicolon ;\n";
   std::cout << "  * All expressions defined in a SBG program should have the\n";
@@ -90,8 +91,9 @@ void usage()
   std::cout << "    for linear expressions. As explained above, \"dims\"\n";
   std::cout << "    is also reserved.\n";
   std::cout << "  * Linear expresssions should include a numeric value for\n";
-  std::cout << "    its slope. That is, to express a constant expression\n";
-  std::cout << "    it should be written as: 0*x+h.\n\n";
+  std::cout << "    its slope, except if its value is equal to 1. That is,\n";
+  std::cout << "    to express a constant expression it should be written\n";
+  std::cout << "    as: 0*x+h.\n\n";
 
   std::cout << "A brief list of the available expressions:\n";
   std::cout << "  * Arithmetic.\n";

sbg/af_set.cpp

@@ -0,0 +1,76 @@
+/*******************************************************************************
+
+ This file is part of Set--Based Graph Library.
+
+ SBG Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SBG Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SBG Library.  If not, see <http://www.gnu.org/licenses/>.
+
+ ******************************************************************************/
+
+#include "sbg/af_set.hpp"
+
+namespace SBG {
+
+namespace LIB {
+
+////////////////////////////////////////////////////////////////////////////////
+// Unordered Set AF ------------------------------------------------------------
+////////////////////////////////////////////////////////////////////////////////
+
+Set UnordAF::createSet() const
+{
+  return Set(std::make_unique<UnorderedSet>());
+}
+
+Set UnordAF::createSet(const Util::MD_NAT &x) const
+{
+  return Set(std::make_unique<UnorderedSet>(x));
+}
+
+Set UnordAF::createSet(const Interval &i) const
+{
+  return Set(std::make_unique<UnorderedSet>(i));
+}
+
+Set UnordAF::createSet(const SetPiece &mdi) const
+{
+  return Set(std::make_unique<UnorderedSet>(mdi));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Ordered Set (1 dimension, dense intervals) AF -------------------------------
+////////////////////////////////////////////////////////////////////////////////
+
+Set OrdDenseAF::createSet() const
+{
+  return Set(std::make_unique<OrderedDenseSet>());
+}
+
+Set OrdDenseAF::createSet(const Util::MD_NAT &x) const
+{
+  return Set(std::make_unique<OrderedDenseSet>(x));
+}
+
+Set OrdDenseAF::createSet(const Interval &i) const
+{
+  return Set(std::make_unique<OrderedDenseSet>(i));
+}
+
+Set OrdDenseAF::createSet(const SetPiece &mdi) const
+{
+  return Set(std::make_unique<OrderedDenseSet>(mdi));
+}
+
+} // namespace LIB
+
+} // namespace SBG

sbg/af_set.hpp

@@ -0,0 +1,66 @@
+/** @file af_set.hpp
+
+ @brief <b>Set Abstract Factory</b>
+
+ While developing the SBG library several implementations were proposed. First,
+ two implementations were proposed for sets: unordered and ordered sets. For
+ this reason, it was decided that delegation should be used to provide
+ different implementations, and also an abstract factory was needed to create
+ objects with the desired implementation.
+
+ <hr>
+
+ This file is part of Set--Based Graph Library.
+
+ SBG Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SBG Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SBG Library.  If not, see <http://www.gnu.org/licenses/>.
+
+ ******************************************************************************/
+
+#ifndef SBG_AF_SET_HPP
+#define SBG_AF_SET_HPP
+
+#include "set.hpp"
+
+namespace SBG {
+
+namespace LIB {
+
+struct SetAF {
+  virtual ~SetAF() = default;
+
+  virtual Set createSet() const = 0;
+  virtual Set createSet(const Util::MD_NAT &x) const = 0;
+  virtual Set createSet(const Interval &i) const = 0;
+  virtual Set createSet(const SetPiece &mdi) const = 0;
+};
+
+struct UnordAF : public SetAF {
+  Set createSet() const override;
+  Set createSet(const Util::MD_NAT &x) const override;
+  Set createSet(const Interval &i) const override;
+  Set createSet(const SetPiece &mdi) const override;
+};
+
+struct OrdDenseAF : public SetAF {
+  Set createSet()  const override;
+  Set createSet(const Util::MD_NAT &x) const override;
+  Set createSet(const Interval &i) const override;
+  Set createSet(const SetPiece &mdi) const override;
+};
+
+} // namespace LIB
+
+}  // namespace SBG
+
+#endif

sbg/interval.cpp

@@ -24,8 +24,8 @@ namespace SBG {
 namespace LIB {
 
 Interval::Interval() : begin_(1), step_(1), end_(0) {}
-Interval::Interval(const NAT &x) : begin_(x), step_(1), end_(x) {}
-Interval::Interval(const NAT &begin, const NAT &step, const NAT &end) 
+Interval::Interval(Util::NAT x) : begin_(x), step_(1), end_(x) {}
+Interval::Interval(Util::NAT begin, Util::NAT step, Util::NAT end) 
   : begin_(begin), step_(step), end_(end) 
 {
   if (end >= begin) {
@@ -43,12 +43,9 @@ Interval::Interval(const NAT &begin, const NAT &step, const NAT &end)
   }
 }
 
-NAT Interval::begin() const { return begin_; }
-NAT &Interval::begin_ref() { return begin_; }
-NAT Interval::step() const { return step_; }
-NAT &Interval::step_ref() { return step_; }
-NAT Interval::end() const { return end_; }
-NAT &Interval::end_ref() { return end_; }
+member_imp(Interval, Util::NAT, begin);
+member_imp(Interval, Util::NAT, step);
+member_imp(Interval, Util::NAT, end);
 
 // Operators -------------------------------------------------------------------
 
@@ -88,7 +85,7 @@ unsigned int Interval::cardinal() const
 
 bool Interval::isEmpty() const { return end_ < begin_; }
 
-bool Interval::isMember(const NAT &x) const
+bool Interval::isMember(Util::NAT x) const
 {
   if (x < begin_ || x > end_)
     return false;
@@ -131,7 +128,7 @@ Interval Interval::intersection(const Interval &other)const
 
 // Extra operations ------------------------------------------------------------
 
-Interval Interval::offset(const Util::NAT &off) const
+Interval Interval::offset(Util::NAT off) const
 {
   Util::NAT new_b = begin_ + off, new_e = end_ + off;
 

sbg/interval.hpp

@@ -47,16 +47,13 @@ using MD_NAT = Util::MD_NAT;
 struct Interval {
   using MaybeInterval = std::optional<Interval>;
 
-  NAT begin() const;
-  NAT &begin_ref();
-  NAT step() const;
-  NAT &step_ref();
-  NAT end() const;
-  NAT &end_ref();
+  member_class(NAT, begin);
+  member_class(NAT, step);
+  member_class(NAT, end);
 
   Interval();
-  Interval(const NAT &x);
-  Interval(const NAT &begin, const NAT &step, const NAT &end);
+  Interval(Util::NAT x);
+  Interval(Util::NAT begin, Util::NAT step, Util::NAT end);
 
   bool operator==(const Interval &i) const;
   bool operator!=(const Interval &i) const;
@@ -67,20 +64,15 @@ struct Interval {
    */
   unsigned int cardinal() const;
   bool isEmpty() const;
-  bool isMember(const NAT &x) const;
+  bool isMember(NAT x) const;
   Interval intersection(const Interval &i2) const;
 
   /**
    * @brief Extra operations.
    */
-  Interval offset(const Util::NAT &off) const;
+  Interval offset(Util::NAT off) const;
   Interval least(const Interval &i2) const;
   MaybeInterval compact(const Interval &i2) const;
-
-  private:
-  NAT begin_;
-  NAT step_;
-  NAT end_;
 };
 std::ostream &operator<<(std::ostream &out, const Interval &i);
 

sbg/lexp.cpp

@@ -48,7 +48,7 @@ LExp LExp::operator-(const LExp &other) const
 
 std::ostream &operator<<(std::ostream &out, const LExp &le)
 {
-  RAT slo = le.slope_, off = le.offset_;
+  RAT slo = le.slope(), off = le.offset();
 
   if (slo != 0 && slo != 1) {
     if (slo.numerator() != 1)