Fix to Buffer and Opt of CH

Author: Azzaare

include/buffer.hpp

@@ -69,15 +69,15 @@ template <class T, class D> Buffer<T, D>::Buffer(int size) {
   Getters
 ==============================================================================*/
 template <class T, class D> Data<T, D> Buffer<T, D>::top(int k) {
-  if (k < mSize) {
+  if (k <= mSize) {
     int index = (k + mStart - 1) % mSize; // -1 match the start of vectors at 0
     return *(mExplicit[index]);
   }
   throw "Access to a top element bigger than the size of the buffer";
 }
 
 template <class T, class D> SPData<T, D> Buffer<T, D>::topPointer(int k) {
-  if (k < mSize) {
+  if (k <= mSize) {
     int index = (k + mStart - 1) % mSize; // -1 match the start of vectors at 0
     return mExplicit[index];
   }
@@ -101,7 +101,11 @@ void Buffer<T, D>::setData(SPData<T, D> elt, int id) {
 ==============================================================================*/
 template <class T, class D> void Buffer<T, D>::push(SPData<T, D> elt) {
   if (mSize > 0) {
-    setData(elt, mStart + 1);
+    if ((int) mExplicit.size() < mSize) {
+      mExplicit.push_back(elt);
+    } else {
+      setData(elt, mStart + 1);
+    }
   }
 }
 

include/compressedStack.hpp

@@ -405,7 +405,7 @@ SPData<T, D> CompressedStack<T, D>::getExplicitData(int k) {
   if (k <= (int)mFirst.mExplicit.size()) {
     return mFirst.mExplicit[k - 1];
   } else {
-    return mFirst.mSign.mBuffer.topPointer(k - 1 - mFirst.mExplicit.size());
+    return mFirst.mSign.mBuffer.topPointer(k - mFirst.mExplicit.size());
   }
 }
 
@@ -451,16 +451,12 @@ template <class T, class D> std::string CompressedStack<T, D>::toString() {
 // Function push that push the data in explicit and index in partial/compressed
 template <class T, class D>
 void CompressedStack<T, D>::push(const Data<T, D> &elt) {
-  std::cout << " inside comp stack goinbg to push "<< std::endl;
   // update the buffer (if buffer size is bigger than 0)
   SPData<T, D> ptr_elt = std::make_shared<Data<T, D>>(elt);
-  std::cout << " inside comp stack made buffer "<< std::endl;
   mBuffer.push(ptr_elt);
   // update the explicit Blocks, with possibly shifting first to second
-  std::cout << " inside comp stack going to push explicit "<< std::endl;
   pushExplicit(ptr_elt);
   // update the compressed Blocks at each levels (including fully compressed)
-  std::cout << " inside comp stack pushed explicit "<< std::endl;
   for (int lvl = mDepth - 1; lvl > 0; lvl--) {
     int headIndex = getLast(lvl);
     pushCompressed(ptr_elt, lvl, headIndex);
@@ -476,7 +472,10 @@ void CompressedStack<T, D>::pushExplicit(SPData<T, D> elt) {
   // If the explicit datas of component 1 are empty we push
   if (empty(mDepth, 1)) {
     mFirst.pushExplicit(eltPtr);
-    std::shared_ptr<T> context = std::make_shared<T>(*mContext);
+    std::shared_ptr<T> context;
+    if (mContext != nullptr) {
+      context = std::make_shared<T>(*mContext);
+    }
     Signature<T, D> sign(index, mPosition, context, mBuffer);
     mFirst.mSign = sign;
   }

include/convexHull.hpp

@@ -3,48 +3,52 @@
 #include "Point2D.hpp"
 
 
+/*==============================================================================
+  Empty type for the context (empty for the Convex Hull problem)
+==============================================================================*/
+class emptyContext{};
+
 /*==============================================================================
   Instantiation of a problem
 ==============================================================================*/
-class convexHull : public Problem<std::nullptr_t, Point2D> {
+class convexHull : public Problem<emptyContext, Point2D> {
 public:
-    convexHull(std::string filePath) : Problem<std::nullptr_t, Point2D>(filePath) {}
+    convexHull(std::string filePath) : Problem<emptyContext, Point2D>(filePath) {}
 
 private:
     // Functions to run the stack
     Point2D readInput(std::vector<std::string> line);
 
-    std::shared_ptr<std::nullptr_t> initStack();
+    std::shared_ptr<emptyContext> initStack();
 
     bool popCondition(Point2D data);
 
-    void popAction(Data<std::nullptr_t, Point2D> elt);
+    void popAction(Data<emptyContext, Point2D> elt);
 
     bool pushCondition(Point2D data);
 
-    void pushAction(Data<std::nullptr_t, Point2D> elt);
+    void pushAction(Data<emptyContext, Point2D> elt);
 };
 
 /*==============================================================================
   Instantiation of a comparison
 ==============================================================================*/
 
-class comparisonConvexHull : public CompareStacks<int, int> {
+class comparisonConvexHull : public CompareStacks<emptyContext, Point2D> {
 public:
-    comparisonConvexHull(std::string filePath) : CompareStacks<int, int>(filePath) {}
+    comparisonConvexHull(std::string filePath) : CompareStacks<emptyContext, Point2D>(filePath) {}
 
 private:
     // Functions to run the stack
-    int readInput(std::vector<std::string> line);
-
-    std::shared_ptr<int> initStack();
+    Point2D readInput(std::vector<std::string> line);
 
-    bool popCondition(int data);
+    std::shared_ptr<emptyContext> initStack();
 
-    void popAction(Data<int, int> elt);
+    bool popCondition(Point2D data);
 
-    bool pushCondition(int data);
+    void popAction(Data<emptyContext, Point2D> elt);
 
-    void pushAction(Data<int, int> elt);
+    bool pushCondition(Point2D data);
 
-};
+    void pushAction(Data<emptyContext, Point2D> elt);
+};

include/problem.hpp

@@ -39,7 +39,6 @@ template <class T, class D> class Problem {
   // Running the stack
   void run();
   void run(int limit);
-  void readPush(int iter = 1);
   void push(Data<T, D> elt);
   Data<T, D> pop();
   Data<T, D> top(int k);
@@ -109,13 +108,9 @@ Problem<T, D>::Problem(std::string fileName) : mIndex(0), mContext(nullptr) {
     if (parameters[i].compare("b") == 0) {
       foundBuffer = true;
       b = stoi(parameters[i + 1]);
-      //std::cout<<"found buffer "<<b<<std::endl;
     }
   }
 
-  //  std::cout << "reading all shit n,p,b,foundP,foundBuffer "<<n<<" "<<p<<"
-  //  "<<b<<" "<<foundP<<" "<<foundBuffer<<std::endl;
-
   if (foundBuffer && !foundP)
     throw("Problem<T,D>::Problem(std::string fileName), wrong header format ");
   if (!foundP)
@@ -130,31 +125,12 @@ Problem<T, D>::Problem(std::string fileName) : mIndex(0), mContext(nullptr) {
   }
 }
 
-/*template <class T, class D>
-Problem<T,D>::Problem(std::string fileName, int size)
-: mIndex(0)
-, mContext(nullptr)
-, mStack(new NormalStack<T,D> (size)){
-  mInput.open(fileName, std::ifstream::in);
-}
-
-template <class T, class D>
-Problem<T,D>::Problem(std::string fileName, int size, int space, int buffer)
-: mIndex(0)
-, mContext(nullptr){
-  mInput.open(fileName, std::ifstream::in);
-  std::streampos position = mInput.tellg();
-  mStack = std::shared_ptr<Stack<T,D>> (new CompressedStack<T,D> (size, space,
-buffer, mContext));
-
-}*/
-
 /*==============================================================================
   IO : toString, print, println
 ==============================================================================*/
 template <class T, class D> std::string Problem<T, D>::toString() {
   std::string str;
-  str = "Problem with an actual index of " + std::to_string(mIndex);
+  str = "Instance with an actual index of " + std::to_string(mIndex);
   str += ", with a stack of type\n";
   str += mStack->toString();
   return str;
@@ -206,30 +182,23 @@ std::vector<std::string> Problem<T, D>::readHeader() {
 }
 
 template <class T, class D> void Problem<T, D>::readPush(int iter) {
-  std::cout << " read push start " << std::endl;
-
   for (int i = 0; i < iter; i++) {
     std::streampos position = mInput.tellg();
     (*mStack).setPosition(position);
     std::vector<std::string> line = readLine();
     D data = readInput(line);
     mIndex++;
-    std::cout << " read push read "<<data << std::endl;
-
     Data<T, D> elt(mIndex, data);
     pushAction(elt);
     push(elt);
-    std::cout << " pushed read "<<data << std::endl;
-
   }
-  std::cout << " read push end " << std::endl;
-
 }
 
 
 /*==============================================================================
   Stack Functions: run, push, pop, top, readPush
 ==============================================================================*/
+// TODO: Make popLoop, pushStep and so on functions
 template <class T, class D> void Problem<T, D>::run() {
   initStackIntern();
   while (mInput.good()) {
@@ -240,8 +209,7 @@ template <class T, class D> void Problem<T, D>::run() {
       break;
     }
     D data = readInput(line);
-    mIndex++; // Might have to move
-    std::cout << " Starting loop for "<<data << std::endl;
+    mIndex++;
     while ((!emptystack()) && (popCondition(data))) {
       Data<T, D> elt = pop();
       popAction(elt);
@@ -262,7 +230,7 @@ template <class T, class D> void Problem<T, D>::run(int limit) {
     std::vector<std::string> line = readLine();
 
     D data = readInput(line);
-    mIndex++; // Might have to move
+    mIndex++;
 
     while ((!emptystack()) && (popCondition(data))) {
       Data<T, D> elt = pop();
@@ -276,25 +244,8 @@ template <class T, class D> void Problem<T, D>::run(int limit) {
   }
 }
 
-template <class T, class D> void Problem<T, D>::readPush(int iter) {
-  for (int i = 0; i < iter; i++) {
-    std::streampos position = mInput.tellg();
-    (*mStack).setPosition(position);
-    std::vector<std::string> line = readLine();
-    D data = readInput(line);
-    mIndex++;
-    Data<T, D> elt(mIndex, data);
-    pushAction(elt);
-    push(elt);
-  }  
-}
-
 template <class T, class D> void Problem<T, D>::push(Data<T, D> elt) {
-  std::cout << " goinbg to push "<<elt.getData() << std::endl;
-
   mStack->push(elt);
-  std::cout << " pushed "<<elt.getData() << std::endl;
-
 }
 template <class T, class D> Data<T, D> Problem<T, D>::pop() {
   return mStack->pop(*this);

src/convexHull.cpp

@@ -16,7 +16,7 @@ double y = std::stof(line[1]);
 return p;
 }
 
-std::shared_ptr<std::nullptr_t> convexHull::initStack() {
+std::shared_ptr<emptyContext> convexHull::initStack() {
 
     std::cout<<"going to read two values "<<std::endl;
 
@@ -26,7 +26,7 @@ std::shared_ptr<std::nullptr_t> convexHull::initStack() {
     std::cout<<"done reading two values "<<std::endl;
 
     // then initialize context (which in this case is NULL everything
-    std::shared_ptr<std::nullptr_t> context(new std::nullptr_t());
+    std::shared_ptr<emptyContext> context;
     return context;
 }
 bool convexHull::popCondition(Point2D last) {
@@ -50,41 +50,76 @@ bool convexHull::popCondition(Point2D last) {
 
     return false;
 }
-void convexHull::popAction(Data<std::nullptr_t, Point2D> elt) {
+void convexHull::popAction(Data<emptyContext, Point2D> elt) {
      std::cout << elt.getData() << " <<<< Pop!" << std::endl;
    // setContext(getContext() );
 }
 bool convexHull::pushCondition(Point2D data) {
     std::cout << data << " <<<< push condition returning true " << std::endl;
         return true;
 }
-void convexHull::pushAction(Data<std::nullptr_t, Point2D> elt) {
+void convexHull::pushAction(Data<emptyContext, Point2D> elt) {
     std::cout << "convexHullProblem::pushAction Nothing to see here "<<elt.getData()<< std::endl;
 }
 
 
 // copy the same functions again to be able to perform comparisons
-int comparisonConvexHull::readInput(std::vector<std::string> line) {
-    int value = std::stoi(line[0]);
-    setContext(std::stoi(line[1]));
-    return value;
+Point2D comparisonConvexHull::readInput(std::vector<std::string> line) {
+double x = std::stof(line[0]);
+double y = std::stof(line[1]);
+
+    Point2D p(x,y);
+
+    std::cout<<"I JUST READ "<<p<<std::endl;
+
+//setContext(std::stoi(line[1]));
+return p;
 }
-std::shared_ptr<int> comparisonConvexHull::initStack() {
-    std::shared_ptr<int> context(new int(0));
+
+std::shared_ptr<emptyContext> comparisonConvexHull::initStack() {
+
+    std::cout<<"going to read two values "<<std::endl;
+
+    //first, read and push two values
+    readPush(2);
+
+    std::cout<<"done reading two values "<<std::endl;
+
+    // then initialize context (which in this case is NULL everything
+    std::shared_ptr<emptyContext> context;
     return context;
 }
-bool comparisonConvexHull::popCondition(int data) {
-    if (getContext() > 0) {
+
+bool comparisonConvexHull::popCondition(Point2D last) {
+    Point2D minus1,minus2;
+
+    std::cout << last << " <<<< pop condition enter " << std::endl;
+
+    // read the two previous elements
+    minus1=top(1).getData();
+    minus2=top(2).getData();
+
+    std::cout << last << " <<<< pop condition read two befoer "<<minus1<<minus2 << std::endl;
+
+
+    if (Point2D::orientation(minus2,minus1,last)==2 ) {
+        std::cout << last << " <<<< pop condition returning true " << std::endl;
+
         return true;
     }
+    std::cout << last << " <<<< pop condition returning false " << std::endl;
+
     return false;
 }
-void comparisonConvexHull::popAction(Data<int, int> elt) {
-    //  std::cout << elt.toString() << " <<<< Pop!" << std::endl;
-    setContext(getContext() - 1);
+
+void comparisonConvexHull::popAction(Data<emptyContext, Point2D> elt) {
+     std::cout << elt.getData() << " <<<< Pop!" << std::endl;
+   // setContext(getContext() );
+}
+bool comparisonConvexHull::pushCondition(Point2D data) {
+    std::cout << data << " <<<< push condition returning true " << std::endl;
+        return true;
 }
-bool comparisonConvexHull::pushCondition(int data) {
-    return true;
+void comparisonConvexHull::pushAction(Data<emptyContext, Point2D> elt) {
+    std::cout << "convexHullProblem::pushAction Nothing to see here "<<elt.getData()<< std::endl;
 }
-void comparisonConvexHull::pushAction(Data<int, int> elt) {
-}