Apriori.hpp

Go to the documentation of this file.

#ifndef Apriori_HPP
#define Apriori_HPP

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

template <class C, class D, class MAIN_DATA_STRUCTURE, 
          class SEC_DATA_STRUCTURE, class FII, class FPI, 
          class CG, class IR, class SUPP_C>
class Apriori
{
   private:
      MAIN_DATA_STRUCTURE& data_structure;
      SEC_DATA_STRUCTURE& s_alloc;
      IR& infrequent_remover;
      C& coder;
      D& decoder;
      //
      FII& fii;

      unsigned int candidate_size;

   public:

      Apriori(MAIN_DATA_STRUCTURE& data_structure, SEC_DATA_STRUCTURE& s_alloc, 
              IR& infrequent_remover, C& coder, D& decoder, FII& fii ) : 
         data_structure(data_structure), s_alloc(s_alloc), 
         infrequent_remover(infrequent_remover), coder(coder), decoder(decoder), fii(fii){}

      void findFrequentItemsets( 
         const counter_t emptyset_support,
         std::vector<counter_t>& freq_counters,
         std::vector< std::pair< counter_t, std::pair<item_t, item_t> > >& 
         freq_pairs_with_counters,
         const counter_t min_supp,
         unsigned int maxsize = largest_itemsetsize);

};

template <class C, class D, class MAIN_DATA_STRUCTURE, 
          class SEC_DATA_STRUCTURE, class FII, class FPI, 
          class CG, class IR, class SUPP_C>
void Apriori<C, D, MAIN_DATA_STRUCTURE, SEC_DATA_STRUCTURE, 
             FII, FPI, CG, IR, SUPP_C>::
findFrequentItemsets( 
   const counter_t emptyset_support,
   std::vector<counter_t>& freq_counters,
   std::vector< std::pair< counter_t, std::pair<item_t, item_t> > >& 
   freq_pairs_with_counters,
   const counter_t min_supp,
   unsigned int maxsize )
{
   if(maxsize > 2)
   {
      FPI fpi(data_structure, decoder, s_alloc);
      log_status(0,"Setting the support of the emptyset in the trie.");
      fii.setEmptysetSupport(emptyset_support);
      log_status(0,"Inserting the support of the frequent items.");
      fii.insertFrequentItems(freq_counters);
      freq_counters.clear();
      std::vector<counter_t>().swap(freq_counters);
      log_status(0,"Inserting the frequent pairs and they supports.");
      fpi.insertFrequentPairs(freq_pairs_with_counters);
      freq_pairs_with_counters.clear();  
      std::vector< std::pair< counter_t, std::pair<item_t, item_t> > >().
         swap(freq_pairs_with_counters);

      CG candidate_generator(data_structure, decoder, s_alloc);
      SUPP_C support_counter(data_structure, coder);
      log_status(0,"Setting the size of the candidate to 3");
      candidate_size = 3;

      log_status(0,"Generating candidates of size 3");
      candidate_generator.generateCandidate(candidate_size);
   
      while( candidate_generator.isThereAnyCandidate()  )
      {
         log_status(0,"Determining the supports");
         support_counter.countSupport(candidate_size);
         log_status(0,"Deleting infrequent candidates");
         infrequent_remover.deleteInfrequent(min_supp, candidate_size);
         ++candidate_size;
         log_status(0,"Setting the candidatesize counter to %d", 
                    candidate_size);
         if(maxsize < candidate_size)
         {
            log_status(0,"Maximal size threshold is reached.");
            break;
         }
         log_status(0,"Generating new candidates");
         candidate_generator.generateCandidate(candidate_size);
      }
      log_status(0,"No new candidates were generated.");
      candidate_generator.afterWorkCandGen();
      infrequent_remover.afterWorkDel();
   }
   else
   {
      for(std::vector<counter_t>::size_type index = 0;
          index != freq_counters.size(); ++index)
      {
         decoder.pushItemWithWrite( index, freq_counters[index] );
         decoder.popItem();      
      }
      for(std::vector< std::pair< counter_t, std::pair<item_t, item_t> > >::iterator it 
             = freq_pairs_with_counters.begin(); it != freq_pairs_with_counters.end(); ++it)
      {
         // it could be solved more efficient... but I don't care ;)
         decoder.pushItem((*it).second.first);
         decoder.pushItemWithWrite((*it).second.second, (*it).first);
         decoder.popItem();
         decoder.popItem();
      }      
   }
}

#endif

---