Implementation of push for Compressed Stack

Azzaare · Azzaare · commit f67c66edbbf4 · 2016-07-08T10:59:37.000+09:00
diff --git a/include/component.hpp b/include/component.hpp
@@ -44,15 +44,15 @@ class Component{
 
   Levels<T,D> mPartial;
   ExplicitPointer<T,D> mExplicit;
-  std::shared_ptr<Signature<T,D>> mSign;
+  Signature<T,D> mSign;
 };
 
 /*==============================================================================
   Constructors
 ==============================================================================*/
 template <class T, class D>
-Component<T,D>::Component(int space, int depth){
-  mSign = std::shared_ptr<Signature<T,D>> (nullptr);
+Component<T,D>::Component(int space, int depth)
+:mSign(0, std::streampos (0), std::shared_ptr<T>(nullptr)){
 
   Levels<T,D> partial = initLevels<T,D>(space, depth);
   mPartial = partial;
@@ -95,14 +95,14 @@ std::string Component<T,D>::toString(){
 ==============================================================================*/
 template <class T, class D>
 bool Component<T,D>::isempty(){
-  bool b = bool (mSign);
+  bool b = bool (mSign.mContext);
   return !b;
 }
 
 template <class T, class D>
 bool Component<T,D>::isempty(int lvl){
   bool b;
-  if (lvl > mPartial.size()) {
+  if (lvl > int(mPartial.size())) {
     b = isExplicitEmpty();
   } else {
     b = (mPartial[lvl]).empty();
diff --git a/include/compressedStack.hpp b/include/compressedStack.hpp
@@ -26,14 +26,17 @@ class CompressedStack: public Stack<T,D>{
   friend class Problem<T,D>;
 
 private:
-  CompressedStack<T,D>(int size, int space, int buffer, std::shared_ptr<T> context, std::streampos position);
+  CompressedStack<T,D>(int size, int space, int buffer, std::shared_ptr<T> context, std::streampos position = std::streampos(0));
 
   // Internals
   Data<T,D> top(int k);
-  void push(Data<T,D> data);
+  void push(const Data<T,D> &data);
   Data<T,D> pop();
   bool isempty();
 
+  // Setters
+  void setContext(std::shared_ptr<T> context);
+
   // IO
   std::string toString();
 
@@ -42,6 +45,8 @@ class CompressedStack: public Stack<T,D>{
   void pushCompressed(std::shared_ptr<Data<T,D>> elt, int lvl);
   Data<T,D> top();
   int topIndex();
+  void compress();
+  void resetBlock(Signature<T,D> sign, int lvl);
 
   // Structure constraints
   int mSize;  // (Expected) size of the input in #elements
@@ -68,15 +73,22 @@ class CompressedStack: public Stack<T,D>{
 ==============================================================================*/
 template <class T, class D>
 CompressedStack<T,D>::CompressedStack(int size, int space, int buffer, std::shared_ptr<T> context, std::streampos position)
-:mFirst(size,space), mSecond(size,space), mBuffer(buffer){
+: mFirst(space, int( ceil(log(size)/log(space)-.1)))
+, mSecond(space, int( ceil(log(size)/log(space)-.1)))
+, mBuffer(buffer){
   mSize = size;
   mSpace = space;
-  mDepth = (int) ceil(log(size)/log(space)-.1); // - 1;
-
+  mDepth = int( ceil(log(size)/log(space)-.1));
   mPosition = position;
-
   mCompressed = initBlock<T,D>(mSpace);
+  mContext = context;
+}
 
+/*==============================================================================
+  Setters : setContext
+==============================================================================*/
+template <class T, class D>
+void CompressedStack<T,D>::setContext(std::shared_ptr<T> context){
   mContext = context;
 }
 
@@ -100,23 +112,39 @@ std::string CompressedStack<T,D>::toString(){
 }
 
 /*==============================================================================
-  Stack Functions: push, pop, isempty
+  Stack Functions: push, pop, isempty, compress
 ==============================================================================*/
+// Function that compress the top block of mSecond to a sign in mCompressed
+template <class T, class D>
+void CompressedStack<T,D>::compress(){
+  if (!mSecond.isempty()) {
+    mCompressed.back().mLast = mSecond.topIndex();
+  }
+}
+
 template <class T, class D>
 bool CompressedStack<T,D>::isempty(){
   return (mFirst.isempty() && mSecond.isempty());
 }
 
+template <class T, class D>
+void CompressedStack<T,D>::resetBlock(Signature<T,D> sign, int lvl){
+  mFirst.mPartial[lvl].clear();
+  mFirst.mPartial[lvl].reserve(std::pow(mSpace, mDepth + 1 - lvl));
+  mFirst.mPartial[lvl].push_back(sign);
+}
+
 // Function push that push the data in explicit and index in partial/compressed
 template <class T, class D>
-void CompressedStack<T,D>::push(Data<T,D> elt){
+void CompressedStack<T,D>::push(const Data<T,D> &elt){
   // update the buffer (if buffer size is bigger than 0)
-  std::shared_ptr<Data<T,D>> ptr_elt (new Data<T,D>(elt));
+  std::shared_ptr<Data<T,D>> ptr_elt = std::make_shared<Data<T,D>>(elt);
   mBuffer.push(ptr_elt);
   // update the explicit Blocks, with possibly shifting first to second
   pushExplicit(ptr_elt);
   // update the compressed Blocks at each levels (including fully compressed)
-  for (int lvl = 1; lvl < mDepth - 1; lvl++) {
+  for (int lvl = 0; lvl < mDepth - 1; lvl++) {
+    std::cout << "Pushing on level " << lvl << std::endl;
     pushCompressed(ptr_elt, lvl);
   }
 }
@@ -131,28 +159,26 @@ void CompressedStack<T,D>::pushExplicit(std::shared_ptr<Data<T,D>> elt){
   // If the explicit datas of component 1 are empty we push
   if (mFirst.isExplicitEmpty()) {
     mFirst.pushExplicit(eltPtr);
-    std::shared_ptr<Signature<T,D>> signPtr(&sign);
-    mFirst.mSign = signPtr;
+    mFirst.mSign = sign;
   }
   // We check if thoses explicit datas are full
   else {
     int headIndex = mFirst.topIndex();
     int startBlock = headIndex - (headIndex - 1) % mSpace;
     if (index - startBlock < mSpace) {
       mFirst.pushExplicit(eltPtr);
-      (*mFirst.mSign).mLast = index;
+      mFirst.mSign.mLast = index;
     } else {
       if ((mDepth == 1) && (!(mSecond.isExplicitEmpty()))) {
         if (mCompressed.empty()) {
-          mCompressed.push_back(*mSecond.mSign);
+          mCompressed.push_back(mSecond.mSign);
         } else {
           // Compress mSecond into mCompressed
-          (mCompressed.back()).mLast = (*mSecond.mSign).mLast;
+          (mCompressed.back()).mLast = mSecond.mSign.mLast;
         }
       }
-      std::shared_ptr<Signature<T,D>> signPtr = mFirst.mSign;
-      mSecond.mSign = signPtr;
-      mFirst.mSign = signPtr;
+      mSecond.mSign = sign;
+      mFirst.mSign = sign;
       mSecond.mExplicit = mFirst.mExplicit;
       mFirst.clearExplicit(mSpace);
       mFirst.pushExplicit(eltPtr);
@@ -166,9 +192,9 @@ void CompressedStack<T,D>::pushCompressed(std::shared_ptr<Data<T,D>> elt, int lv
   int distSubBlock = std::pow(mSpace,(mDepth - lvl));
   int distBlock = distSubBlock * mSpace;
   int index = elt->mIndex;
+  Signature<T,D> sign (index, mPosition, mContext);
 
   if (mFirst.isempty(lvl)) {
-    Signature<T,D> sign (index, mPosition, mContext);
     mFirst.push(sign, lvl);
   } else {
     int headIndex = mFirst.topIndex(lvl);
@@ -181,12 +207,23 @@ void CompressedStack<T,D>::pushCompressed(std::shared_ptr<Data<T,D>> elt, int lv
       int eta = index - startSubBlock + 1;
       // compress new element in the top of the current Block
       if (eta <= distSubBlock) {
-        int lengthSubBlock = 0;
+        mFirst.mPartial[lvl].back().mLast = index;
       } else {
-        /* code */
+        mFirst.push(sign, lvl);
       }
     } else {
-      /* code */
+      if (lvl == 0) {
+        int distComponent = int(ceil(mSize/mSpace));
+        int startComponent = headIndex - (headIndex - 1) % distComponent;
+        int gamma = index - startComponent + 1;
+        if (gamma <= distComponent) {
+          compress();
+        } else {
+          mCompressed.push_back(Signature<T,D>(mSecond.mPartial[1]));
+        }
+      }
+      mSecond.mPartial[lvl] = mFirst.mPartial[lvl];
+      resetBlock(sign, lvl);
     }
   }
 }
diff --git a/include/data.hpp b/include/data.hpp
@@ -13,15 +13,17 @@
   Class      : template (D datas)
   Extensions :
   Aliases    : Explicit, ExplicitPointer
-  Friends   -> Component
+  Friends   -> Component, CompressedStack, Problem
             <-
 ==============================================================================*/
 template <class T, class D> class Component; // Required for the friendship
 template <class T, class D> class CompressedStack; // Required for the friendship
+template <class T, class D> class Problem; // Required for the friendship
 template <class T, class D>
 class Data{
   friend class Component<T,D>;
   friend class CompressedStack<T,D>;
+  friend class Problem<T,D>;
 
 public:
   // IO
diff --git a/include/normalStack.hpp b/include/normalStack.hpp
@@ -5,6 +5,7 @@
   Includes
 ==============================================================================*/
 #include "stack.hpp"
+#include <memory>
 
 /*==============================================================================
   Class      : template (D datas)
@@ -30,9 +31,12 @@ class NormalStack: public Stack<T,D>{
 
   // Stack common methods
   Data<T,D> pop();
-  void push(Data<T,D> data);
+  void push(const Data<T,D> &data);
   Data<T,D> top(int k);
   bool isempty();
+
+  // Setters
+  void setContext(std::shared_ptr<T> context){}
 };
 
 /*==============================================================================
@@ -61,7 +65,7 @@ Data<T,D> NormalStack<T,D>::pop(){
 }
 
 template <class T, class D>
-void NormalStack<T,D>::push(Data<T,D> elt){
+void NormalStack<T,D>::push(const Data<T,D> &elt){
   mDatas.push_back(elt);
 }
 
diff --git a/include/problem.hpp b/include/problem.hpp
@@ -17,7 +17,7 @@
   Extensions : Instance
   Aliases    :
   Friends   ->
-            <- NormalStack, CompressedStack
+            <- NormalStack, CompressedStack, Data
 ==============================================================================*/
 template <class T, class D>
 class Problem{
@@ -35,8 +35,7 @@ class Problem{
   bool emptystack();
 
   // Setters
-  void setOutput(std::string fileName);
-  void setContext(T context);
+  void setContext(const T &context);
 
   //Getters
   T getContext();
@@ -54,7 +53,7 @@ class Problem{
 private:
   // Input/Ouput
   std::ifstream mInput;
-  std::shared_ptr<std::ofstream> mOutput; // output file is optional
+  std::ofstream mOutput; // output file is optional
 
   // Stack Functions: defined by user
   virtual D readInput(std::vector<std::string> line) = 0;
@@ -75,27 +74,20 @@ class Problem{
   Constructors : with NormalStack or CompressedStack
 ==============================================================================*/
 template <class T, class D>
-Problem<T,D>::Problem(std::string fileName, int size){
+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);
-  mOutput = nullptr;
-
-  mContext = (nullptr);
-  mIndex = 0;
-
-  mStack = std::shared_ptr<Stack<T,D>> (new NormalStack<T,D> (size));
 }
 
 template <class T, class D>
-Problem<T,D>::Problem(std::string fileName, int size, int space, int buffer){
+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();
-
-  mOutput = nullptr;
-
-  mContext = (nullptr);
-  mIndex = 0;
-
-  mStack = std::shared_ptr<Stack<T,D>> (new CompressedStack<T,D> (size, space, buffer, mContext, position));
+  mStack = std::shared_ptr<Stack<T,D>> (new CompressedStack<T,D> (size, space, buffer, mContext));
 }
 
 /*==============================================================================
@@ -185,18 +177,9 @@ bool Problem<T,D>::emptystack(){
 
 /** Setters **/
 template <class T, class D>
-void Problem<T,D>::setOutput(std::string fileName){
-  std::ofstream ofstr;
-  ofstr.open(fileName, std::ofstream::out);
-  mOutput = &ofstr;
-}
-
-template <class T, class D>
-void Problem<T,D>::setContext(T context){
-//  std::cout << "setContext, T = " << context << std::endl;
-  *mContext = context;
-//  std::cout << "setContext, *mContext = " << (*mContext) << std::endl;
-//  std::cout << "setContext, *mContext = " << getContext() << std::endl;
+void Problem<T,D>::setContext(const T &context){
+  mContext = std::make_shared<T>(context);
+  mStack->setContext(mContext);
 }
 
 template <class T, class D>
diff --git a/include/sign.hpp b/include/sign.hpp
@@ -62,10 +62,10 @@ template <class T, class D>
 Signature<T,D>::Signature(Block<T,D> block){
   Signature<T,D> frontSign = block.front();
   Signature<T,D> backSign = block.back();
-  mFirst = frontSign.getFirst();
-  mLast = backSign.getLast();
-  mPosition = frontSign.getPosition();
-  mContext = frontSign.getContext();
+  mFirst = frontSign.mFirst;
+  mLast = backSign.mLast;
+  mPosition = frontSign.mPosition;
+  mContext = frontSign.mContext;
 }
 
 template <class T, class D>
diff --git a/include/stack.hpp b/include/stack.hpp
@@ -5,6 +5,7 @@
   Includes
 ==============================================================================*/
 #include "data.hpp"
+#include <memory>
 
 /*==============================================================================
   Class      : abstract, template (T context, D datas)
@@ -22,10 +23,13 @@ class Stack{
 
   // Common stack functions
   virtual Data<T,D> pop() = 0;
-  virtual void push(Data<T,D> data) = 0;
+  virtual void push(const Data<T,D> &data) = 0;
   virtual Data<T,D> top(int k) = 0;
   virtual bool isempty() = 0;
 
+  // Setters
+  virtual void setContext(std::shared_ptr<T> context) = 0;
+
   // IO
   virtual std::string toString() = 0;
 };
diff --git a/src/main.cpp b/src/main.cpp
@@ -65,6 +65,8 @@ void testProblem()
   // Test on CompressedStack
   Instance testCS(filePath, 1000, 3, 0);
   testCS.println();
+  testCS.run();
+  testCS.println();
 }
 
 /*==============================================================================

Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,8 @@ void testProblem()`
`65`	`65`	`// Test on CompressedStack`
`66`	`66`	`Instance testCS(filePath, 1000, 3, 0);`
`67`	`67`	`testCS.println();`
	`68`	`+ testCS.run();`
	`69`	`+ testCS.println();`
`68`	`70`	`}`
`69`	`71`
`70`	`72`	`/*==============================================================================`