eclat/main.cpp

Go to the documentation of this file.

#include "common.hpp"
#include "common/commandline.hpp"

#include "io/FILERepr.hpp"
#include "io/FDRepr.hpp"
#include "io/input/transaction_reader/TransactionReader.hpp"
#include "io/input/transaction_reader/LBufferedTransactionReader.hpp"

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

#include "io/codec/coder/Coder.hpp"
#include "util/FrequentFilter.cpp"

#include "eclat.hpp"


// get rid of non-informative namespaces...
//using namespace Bodon;
// using namespace Lars;


long long numint=0;
long long numlen=0;

// feature flags: (see also in SparseBitmatrix_setdifference.hpp and SparseBitmatrix_intersection.hpp)
#ifdef ECLAT_COVER
static const CodeMode RECODING_TYPE = DESC;
#endif

#ifdef ECLAT_DEFECT
static const CodeMode RECODING_TYPE = ASC;
#endif

#if (!defined(ECLAT_COVER)) && (!defined(ECLAT_DEFECT))
#error you must define at least one of ECLAT_COVER and ECLAT_DEFECT
#endif

#if (defined(ECLAT_COVER)) && (defined(ECLAT_DEFECT))
#error you must define at most one of ECLAT_COVER and ECLAT_DEFECT
#endif

// template types:
typedef LBufferedTransactionReader< > OriginalTransactionReader;
// typedef DFDecoderWithEEManagement<OutputBase<FILERepr> > PatternWriter;
typedef DFDecoderWithEEManagement< > PatternWriter;
typedef Coder<OriginalTransactionReader, PatternWriter> RecodedTransactionReader;



int main(int argc,  char *argv[])
{
   counter_t min_supp;
   if( !process_arguments( argc, argv, min_supp ) ) 
   {
      // 1. commandline parameters:
      char* filenameIn = argv[2];
      char* filenameOut = argv[4];

      // 1.5 output features: (for the logs)
      std::cout << "algorithmic features:"
                << " EXTDESC:" << (EXTENSION_DESCRIPTION_DEFECTS ? "DEF" : "COVER")
                << " REC:" << (RECODING_TYPE == NOCARE ? "no" : (RECODING_TYPE == ASC ? "ASC" : "DESC"))
                << " PEE" << (PRUNE_EQUISUPPORT_EXTENSIONS ? "+" : "-")
                << " OFIN" << (OMIT_FINAL_INCIDENCE_MATRIX ? "+" : "-")
                << " EFILT" << (EARLY_FILTERING ? "+" : "-");
      if (EXTENSION_DESCRIPTION_DEFECTS)
        ;
      else // if (EXTENSION_DESCRIPTION_COVERS) 
        std::cout << " RSWP" << (INTERSECTION_ROWSWAPPING ? "+" : "-");
      std::cout << std::endl;
      /*
      std::cout << "implementation features:"
                << " LARR" << (USE_LOCAL_ARRAYS ? "+" : "-")
                << endl;
      */

      if ((EXTENSION_DESCRIPTION_DEFECTS && RECODING_TYPE != ASC)
          || (! EXTENSION_DESCRIPTION_DEFECTS && RECODING_TYPE != DESC)) {
        std::cout << "options are not compatible right now: "
                  << " EXTDESC:" << (EXTENSION_DESCRIPTION_DEFECTS ? "DEF" : "COVER")
                  << " and"
                  << " REC:" << (RECODING_TYPE == NOCARE ? "no" : (RECODING_TYPE == ASC ? "ASC" : "DESC")) << std::endl;
        exit(1);
      }

      // 2. create transaction reader:
      OriginalTransactionReader::params_t par_i;
      par_i.file_name = filenameIn;
      par_i.mode=FileReprBase::READ;
      OriginalTransactionReader transactionReader(&par_i);

      // 3. find frequent items:
      std::cout << "Finding frequent items..." << std::flush;
      std::vector< std::pair<counter_t, item_t> > freq_items_with_counters;
      counter_t nr_of_transactions;
      FrequentFilter<OriginalTransactionReader> fr_filter(transactionReader);
      fr_filter.findFrequentItems( freq_items_with_counters, nr_of_transactions, min_supp);
      // item_t maxitem = freq_items_with_counters.size();
      // std::cout << " - done" << std::endl;

      // 4. setup pattern writer:
      // std::cout << "Setup i/o..." << std::flush;
      PatternWriter::params_t par_d;
      par_d.file_name = filenameOut;
      par_d.mode=FileReprBase::WRITE;
      PatternWriter patternWriter(&par_d);

      // 5. setup transaction reader:
      RecodedTransactionReader::params_t par_c;
      par_c.file_name = filenameIn;
      par_c.mode=FileReprBase::READ;
      par_c.largest_item = transactionReader.getLargestItem();
      par_c.decoder = &patternWriter;
      par_c.freq_items_with_counters = &freq_items_with_counters;
      // par_c.codemode = ASC;
      par_c.codemode = RECODING_TYPE;

      RecodedTransactionReader recodedTransactionReader(&par_c);
      std::cout << " - done" << std::endl;

      // 6. find frequent patterns
      Eclat<RecodedTransactionReader,PatternWriter> eclat(recodedTransactionReader, freq_items_with_counters, min_supp, nr_of_transactions, patternWriter);
      eclat.findFrequentPatterns();

      /*
      // 6. output all transaction to stdout:
      sorted_coder.rewind();
      std::vector<item_t> transaction;
      std::vector<item_t>::iterator it_transaction;
      while( sorted_coder.nextTransactionBIS( transaction ) )
      {      
         for( it_transaction = transaction.begin(); 
              it_transaction != transaction.end(); ++it_transaction )
         {
            std::cout << *it_transaction << " ";
         }
         std::cout << std::endl;
      }
      */
      cout << "num intersections " << numint << "; num lengths " << numlen <<std::endl;
   }
}

---