InfreqRemoverOrderPresAssumption.hpp

Go to the documentation of this file.

#ifndef InfreqRemoverOrderPresAssumption_HPP
#define InfreqRemoverOrderPresAssumption_HPP


#include "common.hpp"
#include "common/Edge.hpp"
#include "apriori/bodon/inhomogeneous_trie/trie_manipulators/InfreqRemover.hpp"
#include <vector>
//#include <cstdio>
//#include <iterator>   //for test




namespace Bodon
{
namespace inhomogeneous_trie
{
   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   class InfreqRemoverOrderPresAssumption : 
         public InfreqRemover<DF_D, TRIE, LEAF, LEAF_ALLOCATOR, NEE_Off, false>
   {
      private:
         typedef InfreqRemover<DF_D, TRIE, LEAF, LEAF_ALLOCATOR, NEE_Off, false> 
         PARENT;
      public:
         InfreqRemoverOrderPresAssumption( TRIE& main_trie, DF_D& df_decoder,
                                           LEAF_ALLOCATOR& s_alloc ) : 
            PARENT(main_trie, df_decoder, s_alloc)
         {
            float alphas_array[] = {1.00, 0.95, 0.9, 0.85};
            int size = sizeof(alphas_array) / sizeof(float);
            alphas.insert(alphas.end(), alphas_array, alphas_array + size);         
            holds.resize(size);
            not_holds.resize(size);
         }      
         void afterWorkDel();
         float getOrderPreservingRatio(const int index) const
         {
            return static_cast<float>(holds[index])/(holds[index] + not_holds[index]);
         }
      protected:
         std::vector<float> alphas;
         std::vector<unsigned int> holds;
         std::vector<unsigned int> not_holds;

         void calculateOrderPresRatio(TRIE* trie1,
                                      std::vector<item_t>& itemset1 );

         void calculateOrderPresRatioAssist(
            const TRIE* trie1, TRIE* trie2, const std::vector<item_t>& itemset1, 
            std::vector<item_t>& itemset2, std::vector<item_t>& intersection,
            std::vector<item_t>& diff_1, std::vector<item_t>& diff_2);

   };


   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   void InfreqRemoverOrderPresAssumption<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::
   afterWorkDel()
   {
      std::vector<item_t> itemset1;
      calculateOrderPresRatio( &this->main_trie, itemset1);
      for(unsigned int index = 0; index<holds.size(); ++index)
      {
         std::cout<<"The "<<alphas[index]<<"-order-preserving ratio is: "<<
            getOrderPreservingRatio(index)<<std::endl;
      }
      PARENT::destroy(&this->main_trie);
   }
   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   void InfreqRemoverOrderPresAssumption<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::
   calculateOrderPresRatio(TRIE* trie1,
                           std::vector<item_t>& itemset1) 
   {
      std::vector<item_t> itemset2, intersection,
         diff1(itemset1), diff2;
      calculateOrderPresRatioAssist( trie1, &this->main_trie,
                                     itemset1, itemset2, intersection,
                                     diff1, diff2);
      for(typename TRIE::iterator itEdge( trie1->edgelist.begin()); 
          itEdge != trie1->edgelist.end(); ++itEdge )
      {
         itemset1.push_back((*itEdge).first);
         calculateOrderPresRatio(static_cast<TRIE*>((*itEdge).second), itemset1 );
         itemset1.pop_back();
      }
   }
   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   void InfreqRemoverOrderPresAssumption<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::
   calculateOrderPresRatioAssist(
      const TRIE* trie1, TRIE* trie2, const std::vector<item_t>& itemset1, 
      std::vector<item_t>& itemset2, std::vector<item_t>& intersection,
      std::vector<item_t>& diff1, std::vector<item_t>& diff2)
   {
      if( trie1 < trie2)
      {
         if(!intersection.empty() && !diff1.empty() && !diff2.empty())
         {
            const LEAF* subtrie1 = static_cast<const LEAF*>(
               this->main_trie.isIncluded( diff1, diff1.begin()));
            const LEAF* subtrie2 = static_cast<const LEAF*>(
               this->main_trie.isIncluded( diff2, diff2.begin()));
            if(subtrie1->getCounter() != subtrie2->getCounter())
            {
               for(unsigned int index = 0; index< holds.size(); ++index)
               {
                  if( subtrie1->getCounter() < subtrie2->getCounter() )
                  {
                     if(alphas[index] * trie1->getCounter() > trie2->getCounter())                
                        ++not_holds[index];
                     else
                        ++holds[index];
                  }
                  else
                  {
                     if(trie1->getCounter() < alphas[index] * trie2->getCounter())                
                        ++not_holds[index];
                     else
                        ++holds[index];
                  }
               }
            }
         }
      }
      for(typename TRIE::iterator itEdge( trie2->edgelist.begin()); 
          itEdge != trie2->edgelist.end(); ++itEdge )
      {
         itemset2.push_back((*itEdge).first);
         std::vector<item_t>::size_type index = 
            std::find(diff1.begin(), diff1.end(), (*itEdge).first) 
            - diff1.begin();
         if ( index != diff1.size())
         {
            intersection.push_back((*itEdge).first);
            diff1.erase(diff1.begin() + index);
            calculateOrderPresRatioAssist(trie1, static_cast<TRIE*>((*itEdge).second), 
                                          itemset1, itemset2, intersection,
                                          diff1, diff2);
            diff1.insert(diff1.begin() + index, (*itEdge).first);
            intersection.pop_back();
         }
         else
         {
            diff2.push_back((*itEdge).first);
            calculateOrderPresRatioAssist(trie1, static_cast<TRIE*>((*itEdge).second), 
                                          itemset1, itemset2, intersection,
                                          diff1, diff2);
            diff2.pop_back();
         }
         itemset2.pop_back();
      }
   }

}
}
#endif

---