StatOutput.hpp

Go to the documentation of this file.

#ifndef StatOutput_HPP
#define StatOutput_HPP

#include "common.hpp"  
#include "common/log.h"
#include "io/output/normal/BufferedNormalOutput.hpp"
#include <iostream>
#include <vector>

template <class OUTPUT = BufferedNormalOutput<>, bool VERBOSE = false > 
class StatOutput : public OUTPUT
{
      std::vector<counter_t> lengthsp;
      size_t buffer_size;
public:
      class params_t : public OUTPUT::params_t
      {
         public:
            item_t numfreq;
            params_t() : OUTPUT::params_t()
            {
               numfreq = 0;
            }
      };
      StatOutput( const params_t* par ):
         OUTPUT(par), lengthsp(par->numfreq), buffer_size(0){ }
      
      template <class InputIterator> inline 
      void DINLINE writeItemsetAndCounter( 
         InputIterator first, InputIterator last, 
         const counter_t support)
      {
         size_t slen = last - first; //will work only with randomaccess iterators
         lengthsp[slen]++;
         OUTPUT::writeItemsetAndCounter(first,last,support);
      }

      void pushItem(item_t item)
      {
         ++buffer_size;
         OUTPUT::pushItem(item);
      }
      void write(counter_t support)
      {
         lengthsp[buffer_size]++;
         OUTPUT::write(support);
      }

      void pushItemWithWrite(item_t item, counter_t support)
      {
         ++buffer_size;
         lengthsp[buffer_size]++;
         OUTPUT::pushItemWithWrite(item, support);
      }

      void pushItemWithPrevSupport(item_t item)
      {
         ++buffer_size;
         lengthsp[buffer_size]++;
         OUTPUT::pushItemWithPrevSupport(item);
      }

      void popItem()
      {
         --buffer_size;
         OUTPUT::popItem();
      }

      void popAll()
      {
         buffer_size = 0;
         OUTPUT::popAll();
      }

      ~StatOutput( )
      {
         int maxs=-1;
         unsigned int total_nr_of_freq_items = 0;
         for(size_t i=0; i< lengthsp.size(); ++i) 
         {
            if( lengthsp[i] )
               maxs=i;
            total_nr_of_freq_items += lengthsp[i];
         }
         if (VERBOSE)
         {
            std::cerr<<"Total number of frequent itemsets: \t\t\t"<<total_nr_of_freq_items<<std::endl;
            std::cerr<<"Total number of frequent itemsets except 0,1,2-itemsets: "<<
            total_nr_of_freq_items-lengthsp[0]-lengthsp[1]-lengthsp[2]<<std::endl;
            std::cerr<<"The size of the largest frequent itemset: \t\t"<<maxs<<std::endl;
            std::cerr<<"The distribution of the frequent itemsets:"<<std::endl;
         }
         unsigned int sum_of_sizes=0;
         for(int i=0; i <= maxs; ++i) 
         {
            if(VERBOSE)
            {
               std::cerr<<i<<':';
               sum_of_sizes += i*lengthsp[i];
            }
            std::cerr<<lengthsp[i]<<std::endl;
         }
         if(VERBOSE)
         {
            std::cerr<<"The average size of the frequent itemsets: \t\t"<<
               static_cast<double>(sum_of_sizes)/total_nr_of_freq_items<<std::endl;
         }
         
      }
};

template <class OUTPUT>
class LStatOutput {
private:
  OUTPUT& out;
  size_t totlen;
  size_t totsup;
public:

  LStatOutput( OUTPUT& out, item_t numfreq )
    throw(std::ios_base::failure) : out(out), totlen(0), totsup(0){
        
  }
      
  template <class InputIterator> inline void DINLINE writeItemsetAndCounter( 
                                                                            InputIterator first, InputIterator last, 
                                                                            const counter_t support){
    totlen+=last-first; //will work only with randomaccessiterators
    totsup+=support; //to avoid the compiler optimizing it away
    out.writeItemsetAndCounter(first,last,support);
  }

  void flush() {
    out.flush();
  }

  ~LStatOutput( ){
    log_perf(0,"Total length of itemsets output: %u",totlen);
    log_perf(0,"Total support (ignore this fool statistics): %u",totsup);
  }
};


#endif //StatOutput_CPP

---