SeqFrequentFilter.cpp

Go to the documentation of this file.

#ifndef SeqFrequentFilter_CPP
#define SeqFrequentFilter_CPP

#include "common.hpp"  
#include "common/log.h"  
#include <vector>


template <class IT_R>
class SeqFrequentFilter
{
   public:
      SeqFrequentFilter<IT_R>(IT_R& it_r):it_r(it_r){}

      void findFrequentItems(
         std::vector< std::pair<counter_t, item_t> >& freq_items_with_counters,
         counter_t& nr_of_transactions, counter_t& min_supp, 
         bool relative=false, double relminsupp=0.0);
   private:
      IT_R& it_r;


};

template <class IT_R> void SeqFrequentFilter<IT_R>::findFrequentItems(
   std::vector< std::pair<counter_t, item_t> >& freq_items_with_counters,
   counter_t& nr_of_transactions, counter_t& min_supp, 
   bool relative, double relminsupp)
{
   freq_items_with_counters.clear();
   nr_of_transactions = 0;
   it_r.rewind();

   std::vector<item_t> transaction;
   std::vector<bool> pattern;
   std::vector< counter_t > temp_counter_vector;

   std::vector<item_t>::iterator it_transaction;
   item_t nr_of_items = 0;
   item_t sum_of_lengths = 0;
   while( it_r.nextTransactionBIS( transaction ) )
   {      
      if( !transaction.empty() )
      {
         nr_of_transactions++;
         for( it_transaction = transaction.begin(); 
              it_transaction != transaction.end(); ++it_transaction )
         {
            if( *it_transaction + 1  > temp_counter_vector.size() )
            {
               temp_counter_vector.resize( *it_transaction + 1, 0 );
               pattern.resize( *it_transaction + 1, 1 );
            }
            if(pattern[*it_transaction])
            {
               ++temp_counter_vector[*it_transaction];
               pattern[*it_transaction] = false;
            }
         }
         for( it_transaction = transaction.begin(); 
              it_transaction != transaction.end(); ++it_transaction )
               pattern[*it_transaction] = true;
#if DEBUG_LEVEL >= LEVEL_DBG
         sum_of_lengths += transaction.size();
#endif
      }
   }
   it_r.setLargestItem( temp_counter_vector.size() - 1 );
   log_info(0,"Largest itemcode: %d", temp_counter_vector.size() - 1);
      
   if(relative)
      min_supp = static_cast<unsigned int>(relminsupp * nr_of_transactions);
   for( std::vector< counter_t >::size_type index = 0; 
        index < temp_counter_vector.size(); ++index )
   {
      if(temp_counter_vector[index] >= min_supp)
      {
         std::pair<counter_t, item_t> temp_pair(
            temp_counter_vector[index],index);
         freq_items_with_counters.push_back(temp_pair);
      }
#if DEBUG_LEVEL >= LEVEL_DBG
      if(temp_counter_vector[index] )
         ++nr_of_items;
#endif
   }
   log_dbg(0,"Number of items: %d", nr_of_items);
   log_dbg(0,"Average of the transactions' sizes: %d", 
           sum_of_lengths / nr_of_transactions);
}

#endif

---