StatSupportCounterMerge.hpp

Go to the documentation of this file.

#ifndef StatSupportCounterMerge_HPP
#define StatSupportCounterMerge_HPP

#include "common.hpp"
#include <vector>
#include "apriori/bodon/Leaf.hpp"
//#include <cstdio>
//#include <iterator>   //for test




namespace Bodon
{
   template <class TRIE, unsigned int THRESHOLD>
   class StatSupportCounterMerge
   {
      public:
         StatSupportCounterMerge( ){}
         ~StatSupportCounterMerge( );
         void findCandidates( TRIE* subtrie,
            std::vector<item_t>::const_iterator it_basket_upper_bound,
            std::vector<item_t>::const_iterator it_basket, 
            item_t step_to_candidate,
            const counter_t counter_incr );
      private:
         vector<unsigned int> trans_step_distribution;
         vector<unsigned int> edgelist_step_distribution;

   };

   template <class TRIE, unsigned int THRESHOLD> void 
   StatSupportCounterMerge<TRIE, THRESHOLD>::findCandidates( 
      TRIE* subtrie, std::vector<item_t>::const_iterator it_basket_upper_bound,
      std::vector<item_t>::const_iterator it_basket, 
      item_t step_to_candidate, const counter_t counter_incr )
   {
      unsigned int trans_step=0, edgelis_step=0;
      --step_to_candidate;
      typename TRIE::iterator it_edge(subtrie->edgelist.begin());
      while( it_edge != subtrie->edgelist.end() && 
             it_basket != it_basket_upper_bound )
      {
         if( (*it_edge).first < *it_basket)
         { 
            ++it_edge;
            ++edgelis_step;
         }
         else if( (*it_edge).first > *it_basket)
         { 
            ++it_basket;
            ++trans_step;
         }
         else
         {
            if(trans_step >= trans_step_distribution.size())
               trans_step_distribution.resize(trans_step + 1, 0);
            ++trans_step_distribution[trans_step];
            trans_step=1;
            if(edgelis_step >= edgelist_step_distribution.size())
               edgelist_step_distribution.resize(edgelis_step + 1, 0);
            ++edgelist_step_distribution[edgelis_step];
            edgelis_step=1;

            ++it_basket;
            if( step_to_candidate ) 
               findCandidates( static_cast<TRIE*>((*it_edge).second),
                               it_basket_upper_bound + 1, it_basket, 
                               step_to_candidate, counter_incr);
            else
               static_cast<Leaf*>((*it_edge).second)
                  ->increaseCounter( counter_incr);
            ++it_edge;
         }
      }
   }
   template <class TRIE, unsigned int THRESHOLD> 
   StatSupportCounterMerge<TRIE, THRESHOLD>::
   ~StatSupportCounterMerge()
   {
      unsigned int index, sum_of_matches=0, part_sum_of_matches=0;
      
      std::cout<<"The distribution of the steps between matches in the transactions:"<<std::endl;
      for(index=0; index <= trans_step_distribution.size(); ++index) 
      {
         std::cout<<index<<" "<<trans_step_distribution[index]<<std::endl;
         sum_of_matches += trans_step_distribution[index];
         if(index < THRESHOLD)
            part_sum_of_matches += trans_step_distribution[index];
      }
      std::cout<<"The sum of matches: "<<sum_of_matches<<std::endl;
      std::cout<<"The sum of matches within "<<THRESHOLD<< " steps: "<<part_sum_of_matches<<std::endl;
      std::cout<<"This threshold equals to the "<<static_cast<double>(part_sum_of_matches)/sum_of_matches<< "-quantile."<<std::endl;
/*      std::cout<<"The distribution of the steps between matches in the edgelists:"<<std::endl;
      for(index=0; index <= edgelist_step_distribution.size(); ++index) 
      std::cout<<index<<": "<<edgelist_step_distribution[index]<<std::endl;*/
   }
}
#endif

---