input_output_manager.cpp

来自「Aprior的C++实现算法」· C++ 代码 · 共 178 行

/***************************************************************************
                          Input_Output_Manager.cpp  -  description
                             -------------------
    begin                : cs march 10 2004
    copyright            : (C) 2004 by Ferenc Bodon
    email                : [e-mail]
 ***************************************************************************/


/**
  *@author Ferenc Bodon
  */
  
#include "Input_Output_Manager.hpp"
#include <iostream>

Input_Output_Manager::Input_Output_Manager( ifstream& basket_file, const char* output_file_name ):ofstream(output_file_name), basket_file(basket_file)
{
}

/**
  \param basket The basket that will be filled with the next row of the file.
  \return 0 if the end of file is reached, otherwise 1;
*/
int Input_Output_Manager::read_in_a_line( set<itemtype>& basket )
{
   if( basket_file.eof() ) return 0;
   char          c;
   itemtype      pos;

   basket.clear();
   do
   {
      int item = 0;
      pos = 0;
      basket_file.get(c);
      while(basket_file.good() && (c >= '0') && (c <= '9'))
      {
         pos++;
         item *= 10;
         item += int(c)-int('0');
         basket_file.get(c);
      }
      if( pos ) basket.insert( (itemtype) item );
   }
   while( c != '\n' && !basket_file.eof() );
   return 1;
}

/**
  \param mis_file The file that contain the relative mis values
  \param support_of_items The support of the items. The i<sup>th</sup> least frequent 
                          item's support is given by support_of_items[i].
   \param mis_abs The absolut support thresholds according to the new coding
  \return The number of transactions that the basketfile contains.
*/
unsigned long Input_Output_Manager::find_frequent_items( ifstream& mis_file,
                          set<pair<itemtype, unsigned long> >& support_of_items, 
                          vector<double>& mis_abs)
{
/// Reading in mis values
   itemtype item;
   double mis_value;

   set<pair<double,itemtype> > temp_set;

/// Reading in relative mis values
   vector<double> mis_values_original;
   while(!mis_file.eof())
   {
      mis_file>>item;
      mis_file.ignore();
      mis_file>>mis_value;
      if(mis_file.fail()) break;
      if(item + 1> mis_values_original.size())
	 mis_values_original.resize(item + 1);
      mis_values_original[item] = mis_value;
      temp_set.insert(pair<double,itemtype>(mis_value,item));
   }
   
/// Determining the support of the items
   unsigned long basket_number = 0;
   set<itemtype> basket;
   vector<unsigned long> temp_counter_vector;
   set<itemtype>::iterator it_basket;
   while( read_in_a_line( basket ) )
   {      
      if( !basket.empty() )
      {
         basket_number++;
         for( it_basket = basket.begin(); it_basket != basket.end(); it_basket++ )
         {
            if( *it_basket + 1  > temp_counter_vector.size() )
               temp_counter_vector.resize( *it_basket + 1, 0 );
            temp_counter_vector[*it_basket]++;
         }
      }
   }
   
   /// Filtering item, that do not need to consider.
   set<pair<double,itemtype> >::iterator it_s = temp_set.begin();
   while( temp_counter_vector[(*it_s).second] < (*it_s).first * (basket_number - 0.5) 
	  && it_s != temp_set.end() ) it_s++;
   /// Saving items and mis for item that need to be considered,
   /// and saving frequent items
   new_code_inverse.clear();
   double mis_abs_min = (*it_s).first * (basket_number - 0.5),
      temp_mis_abs;
   while( it_s != temp_set.end() )
   {
      if (temp_counter_vector[(*it_s).second] > mis_abs_min )
      {
	 temp_mis_abs = (*it_s).first * (basket_number - 0.5);
	 if( temp_counter_vector[(*it_s).second] > temp_mis_abs )
	    support_of_items.insert( pair<itemtype, unsigned long>(
				     new_code_inverse.size(), temp_counter_vector[(*it_s).second] ));
	 new_code_inverse.push_back((*it_s).second);
	 mis_abs.push_back(temp_mis_abs);
      }
      it_s++;
   }

   vector<itemtype>(new_code_inverse).swap(new_code_inverse);
   vector<double>(mis_abs).swap(mis_abs);
   set< pair<itemtype, unsigned long> >(support_of_items).swap(support_of_items);

   new_code.reserve(  temp_counter_vector.size() + 1 );
   new_code.resize(  temp_counter_vector.size() + 1, 0 );

   for( itemtype edgeIndex = 0; edgeIndex < new_code_inverse.size(); edgeIndex++ )
      new_code[new_code_inverse[edgeIndex]] = edgeIndex+1;
   return basket_number;
}
/**
  \param original_basket The basket to filter and recode.
  \param new_basket The created reduced basket
*/
void Input_Output_Manager::basket_recode( const set<itemtype>& original_basket, vector<itemtype>& new_basket )
{
   new_basket.clear();
   for( set<itemtype>::iterator it_basket = original_basket.begin(); it_basket != original_basket.end()
                                                                   ; it_basket++ )
     if( new_code[*it_basket] ) new_basket.push_back( new_code[*it_basket]-1 );
   sort( new_basket.begin(), new_basket.end() );     
}

void Input_Output_Manager::write_out_basket(const set<itemtype>& basket)
{
   for( set<itemtype>::const_iterator it_item = basket.begin(); it_item != basket.end(); it_item++)
   {
      operator<<( new_code_inverse[*it_item] );
      put(' ');
   }
}

void Input_Output_Manager::write_out_basket_and_counter(const set<itemtype>& itemset, const unsigned long counter)
{
   for( set<itemtype>::const_iterator it_item = itemset.begin(); it_item != itemset.end(); it_item++)
   {
      operator<<( new_code_inverse[*it_item] );
      put(' ');
   }
   put('(');
   operator<<(counter);
   write(")\n",2);
}

void Input_Output_Manager::rewind()
{
   basket_file.clear();
   basket_file.seekg(0, ios::beg);
}

Input_Output_Manager::~Input_Output_Manager()
{
   close();
}