inhomogeneous_trie/trie_manipulators/sequence/CandGenInfreqRemoveNopruneMerge.hpp

Go to the documentation of this file.

#ifndef CandGenInfreqRemoveNopruneMerge_HPP
#define CandGenInfreqRemoveNopruneMerge_HPP

#include "common.hpp"
#include "common/Edge.hpp"
#include "common/log.h"
#include "apriori/bodon/inhomogeneous_trie/trie_manipulators/sequence/CandidateGeneratorNoprune.hpp"
#include <vector>
//#include <cstdio>
//#include <iterator>   //for test




namespace Bodon
{
namespace sequence
{
namespace inhomogeneous_trie
{
   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   class CandGenInfreqRemoveNopruneMerge : 
         public CandidateGeneratorNoprune<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>
   {
      private:
         typedef CandidateGeneratorNoprune<DF_D, TRIE, LEAF, LEAF_ALLOCATOR> PARENT;
      protected:
         unsigned int nr_of_deleted;
         unsigned int total_nr_of_deleted;
      public:
         CandGenInfreqRemoveNopruneMerge( TRIE& main_trie, DF_D& df_decoder,
                                          LEAF_ALLOCATOR& s_alloc ) :
            CandidateGeneratorNoprune<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>(
               main_trie, df_decoder, s_alloc), 
            total_nr_of_deleted(0){}


         void generateCandidate(unsigned int candidate_size);
      
         void deleteInfrequent( const counter_t min_supp, 
                                unsigned int candidate_size );
         void afterWorkDel();
      protected:

         void delete_infrequent_subtrie( TRIE* subtrie, 
                                         const counter_t min_supp,
                                         unsigned int step_to_cand_par );


      public:
         // No public members
   };


   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   void CandGenInfreqRemoveNopruneMerge<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::
   generateCandidate(const unsigned int candidate_size)
   {
      if(candidate_size == 3)
      {
         PARENT::nr_of_new_candidates = 0;
         generateCandidateFindParent( &this->main_trie, 
                                      candidate_size -2 );
         log_dbg(0,"Number of newly generated candidates: %d", PARENT::nr_of_new_candidates);
#if DEBUG_LEVEL >= LEVEL_DBG
            nr_of_all_candidates += nr_of_new_candidates;
#endif
      }
      else
         log_dbg(0,"This algorithm does not generate any candidate in this phase.");

   }

   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   void CandGenInfreqRemoveNopruneMerge<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::
   deleteInfrequent( const counter_t min_supp, unsigned int candidate_size )
   {
      assert(candidate_size > 1);
      nr_of_deleted = 0;
      PARENT::nr_of_new_candidates = 0;
      delete_infrequent_subtrie( &this->main_trie, min_supp, 
                                 candidate_size - 1 );
      log_dbg(0,"Number of infrequent candidates: %d", nr_of_deleted);
      log_dbg(0,"Number of newly generated candidates (in del. phase!): %d", 
              PARENT::nr_of_new_candidates);
#if DEBUG_LEVEL >= LEVEL_DBG
      nr_of_all_candidates += nr_of_new_candidates;
      total_nr_of_deleted += nr_of_deleted;
#endif
   }

   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   void CandGenInfreqRemoveNopruneMerge<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::
   afterWorkDel()
   {
      log_dbg(0,"The total number of generated candidates (in del. p.): %d", 
              PARENT::nr_of_all_candidates);
      log_dbg(0,"The total number of infrequent candidates: %d", 
              total_nr_of_deleted);
   }

   template <class DF_D, class TRIE, class LEAF, class LEAF_ALLOCATOR>
   void CandGenInfreqRemoveNopruneMerge<DF_D, TRIE, LEAF, LEAF_ALLOCATOR>::
   delete_infrequent_subtrie( TRIE* subtrie, const counter_t min_supp,
                              unsigned int step_to_cand_par)
   {
      typename TRIE::iterator itEdge( subtrie->edgelist.begin() );
      if(step_to_cand_par)
      {
         --step_to_cand_par;
         while( itEdge != subtrie->edgelist.end() )
         {
            PARENT::df_decoder.pushItem( (*itEdge).first );
            delete_infrequent_subtrie( static_cast<TRIE*>((*itEdge).second), min_supp,
                                       step_to_cand_par);
            PARENT::df_decoder.popItem();
            if( static_cast<TRIE*>((*itEdge).second)->edgelist.empty() )
            {
               delete static_cast<TRIE*>((*itEdge).second);
               itEdge = subtrie->edgelist.erase(itEdge);
            }
            else ++itEdge;
         }
      }
      else
      {
         while( itEdge != subtrie->edgelist.end() )
         {
            if( static_cast<LEAF*>((*itEdge).second)->getCounter() < min_supp )
            {
#if DEBUG_LEVEL >= LEVEL_DBG
                  ++nr_of_deleted;
#endif
               PARENT::s_alloc.free(static_cast<LEAF*>((*itEdge).second));
               itEdge = subtrie->edgelist.erase(itEdge);
            }
            else
               ++itEdge;
         }
         generateCandidateAtParent(subtrie);
#if DEBUG_LEVEL >= LEVEL_DBG
         for( typename TRIE::iterator it( subtrie->edgelist.begin() );
              it != subtrie->edgelist.end(); ++it)
            nr_of_new_candidates += 
               static_cast<TRIE*>((*it).second)->edgelist.size();
#endif
      }
   }
}
}
}
#endif

---