routing.cpp

Go to the documentation of this file.

#include "common.hpp"
#include "io/input/transaction_reader/brBufferedTransactionReader.hpp"
#include "io/input/transaction_reader/SortedTransactionReader.hpp"

#include "io/output/BufferedOutput.hpp"
#include "io/codec/decoder/df/DFDecoderWithEEManagement.hpp"

#include "util/StreamParser.hpp"
#include "util/FrequentFilter.cpp"

#include "datastructures/maxvector.hpp"
#include "datastructures/trie/edgelist/OrderedEdgelist.hpp"
//#include "datastructures/trie/edgelist/OrderedEdgelistDynLookup.hpp"
#include "datastructures/trie/edgelist/OffsetIndexVector.hpp"
//#include "datastructures/trie/edgelist/DoubleRepr.hpp"

#include "apriori/bodon/Trie.hpp"

#include "test/apriori/bodon/trie_manipulators/RoutingSelector.hpp"

#include <vector>
#include <iostream>
#include <string>


std::string file_format;

void init()
{
   file_format = "File format:";
   file_format += "\n\nThe transactionfile is a plan text file. Each row ";
   file_format += "represents a transaction. \n";
   file_format += "A transaction is a set of items seperated by a nonnumeric ";
   file_format += "character.\nIt can be for example a white space, comma, ";
   file_format += "colon, etc.\n";
   file_format += "Items are nonnegative integers.\n";
}
void usage()
{
   std::cerr << "\nUsage: routing routing_strat edge_repr transactionfile min_supp ";
   std::cerr << "outcomefile [options]\n";
   std::cerr << "\n routing_strat\t  the routing strategy, i.e: ";
   std::cerr << "merge, merge2, merge3, lookup_edge,\n\t\t  lookup_edge_prev_mem, ";
   std::cerr << "bitvector, indexvector, lookup_tr, hybrid, default\n";
   std::cerr << " edge_repr\t  the representation of the edge, i.e: ";
   std::cerr << "ordered_list, \n\t\t  offsetindex, hybrid";
   std::cerr << "\n transactionfile  file, that contains the tranasctions of items";
   std::cerr << "\n min_supp\t  absolute support threshold";
   std::cerr << "\n outcomefile\t  file to write the outcome";

   std::cerr << file_format;
   std::cerr << "\n\nHave a succesful mining ;-)"<<std::endl<<std::endl;
}

int process_arguments( int argc, char *argv[], counter_t& min_supp, 
                       bool &isrel, double &relminsupp )
{
   if ( argc < 6 )
   {
      usage();
      log_err(0,"There are 5 mandatory arguments.");
      return 2;
   }
   std::string mins=argv[4];
   if (mins[mins.size()-1]=='%') {
      mins.erase(mins.size()-1);
      isrel=true;
      relminsupp=atof(mins.c_str());
      relminsupp/=100;
      log_info(0,"Using relative minimum support of %lg",relminsupp);
      return 0;
   }
   isrel=false;
   int min_supp_i;
   try
   {
      convert(argv[4], min_supp_i);
      if ( min_supp_i <= 0  )
      {
         log_err(0,"%s cannot be converted to a positive integer.",argv[3]);
         return 3;
      }
   }
   catch(BadConversion e)
   {
      log_err(0,"min_supp conversion problem.");
      return 3;
   }
   min_supp = static_cast<counter_t>(min_supp_i);
   log_info(0,"min_supp is set to %d", min_supp);
   return 0;
}

int main( int argc, char *argv[] )
{
   init();
   counter_t min_supp;
   bool relative;
   double relminsupp;
      
   {
      int return_val = 
         process_arguments( argc, argv, min_supp, relative, relminsupp );
      if(return_val)
         return return_val;
   }

   char* routing = argv[1];
   char* input_file = argv[3];
   char* output_file = argv[5];

   try
   {
      // We assume that the transactions does not contain duplicates!!!
      typedef brBufferedTransactionReader< > T_R;
      // Otherwise uncmment this:
      // typedef SortedTransactionReader<brBufferedTransactionReader< >, true> T_R;

      T_R::params_t par_i;
      par_i.file_name = input_file;
      par_i.mode=FileReprBase::READ;
      par_i.file_buffer_size = 16 * 1024;
      T_R tr_reader(&par_i);
      std::vector< std::pair<counter_t, item_t> > freq_items_with_counters;
      counter_t nr_of_transactions;
      // The first step of each algorithms is determining the frequent items.
      FrequentFilter<T_R>
         fr_filter(tr_reader);
      log_status(0,"Finding frequent items.");
      fr_filter.findFrequentItems( freq_items_with_counters,   
                                   nr_of_transactions, min_supp);

      log_status(0,"Doing decoder.");
      typedef DFDecoderWithEEManagement< > DF_D;

      DF_D::params_t par_d;
      par_d.file_name = output_file;
      par_d.mode=FileReprBase::WRITE;
      DF_D df_decoder(&par_d);

      typedef Bodon::LeafWithoutConstructor LEAF_WC;     
      typedef Bodon::Leaf LEAF;  
      typedef bracz::singleualloc<LEAF_WC, 1024> LEAF_ALLOCATOR;

      if(strcmp(argv[2],"ordered_list")==0)
      {
         log_info(0,"Ordered edgelist representation is selected");
         typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelist<std::vector<Edge> > > TRIE;
         RoutingSelector<TRIE, LEAF_WC, LEAF_ALLOCATOR, T_R, DF_D>( 
            min_supp, routing, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder );
      }
      else if(strcmp(argv[2],"offsetindex")==0)
      {
         log_info(0,"Offsetindex edgelist representation is selected");
         typedef Bodon::Trie< LEAF, Bodon::OffsetIndexVector< std::vector<void*> > > TRIE;
         RoutingSelectorOffset<TRIE, LEAF_WC, LEAF_ALLOCATOR, T_R, DF_D>( 
            min_supp, routing, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder );
      }
      else if(strcmp(argv[2],"hybrid")==0)
      {
         log_info(0,"Hybrid edgelist representation is selected");
         typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelist<std::vector<Edge> > > TRIE_OEL;
         typedef Bodon::Trie< LEAF, Bodon::OffsetIndexVector< std::vector<void*> > > TRIE_OI;
         RoutingSelectorHybrid<TRIE_OEL, TRIE_OI, LEAF_WC, LEAF_ALLOCATOR, T_R, DF_D>( 
            min_supp, routing, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder );
      }
/*      else if(strcmp(argv[2],"double_repr")==0)
      {
         log_info(0,"Double edgelist representation is selected");
         typedef Bodon::Trie< LEAF, Bodon::DoubleRepr<maxvector<Edge>, maxvector<void*> > > TRIE;
         RoutingSelectorDouble<TRIE, LEAF_WC, LEAF_ALLOCATOR, T_R, DF_D>( 
            min_supp, routing, input_file, nr_of_transactions, 
            freq_items_with_counters, tr_reader, df_decoder );
      }
      else if(strstr(argv[2],"ordered_list_dyn"))
      {
         log_info(0,"Dynamic ordered edgelist representation is selected");
         char* threshold = argv[2] + strlen("ordered_list_dyn_");
         if(strcmp(threshold, "3") ==0)
         {
            log_info(0,"Threshold is set to: 3.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 3> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
         }
         else if(strcmp(threshold, "5") ==0)
         {
            log_info(0,"Threshold is set to: 5.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 5> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
         }
         else if(strcmp(threshold, "10") ==0)
         {
         log_info(0,"Threshold is set to: 10.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 10> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
         }
         else if(strcmp(threshold, "15") ==0)
         {
         log_info(0,"Threshold is set to: 15.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 15> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
         }
         else if(strcmp(threshold, "20") ==0)
         {
         log_info(0,"Threshold is set to: 20.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 20> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
         }
         else if(strcmp(threshold, "25") ==0)
         {
         log_info(0,"Threshold is set to: 25.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 25> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
         }
         else if(strcmp(threshold, "30") ==0)
         {
         log_info(0,"Threshold is set to: 30.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 30> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
         }
         else if(strcmp(threshold, "100") ==0)
         {
         log_info(0,"Threshold is set to: 100.");
            typedef Bodon::Trie< LEAF, Bodon::OrderedEdgelistDynLookup<maxvector<Edge>, 100> > TRIE;
            RoutingSelector<TRIE, LEAF, LEAF_ALLOCATOR, T_R, DF_D>( 
               min_supp, routing, input_file, nr_of_transactions, 
               freq_items_with_counters, tr_reader, df_decoder );
               }
               }*/
      else
      {
         usage();
         log_err(0,"edge_repr should be either ordered_list, offsetindex!");
         return 1;
      }
   }
   catch (std::ios_base::failure e)
   {
      log_err(0,"Exiting the program due to IO exception");
      return 1;
   }
}

---