SeqFrequent2Filter.cpp

Go to the documentation of this file.

#ifndef SeqFrequent2Filter_CPP
#define SeqFrequent2Filter_CPP

#include "common.hpp"  
#include <vector>
//#include <iterator> //for tests


template <class IT_R>
class SeqFrequent2Filter
{
   public:
      SeqFrequent2Filter<IT_R>(IT_R* it_r):
         it_r(it_r), largest_item_p1(it_r->getLargestItem()+1) { }

      void findFrequentPairs(
         std::vector< std::pair< counter_t, std::pair<item_t, item_t> > >& 
         freq_pairs_with_counters,
         counter_t min_supp);


   private:
      IT_R* it_r;
      const item_t largest_item_p1;
};
template <class IT_R> inline void SeqFrequent2Filter<IT_R>::
findFrequentPairs(
   std::vector< std::pair<counter_t, std::pair<item_t, item_t> > >& 
   freq_pairs_with_counters, counter_t min_supp)
{
   std::vector< std::vector<counter_t> > temp_counter_array;
   std::vector< std::vector<bool> > pattern;
   temp_counter_array.reserve(largest_item_p1);
   temp_counter_array.resize(largest_item_p1);
   pattern.reserve(largest_item_p1);
   pattern.resize(largest_item_p1);
   for( item_t index = 0; index < largest_item_p1; ++index) 
   {
      temp_counter_array[index].reserve(largest_item_p1);
      pattern[index].reserve(largest_item_p1);
      temp_counter_array[index].resize(largest_item_p1, 0);
      pattern[index].resize(largest_item_p1, true);
   }

   freq_pairs_with_counters.clear();
   it_r->rewind();

   std::vector<item_t> transaction;
   std::vector<item_t>::iterator it1, it2;
   counter_t counter;
   while( (counter = it_r->nextTransactionBIS( transaction )) != 0 )
   {      
      if( transaction.size() > 1)
      {
         for( it1 = transaction.begin(); it1 != transaction.end()-1; ++it1)
         {
            for( it2 = it1+1; it2 != transaction.end(); ++it2)
               if(pattern[*it1][*it2])
               {
                  temp_counter_array[*it1][*it2] += counter;
                  pattern[*it1][*it2] = false;
               }
         }
         for( it1 = transaction.begin(); it1 != transaction.end()-1; ++it1)
            for( it2 = it1+1; it2 != transaction.end(); ++it2)
               pattern[*it1][*it2] = true;
      }
   }
   item_t index1, index2;
   std::pair<item_t, item_t> temp_pair;
   std::pair< counter_t, std::pair<item_t, item_t> > temp_pair2;
   for( index1 = 0; index1 < largest_item_p1 ; ++index1 )
   {
      for( index2 = 0; index2 < largest_item_p1; ++index2 )
      {
         if( temp_counter_array[index1][index2] >= min_supp )
         {
            temp_pair.first = index1;
            temp_pair.second = index2;
            temp_pair2.first = temp_counter_array[index1][index2];
            temp_pair2.second = temp_pair;
            freq_pairs_with_counters.push_back(temp_pair2);
         }
      }
      temp_counter_array[index1].clear();
      std::vector<counter_t>().swap(temp_counter_array[index1]);   
      // temp_counter_array[index1] will never be used again!
   }
}

#endif

---