pushonly and CT seem to work, CH has some problems with push (maybe because of buffer?)

Author: nicill

CMakeLists.txt

@@ -53,7 +53,7 @@ get_property(inc_dirs DIRECTORY PROPERTY INCLUDE_DIRECTORIES)
 message("inc_dirs = ${inc_dirs}")
 
 # Executable
-add_executable(smartstack ${SOURCES})
+add_executable(smartstack ${SOURCES} src/convexHull.cpp)
 
 
 # Description of the different builds

include/Point2D.hpp

@@ -5,6 +5,7 @@
 #include <iostream>
 #include <string>
 
+
 #ifndef SMARTSTACK_POINT2D
 #define SMARTSTACK_POINT2D
 
@@ -28,7 +29,9 @@ class Point2D {
   double GetX() const;
   double GetY() const;
 
-  //  std::string ToString() const;
+  //std::string toString(Point2D&) ;
+
+  static int orientation(Point2D p1, Point2D p2, Point2D p3);
 
   // assignment operator
   void operator=(const Point2D &other);
@@ -39,6 +42,15 @@ class Point2D {
   bool operator<(const Point2D &other) const;
   bool operator>=(const Point2D &other) const;
   bool operator<=(const Point2D &other) const;
+
+  void write(std::ostream& os);
+
+  friend std::ostream& operator<<(std::ostream& os,Point2D p)
+  {
+      p.write(os);
+      return os;
+  }
+
 };
 
 #endif // SMARTSTACK_POINT2D

include/compressedStack.hpp

@@ -451,12 +451,16 @@ 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);

include/convexHull.hpp

@@ -0,0 +1,50 @@
+#include "problem.hpp"
+#include "compare.hpp"
+#include "Point2D.hpp"
+
+
+/*==============================================================================
+  Instantiation of a problem
+==============================================================================*/
+class convexHull : public Problem<std::nullptr_t, Point2D> {
+public:
+    convexHull(std::string filePath) : Problem<std::nullptr_t, Point2D>(filePath) {}
+
+private:
+    // Functions to run the stack
+    Point2D readInput(std::vector<std::string> line);
+
+    std::shared_ptr<std::nullptr_t> initStack();
+
+    bool popCondition(Point2D data);
+
+    void popAction(Data<std::nullptr_t, Point2D> elt);
+
+    bool pushCondition(Point2D data);
+
+    void pushAction(Data<std::nullptr_t, Point2D> elt);
+};
+
+/*==============================================================================
+  Instantiation of a comparison
+==============================================================================*/
+
+class comparisonConvexHull : public CompareStacks<int, int> {
+public:
+    comparisonConvexHull(std::string filePath) : CompareStacks<int, int>(filePath) {}
+
+private:
+    // Functions to run the stack
+    int readInput(std::vector<std::string> line);
+
+    std::shared_ptr<int> initStack();
+
+    bool popCondition(int data);
+
+    void popAction(Data<int, int> elt);
+
+    bool pushCondition(int data);
+
+    void pushAction(Data<int, int> elt);
+
+};

include/createTestInput.hpp

@@ -18,7 +18,7 @@ class createTestInput {
 public:
   createTestInput() {}
 
-  void createTestInputFiles(int code, std::string fileName, int n, int p,
+  void createTestInputFiles(int code, int stacktype, std::string fileName, int n, int p,
                             int min = 0, int max = 100, double prob = 0);
 };
 

include/data.hpp

@@ -32,6 +32,8 @@ template <class T, class D> class Data {
 public:
   // IO
   std::string toString();
+  D getData();
+
 
 private:
   // Constructor
@@ -72,7 +74,7 @@ template <class T, class D> ExplicitPointer<T, D> initExplicitPointer() {
 ==============================================================================*/
 template <class T, class D> std::string Data<T, D>::toString() {
   std::string str;
-  str = std::to_string(mIndex) + "<-" + std::to_string(mData);
+  str = std::to_string(mIndex) + "<-" /*+ std::to_string(mData)*/;
   return str;
 }
 
@@ -103,4 +105,9 @@ std::string explicitPointerToString(ExplicitPointer<T, D> xpointer) {
   return str;
 }
 
+template <class T, class D> D Data<T, D>::getData() {
+  return mData;
+}
+
+
 #endif /* DATA */

include/problem.hpp

@@ -50,12 +50,14 @@ template <class T, class D> class Problem {
 
   // Getters
   T getContext();
+
   int getIndex();
 
   // IO
   std::string toString();
   void print();
   void println();
+  void readPush(int iter = 1);
 
 protected:
   void initStackIntern();
@@ -106,6 +108,7 @@ 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;
     }
   }
 
@@ -201,6 +204,28 @@ std::vector<std::string> Problem<T, D>::readHeader() {
   return line;
 }
 
+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
 ==============================================================================*/
@@ -215,6 +240,7 @@ template <class T, class D> void Problem<T, D>::run() {
     }
     D data = readInput(line);
     mIndex++; // Might have to move
+    std::cout << " Starting loop for "<<data << std::endl;
     while ((!emptystack()) && (popCondition(data))) {
       Data<T, D> elt = pop();
       popAction(elt);
@@ -250,7 +276,11 @@ template <class T, class D> void Problem<T, D>::run(int limit) {
 }
 
 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/Point2D.cpp

@@ -7,68 +7,97 @@
 Point2D::Point2D() {}
 
 Point2D::Point2D(double xi, double yi) {
-  this->x = xi;
-  this->y = yi;
+  this->x=xi;
+  this->y=yi;
 }
 
 Point2D::Point2D(const Point2D &other) {
-  this->x = other.x;
-  this->y = other.y;
+  this->x=other.x;
+  this->y=other.y;
 }
 
-Point2D::~Point2D() {}
+Point2D::~Point2D() {
+}
 
 void Point2D::Set(const double xi, const double yi) {
-  this->x = xi;
-  this->y = yi;
+  this->x=xi;
+  this->y=yi;
+}
+
+void Point2D::SetX(double xi) {
+  this->x=xi;
 }
 
-void Point2D::SetX(double xi) { this->x = xi; }
+void Point2D::SetY(double yi) {
+  this->y=yi;
+}
 
-void Point2D::SetY(double yi) { this->y = yi; }
+double Point2D::GetX() const {
+  return x;
+}
 
-double Point2D::GetX() const { return x; }
+double Point2D::GetY() const {
+  return y;
+}
 
-double Point2D::GetY() const { return y; }
+/*std::string Point2D::toString(Point2D &p) {
+return  "( "+ std::to_string(p.x) + " , " +std::to_string(p.y)+" )";
+  }*/
 
-// std::string Point2D::ToString() const {
+
+// To find orientation of ordered triplet (p1, p2, p3).
+// The function returns following values
+// 0 --> p, q and r are colinear
+// 1 --> Clockwise
+// 2 --> Counterclockwise
+// taken from http://www.geeksforgeeks.org/orientation-3-ordered-points/
+int Point2D::orientation(Point2D p1, Point2D p2, Point2D p3)
+{
+  int val = (p2.y - p1.y) * (p3.x - p2.x) -
+            (p2.x - p1.x) * (p3.y - p2.y);
+
+  if (val == 0) return 0;  // colinear
+  return (val > 0)? 1: 2; // clock or counterclock wise
+}
+
+//std::string Point2D::ToString() const {
 //    return std::string("%f",x)
 //}
 
 void Point2D::operator=(const Point2D &other) {
-  x = other.x;
-  y = other.y;
+  x=other.x;
+  y=other.y;
 }
 
 bool Point2D::operator==(const Point2D &other) const {
-  return (x == other.x) && (y == other.y);
+  return (x==other.x)&&(y==other.y);
 }
 
 bool Point2D::operator!=(const Point2D &other) const {
-  return !(*this == other);
+  return !(*this==other);
 }
 
 // x order
 bool Point2D::operator>(const Point2D &other) const {
-  if (x != other.x)
-    return x > other.x;
-  else
-    return y > other.y; // equal x
+  if(x!=other.x )return x>other.x;
+  else return y>other.y;//equal x
 }
 
-bool Point2D::operator<(const Point2D &other) const {
-  // std::cout<<" comparing "<<x<<" and "<<other.x<<" output "<<(x <
-  // other.x)<<std::endl;
-  if (x != other.x)
-    return x < other.x;
-  else
-    return y < other.y; // equal x
+bool Point2D::operator < (const Point2D &other) const {
+  //std::cout<<" comparing "<<x<<" and "<<other.x<<" output "<<(x < other.x)<<std::endl;
+  if(x!=other.x ) return x < other.x;
+  else return y<other.y;//equal x
 }
 
 bool Point2D::operator>=(const Point2D &other) const {
-  return (*this == other) || (*this > other);
+  return (*this==other)||(*this>other);
 }
 
 bool Point2D::operator<=(const Point2D &other) const {
-  return (*this == other) || (*this < other);
+  return (*this==other)||(*this<other);
 }
+
+void Point2D::write(std::ostream& os)
+{
+  os << "( "<<x<<" , "<<y<<" )"<<std::endl;
+}