thera 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,56 @@
+*.bundle
+*.o
+*.a
+output
+Makefile
+obj/
+mkmf.log
+
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore: 
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+#*.tmproj
+#tmtags
+
+# For emacs:
+#*~
+#\#*
+#.\#*
+
+# For vim:
+#*.swp
+
+# For redcar:
+#.redcar
+
+# For rubinius:
+#*.rbc

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rcov (0.9.10)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1 @@
+Public Domain

data/README.rdoc

@@ -0,0 +1,8 @@
+= thera
+
+Ruby Data Mining Library
+
+
+== Copyright
+
+None, this library is in the Public Domain.

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/ext/Makefile

@@ -0,0 +1,225 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = quarry
+topdir = /Users/will/.rvm/rubies/ruby-1.9.2-p290/include/ruby-1.9.1
+hdrdir = /Users/will/.rvm/rubies/ruby-1.9.2-p290/include/ruby-1.9.1
+arch_hdrdir = /Users/will/.rvm/rubies/ruby-1.9.2-p290/include/ruby-1.9.1/$(arch)
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+
+prefix = $(DESTDIR)/Users/will/.rvm/rubies/ruby-1.9.2-p290
+
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+
+exec_prefix = $(prefix)
+
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+
+sitehdrdir = $(rubyhdrdir)/site_ruby
+
+rubyhdrdir = $(includedir)/$(RUBY_BASE_NAME)-$(ruby_version)
+
+vendordir = $(rubylibprefix)/vendor_ruby
+
+sitedir = $(rubylibprefix)/site_ruby
+
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+
+mandir = $(datarootdir)/man
+
+localedir = $(datarootdir)/locale
+
+libdir = $(exec_prefix)/lib
+
+psdir = $(docdir)
+
+pdfdir = $(docdir)
+
+dvidir = $(docdir)
+
+htmldir = $(docdir)
+
+infodir = $(datarootdir)/info
+
+docdir = $(datarootdir)/doc/$(PACKAGE)
+
+oldincludedir = $(DESTDIR)/usr/include
+
+includedir = $(prefix)/include
+
+localstatedir = $(prefix)/var
+
+sharedstatedir = $(prefix)/com
+
+sysconfdir = $(prefix)/etc
+
+datadir = $(datarootdir)
+
+datarootdir = $(prefix)/share
+
+libexecdir = $(exec_prefix)/libexec
+
+sbindir = $(exec_prefix)/sbin
+
+bindir = $(exec_prefix)/bin
+
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+
+archdir = $(rubylibdir)/$(arch)
+
+sitelibdir = $(sitedir)/$(ruby_version)
+
+sitearchdir = $(sitelibdir)/$(sitearch)
+
+vendorlibdir = $(vendordir)/$(ruby_version)
+
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+
+
+CC = /usr/bin/gcc-4.2
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -lruby.1.9.1-static
+OUTFLAG = -o 
+COUTFLAG = -o 
+
+RUBY_EXTCONF_H = 
+cflags   =  $(optflags) $(debugflags) $(warnflags)
+optflags = -O3
+debugflags = -ggdb
+warnflags = -Wextra -Wno-unused-parameter -Wno-parentheses -Wpointer-arith -Wwrite-strings -Wno-missing-field-initializers -Wshorten-64-to-32 -Wno-long-long
+CFLAGS   = -fno-common -x c++ 
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir) -I./../lib/quarry/src
+DEFS     = 
+CPPFLAGS =  -D_XOPEN_SOURCE -D_DARWIN_C_SOURCE $(DEFS) $(cppflags)  -I/Users/will/.rvm/gems/ruby-1.9.2-p290/gems/rice-1.4.3/ruby/lib/include
+CXXFLAGS = $(CFLAGS)  -Wall -g
+ldflags  = -L. -L/usr/local/lib  -L/Users/will/.rvm/gems/ruby-1.9.2-p290/gems/rice-1.4.3/ruby/lib/lib
+dldflags = -Wl,-undefined,dynamic_lookup -Wl,-multiply_defined,suppress -Wl,-flat_namespace
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags)
+LDSHARED = g++ -dynamic -bundle
+LDSHAREDXX = $(CXX) -dynamic -bundle
+AR = ar
+EXEEXT = 
+
+RUBY_BASE_NAME = ruby
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = ruby.1.9.1
+arch = x86_64-darwin11.1.0
+sitearch = $(arch)
+ruby_version = 1.9.1
+ruby = /Users/will/.rvm/rubies/ruby-1.9.2-p290/bin/ruby
+RUBY = $(ruby)
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = $(RUBY) -run -e rmdir -- -p
+MAKEDIRS = mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+
+#### End of system configuration section. ####
+
+preload = 
+
+
+CXX = g++
+
+libpath = . $(libdir) ./../lib/quarry/obj
+LIBPATH =  -L. -L$(libdir) -L./../lib/quarry/obj
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = -lquarry -lrice -lruby.1.9.1 -lpthread -ldl -lobjc 
+SRCS = quarry_toolkit.cpp
+OBJS = quarry_toolkit.o
+TARGET = quarry_toolkit
+DLLIB = $(TARGET).bundle
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).bundle 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-rb
+
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-rb-default clean-rb
+		@-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES)
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean: clean distclean-so distclean-rb-default distclean-rb
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		@-$(RMDIRS) $(DISTCLEANDIRS)
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	@-$(MAKEDIRS) $(@D)
+	$(INSTALL_PROG) $(DLLIB) $(@D)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .C .o
+
+.cc.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.C.o:
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.o:
+	$(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+$(DLLIB): $(OBJS) Makefile
+	@-$(RM) $(@)
+	$(LDSHAREDXX) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(hdrdir)/ruby.h $(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h

data/ext/extconf.rb

@@ -0,0 +1,29 @@
+require 'mkmf-rice'
+
+QUARRY_H      = 'quarry.h'
+MARKER        = 'mkmf_marker'
+quarry_dir    = File.join(File.dirname(__FILE__), '..', 'lib', 'quarry')
+quarry_obj    = File.join(quarry_dir, 'obj')
+quarry_src    = File.join(quarry_dir, 'src')
+quarry_header = File.join(quarry_src, QUARRY_H)
+
+# compile quarry as a static lib
+Dir.chdir(quarry_dir) do
+  if RUBY_PLATFORM =~ /darwin/
+    puts "Compiling quarry (OS X mode)"
+    `make -f Makefile.osx clean`
+    `make -f Makefile.osx`
+  else
+    puts "Compiling quarry (linux mode)"
+    `make -f Makefile.linux clean`
+    `make -f Makefile.linux`
+  end
+end
+
+# the cflags are required to make mkmf compile in c++ mode
+with_cflags("-x c++") do
+  find_header(QUARRY_H, quarry_src)
+  $LIBPATH << quarry_obj
+  have_library('quarry', MARKER, quarry_header)
+  create_makefile('quarry_toolkit', 'quarry')
+end

data/ext/quarry/quarry_toolkit.cpp

@@ -0,0 +1,148 @@
+#include "rice/Constructor.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Module.hpp"
+#include "rice/Array.hpp"
+#include "quarry.h"
+using namespace Rice;
+
+Object model_rank(Object self, Object ex) {
+  Model::Model *model = from_ruby<Model::Model *>(self);
+  DataSet::Example *example = from_ruby<DataSet::Example *>(ex);
+  Array indexes;
+  
+  vector<Classifier::Score> *ranks = model->rank(example);
+  for(unsigned int i = 0; i < ranks->size(); i++)
+    indexes.push(ranks->at(i).category);
+
+  delete ranks;
+  return indexes;
+}
+
+Object model_rank_text(Object self, Object text) {
+  Model::Model *model = from_ruby<Model::Model *>(self);
+  string example_text = from_ruby<string>(text);
+  Array indexes;
+  
+  vector<Classifier::Score> *ranks = model->rank_text(example_text);
+  for(unsigned int i = 0; i < ranks->size(); i++)
+    indexes.push(ranks->at(i).category);
+
+  delete ranks;
+  return indexes;
+}
+
+
+extern "C" {
+	
+  void Init_quarry_toolkit() {
+    Module rb_mQuarry = define_module("Quarry");
+    Module rb_mDataSet = define_module_under(rb_mQuarry, "DataSet");
+    Module rb_mClassifier = define_module_under(rb_mQuarry, "Classifier");
+    Module rb_mPreprocessing = define_module_under(rb_mQuarry, "Preprocessing");
+    Module rb_mText = define_module_under(rb_mPreprocessing, "Text");
+    
+    
+    // text pipeline
+    rb_mText.define_module_function("standard_pipeline", &Preprocessing::Text::StandardPipeline);
+    Data_Type<Preprocessing::Text::TextPipeline> rb_cTextPipeline = define_class_under<Preprocessing::Text::TextPipeline>(rb_mQuarry, "ImplTextPipeline")
+      .define_constructor(Constructor<Preprocessing::Text::TextPipeline>())
+      .define_method("process_text", &Preprocessing::Text::TextPipeline::process_text);
+    
+    // storage
+    Data_Type<Storage::Storage> rb_cStorage = define_class_under<Storage::Storage>(rb_mQuarry, "ImplStorage");
+    
+    Data_Type<Storage::ARFF> rb_cARFF = define_class_under<Storage::ARFF, Storage::Storage>(rb_mQuarry, "ImplARFF")
+      .define_constructor(Constructor<Storage::ARFF, string>())
+      .define_method("read", &Storage::ARFF::read);
+    
+    Data_Type<Storage::Binary> rb_cBinary = define_class_under<Storage::Binary, Storage::Storage>(rb_mQuarry, "ImplBinary")
+      .define_constructor(Constructor<Storage::Binary, string>())
+      .define_method("read", &Storage::Binary::read)
+      .define_method("write", &Storage::Binary::write)
+      .define_method("read_model", &Storage::Binary::read_model)
+      .define_method("write_model", &Storage::Binary::write_model)
+      .define_method("get_write_examples", &Storage::Binary::get_write_examples)
+      .define_method("set_write_examples", &Storage::Binary::set_write_examples);      
+    
+    Data_Type<Storage::Folders> rb_cFolders = define_class_under<Storage::Folders, Storage::Storage>(rb_mQuarry, "ImplFolders")
+      .define_constructor(Constructor<Storage::Folders, string, Preprocessing::Text::TextPipeline *>())
+      .define_method("read", &Storage::Folders::read);
+    
+    
+    // model
+    Data_Type<Model::Model> rb_cModel = define_class_under<Model::Model>(rb_mQuarry, "ImplModel")
+      .define_constructor(Constructor<Model::Model>())
+      .define_method("train", &Model::Model::train)
+      .define_method("train_text", &Model::Model::train_text)
+      .define_method("classify", &Model::Model::classify)
+      .define_method("classify_text", &Model::Model::classify_text)
+      .define_method("set_data_set", &Model::Model::set_data_set)
+      .define_method("get_data_set", &Model::Model::get_data_set)
+      .define_method("set_classifier", &Model::Model::set_classifier)
+      .define_method("get_classifier", &Model::Model::get_classifier)
+      .define_method("set_text_pipeline", &Model::Model::set_text_pipeline)
+      .define_method("get_text_pipeline", &Model::Model::get_text_pipeline)
+      .define_method("rank", &model_rank)
+      .define_method("rank_text", &model_rank_text);
+      
+
+    
+    // data set
+    Data_Type<DataSet::Feature> rb_cDataSetFeature = define_class_under<DataSet::Feature>(rb_mDataSet, "ImplFeature")
+      .define_method("get_name", &DataSet::Feature::get_name)
+      .define_method("set_name", &DataSet::Feature::set_name)
+      .define_constructor(Constructor<DataSet::Feature, string, int>());
+    
+    Data_Type<DataSet::Example> rb_cDataSetExample = define_class_under<DataSet::Example>(rb_mDataSet, "ImplExample")
+      .define_method("category_index", &DataSet::Example::category_index)
+      .define_method("get_value", &DataSet::Example::get_value)
+      .define_method("set_value", &DataSet::Example::set_value)
+      .define_constructor(Constructor<DataSet::Example, int>());
+    
+    Data_Type<DataSet::DataSet> rb_cDataSet = define_class_under<DataSet::DataSet>(rb_mDataSet, "ImplDataSet")
+      .define_constructor(Constructor<DataSet::DataSet>())
+      .define_method("get_name", &DataSet::DataSet::get_name)
+      .define_method("set_name", &DataSet::DataSet::set_name)
+      .define_method("features_size", &DataSet::DataSet::features_size)
+      .define_method("examples_size", &DataSet::DataSet::examples_size)
+      .define_method("get_feature_by_index", &DataSet::DataSet::get_feature_by_index)
+      .define_method("get_feature_by_name", &DataSet::DataSet::get_feature_by_name)
+      .define_method("get_example_by_index", &DataSet::DataSet::get_example_by_index)
+      .define_method("stratify", &DataSet::DataSet::stratify)
+      .define_method("cross_fold_validation", &DataSet::DataSet::cross_fold_validation);
+
+
+    // abstract classifier
+    Data_Type<Classifier::Classifier> rb_cClassifierClassifier = define_class_under<Classifier::Classifier>(rb_mClassifier, "ImplClassifier")
+      .define_method("prepare", &Classifier::Classifier::prepare)
+      .define_method("classify", &Classifier::Classifier::classify);
+      
+      
+    // bayesian classifiers
+    Data_Type<Classifier::NaiveBayesClassifier> rb_cClassifierNaiveBayesClassifier = define_class_under<Classifier::NaiveBayesClassifier, Classifier::Classifier>(rb_mClassifier, "ImplNaiveBayesClassifier")
+      .define_constructor(Constructor<Classifier::NaiveBayesClassifier, DataSet::DataSet *>());
+    
+    
+    // confusion matrix
+    Data_Type<ConfusionMatrix> rb_cConfusionMatrix = define_class_under<ConfusionMatrix>(rb_mQuarry, "ImplConfusionMatrix")
+      .define_constructor(Constructor<ConfusionMatrix, DataSet::DataSet *>())
+      .define_method("accuracy", &ConfusionMatrix::accuracy)
+      .define_method("error", &ConfusionMatrix::error)
+      .define_method("print_summary", &ConfusionMatrix::print_summary)
+      .define_method("avg_tp", &ConfusionMatrix::avg_tp)
+      .define_method("avg_fp", &ConfusionMatrix::avg_fp)
+      .define_method("avg_tn", &ConfusionMatrix::avg_tn)
+      .define_method("avg_fn", &ConfusionMatrix::avg_fn)
+      .define_method("avg_precision", &ConfusionMatrix::avg_precision)
+      .define_method("avg_recall", &ConfusionMatrix::avg_recall)
+      .define_method("avg_fscore", &ConfusionMatrix::avg_fscore)
+      .define_method("add", &ConfusionMatrix::add)
+      .define_method("tp", &ConfusionMatrix::tp)
+      .define_method("fp", &ConfusionMatrix::tp)
+      .define_method("tn", &ConfusionMatrix::tp)
+      .define_method("fn", &ConfusionMatrix::tp)
+      .define_method("precision", &ConfusionMatrix::tp)
+      .define_method("recall", &ConfusionMatrix::tp)
+      .define_method("fscore", &ConfusionMatrix::tp);
+  }
+}

data/lib/quarry/Makefile.linux

@@ -0,0 +1,2 @@
+STATIC_LIB = ar rcs
+include Makefile.targets

data/lib/quarry/Makefile.osx

@@ -0,0 +1,6 @@
+STATIC_LIB = libtool -o
+CXX = clang++
+CPPFLAGS = -Wno-deprecated-writable-strings
+#CXX = g++
+#CPPFLAGS = -ggdb
+include Makefile.targets

data/lib/quarry/Makefile.targets

@@ -0,0 +1,23 @@
+SRCS = src/quarry.cpp src/data_set/data_set.cpp src/data_set/example.cpp src/data_set/sparse/sparse_example.cpp src/data_set/features/nominal_feature.cpp src/data_set/features/numeric_feature.cpp src/classifier/classifier.cpp src/classifier/naive_bayes/naive_bayes_classifier.cpp src/metrics/confusion_matrix.cpp src/storage/arff.cpp src/storage/folders.cpp src/storage/binary.cpp src/preprocessing/text/text_pipeline.cpp src/preprocessing/text/inplace_processor/porter_stemmer_original.cpp src/preprocessing/text/token_selector/stop_words.cpp src/preprocessing/text/tokeniser/simple_tokeniser.cpp src/model/model.cpp
+OBJS = ${SRCS:.cpp=.o}
+INCFLAGS = -Isrc
+CPPFLAGS += -O3
+LIB = libquarry.a
+
+.SUFFIXES:
+.SUFFIXES: .cpp .o
+
+.cpp.o :
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) -o $@ -c $<
+
+all : $(LIB)
+
+$(LIB) : $(OBJS)
+	$(STATIC_LIB) obj/$(LIB) $(OBJS)
+
+test : $(LIB)
+	$(CXX) $(INCFLAGS) $(CPPFLAGS) -o obj/test obj/$(LIB) src/test.cpp
+
+clean :
+	rm -f $(OBJS)
+	rm -f obj/*

data/lib/quarry/src/classifier/classifier.cpp

@@ -0,0 +1,32 @@
+#include "classifier.h"
+
+int Classifier::Classifier::classify(DataSet::Example *example) {
+  double max_score = 0.0, category_score = 0.0;
+  int max_category = 1;
+
+  for(int category = 1; category <= data_set->categories_size(); category++) {
+    category_score = score(category, example);
+    if(category_score > max_score) {
+      max_score = category_score;
+      max_category = category;
+    }
+  }
+  
+  return max_category;
+}
+
+vector<Classifier::Score> *Classifier::Classifier::rank(DataSet::Example *example) {
+  vector<Score> *scores = score_all(example);
+  sort(scores->begin(), scores->end(), Score::compare);
+  return scores;
+}
+
+vector<Classifier::Score> *Classifier::Classifier::score_all(DataSet::Example *example) {
+  vector<Score> *scores = new vector<Score>();
+  scores->reserve(data_set->categories_size());
+  
+  for(int category = 1; category <= data_set->categories_size(); category++)
+    scores->push_back(Score(category, score(category, example)));
+  
+  return scores;
+}

data/lib/quarry/src/classifier/classifier.h

@@ -0,0 +1,59 @@
+#ifndef __classifier__
+#define __classifier__
+#include "data_set/data_set.h"
+#include <algorithm>
+#include <utility>
+#include <vector>
+#include <iostream>
+#include <typeinfo>
+using namespace std;
+
+namespace Storage {
+  class Binary;
+}
+
+namespace Classifier {
+  
+  class Score {
+  public:
+    int     category;
+    double  score;
+    
+    Score(int category, double score) : category(category), score(score) {}
+    static bool compare (Score a, Score b) {
+      return b.score < a.score; // descending
+    }
+  };
+  
+  
+  class Classifier {
+  public:
+    DataSet::DataSet *data_set;
+    vector<bool> numeric_features;
+    vector<bool> nominal_features;
+    
+    Classifier(DataSet::DataSet *data_set) : data_set(data_set), numeric_features(data_set->features_size(), 0), nominal_features(data_set->features_size(), 0) {
+      DataSet::Feature *feature = NULL;
+      
+      for(unsigned int i = 0; i < data_set->features.size(); i++) {
+        feature = data_set->features[i];
+        if(typeid(*feature) == typeid(DataSet::NumericFeature))
+          numeric_features[i] = true;
+        else
+          nominal_features[i] = true;
+      }
+    }
+    
+    virtual void prepare() {};
+    virtual Classifier *clone(DataSet::DataSet *new_data_set) = 0;
+    virtual double score(int category, DataSet::Example *example) = 0;
+    virtual int classify(DataSet::Example *example);
+    virtual vector<Score> *rank(DataSet::Example *example);
+    virtual vector<Score> *score_all(DataSet::Example *example);
+    virtual void write_binary(Storage::Binary *file) {}
+    virtual void read_binary(Storage::Binary *file) {}
+    virtual uint32_t mark() = 0;
+  };
+}
+
+#endif