rocker 0.0.4

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2010-04-22
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/rocker.rb
+script/console
+script/destroy
+script/generate
+test/test_helper.rb
+test/test_rocker.rb
+ext/rocker/extconf.rb
+ext/rocker/auc_info.h
+ext/rocker/constants.h
+ext/rocker/fetcher.h
+ext/rocker/updater.h
+ext/rocker/line_input_iterator.h
+ext/rocker/rocker.h
+ext/rocker/rocker.cpp

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on rocker, see http://rocker.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,57 @@
+= rocker
+
+* http://github.com/MarcotteLabGit/rocker
+
+== DESCRIPTION:
+
+This gem is very fast C++ code for calculating AUCs on results of cross-validation.
+
+It is specific to the crossval database schema, which has not been released yet.
+
+Chances are you will not find this very useful unless you are the author.
+
+It is in gem form to ensure that each lab machine can compile its own arch-specific
+version.
+
+== FEATURES/PROBLEMS:
+
+* There is no real reason this couldn't work for other schemas, but an adapter
+would have to be generated. I have no motivation to do this, but if you are
+interested, please feel free to get in touch.
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* crossval
+
+== INSTALL:
+
+* sudo gem install rocker, most likely, but I haven't tried it yet.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIXME full name
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/rocker'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'rocker' do
+  self.developer 'John Woods', 'john.woods@marcottelab.org'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/ext/rocker/auc_info.h

@@ -0,0 +1,51 @@
+#ifndef AUC_INFO_H
+# define AUC_INFO_H
+
+#include <string>
+#include <sstream>
+#include <iostream>
+
+typedef unsigned int  uint;
+
+
+using std::ostringstream;
+using std::string;
+using std::ostream;
+
+const string AUC_COLUMNS = "(experiment_id, column, auc, true_positives, false_positives, true_negatives, false_negatives)";
+
+class auc_info {
+public:
+    double auc;
+    uint tp;
+    uint fp;
+    uint tn;
+    uint fn;
+
+    // Constructor
+    auc_info(double area_under_curve = 0, uint true_positives = 0, uint false_positives = 0, uint true_negatives = 0, uint false_negatives = 0)
+    : auc(area_under_curve), tp(true_positives), fp(false_positives), tn(true_negatives), fn(false_negatives) { }
+
+    ~auc_info() { }
+
+    // Convert to a portion of a SQL insertion (string)
+    string to_s() const {
+        ostringstream s;
+        s << auc << ", " << tp << ", " << fp << ", " << tn << ", " << fn;
+        return s.str();
+    }
+
+    string entry(uint experiment_id, uint j) const {
+        ostringstream s;
+        s << '(' << experiment_id << ", " << j << ", " << to_s() << ')';
+        return s.str();
+    }
+};
+
+// Probably not necessary.
+std::ostream& operator<<(std::ostream& out, const auc_info& rhs) {
+    out << rhs.to_s();
+    return out;
+}
+
+#endif

data/ext/rocker/constants.h

@@ -0,0 +1,39 @@
+// DATABASE CONSTANTS AND INCLUDES
+#include <string>
+#include <sstream>
+#include <pqxx/connection.hxx>
+#include <pqxx/transaction.hxx>
+
+
+// DATABASE CONSTANTS
+const std::string DBNAME             = "crossval_development";
+const std::string USER               = "jwoods";
+const std::string PASSWORD           = "youwish1";
+const std::string READ_TRANSACTION   = "ReadTransaction";
+const std::string WRITE_TRANSACTION  = "WriteTransaction";
+
+// RESULTS CONSTANTS
+const std::string ROCKER_VERSION = "0.0.1";
+
+class database_string {
+public:
+    database_string(std::string dbn = DBNAME, std::string u = USER, std::string p = PASSWORD) : dbname(dbn), user(u), password(p) { }
+    ~database_string() { }
+
+    std::string dbname;
+    std::string user;
+    std::string password;
+
+    std::string operator()() {
+        std::ostringstream arg;
+        arg << "dbname=" << dbname << " user=" << user << " password=" << password;
+        return arg.str();
+    }
+};
+
+
+// USED TO GENERATE DBARG CONSTANT:
+std::string make_db_argument(const std::string& dbname, const std::string& user, const std::string& password) {
+    database_string dbstr(dbname, user, password);
+    return dbstr();
+}

data/ext/rocker/extconf.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'mkmf-rice'
+
+dir_config("rocker")
+dir_config("boost")
+
+have_library("stdc++")
+have_library("pqxx")
+# have_library("boost")
+have_library("boost_filesystem")
+if RUBY_VERSION =~ /1.9/ then
+  $CPPFLAGS += " -DRUBY_19"
+end
+
+create_makefile('rocker')

data/ext/rocker/fetcher.h

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <set>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <pqxx/transactor.hxx>
+#include <pqxx/result.hxx>
+
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::set;
+using std::vector;
+using std::string;
+using std::ostringstream;
+using pqxx::transactor;
+using pqxx::result;
+
+typedef unsigned int  uint;
+
+
+class Fetcher : public transactor <> {
+public:
+    Fetcher() : transactor<>("Fetcher") {}
+
+    uint matrix_id;
+    uint experiment_id;
+    vector< set<uint> > known_correct;
+    string query;
+
+    void operator()(argument_type &T) {
+        result R;
+        query = make_known_correct_query().c_str();
+
+        try {
+            R = T.exec(query);
+
+            vector< set<uint> > known(R.size());
+
+            // Get the row and add it to the results set
+            for (result::const_iterator it = R.begin(); it != R.end(); ++it) {
+                uint i; uint j;
+                (*it)[1].to(j); // Get column
+                (*it)[2].to(i); // Get gene
+                known[j].insert(i);
+            }
+
+            known_correct = known;
+
+        } catch (pqxx::sql_error e) {
+            cerr << "SQL error in Fetcher transactor." << endl;
+            cerr << "Query: " << e.query() << endl;
+            cerr << "Error: " << e.what()  << endl;
+        }
+    }
+
+protected:
+    string make_known_correct_query() const {
+        ostringstream q;
+        q << "SELECT id, j, i FROM entries WHERE matrix_id = " << matrix_id
+          << " AND type = 'Cell' ORDER BY j,i;";
+        return q.str();
+    }
+};

data/ext/rocker/line_input_iterator.h

@@ -0,0 +1,114 @@
+
+#include <iterator>
+#include <istream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <cassert>
+#include <utility>
+// #include <boost/lexical_cast.hpp>
+
+// using boost::lexical_cast;
+
+template <class StringT = std::string>
+class LineInputIterator :
+    public std::iterator<std::input_iterator_tag, StringT, std::ptrdiff_t, const StringT*, const StringT&>
+{
+public:
+    typedef typename StringT::value_type char_type;
+    typedef typename StringT::traits_type traits_type;
+    typedef std::basic_istream<char_type, traits_type> istream_type;
+
+    LineInputIterator() : is(NULL) { }
+    LineInputIterator(istream_type& is): is(&is) { }
+
+    const StringT& operator*() const { return value; }
+    const StringT* operator->() const { return &value; }
+    
+    LineInputIterator<StringT>& operator++() {
+        assert(is != NULL);
+        if (is && !std::getline(*is, value)) {
+            is = NULL;
+        }
+        return *this;
+    }
+
+    LineInputIterator<StringT> operator++(int) {
+        LineInputIterator<StringT> prev(*this);
+        ++*this;
+        return prev;
+    }
+
+    bool operator!=(const LineInputIterator<StringT>& other) const {
+        return is != other.is;
+    }
+
+    bool operator==(const LineInputIterator<StringT>& other) const {
+        return !(*this != other);
+    }
+
+protected:
+    istream_type* is;
+    StringT value;
+};
+
+
+template <typename GeneT = unsigned int, typename ScoreT = double>
+class GeneScoreIterator : public LineInputIterator<std::string> {
+public:
+    typedef typename std::pair<GeneT,ScoreT> pair_type;
+    typedef typename std::string::value_type char_type;
+    typedef typename std::string::traits_type traits_type;
+    typedef std::basic_istream<char_type, traits_type> istream_type;
+
+    GeneScoreIterator() : is(NULL) { }
+    GeneScoreIterator(istream_type& is): is(&is) {
+        ++*this; // Priming read.
+    }
+
+    GeneScoreIterator<GeneT,ScoreT>& operator++() {
+        assert(is != NULL);
+
+        if (is) {
+            if (std::getline(*is, value)) {
+
+                // Cast the contents of the string
+                std::istringstream in(value, std::istringstream::in);
+                in >> value_gene_score.first;
+                in >> value_gene_score.second;
+            } else {
+                is = NULL;
+            }
+        }
+        return *this;
+    }
+
+    GeneScoreIterator<GeneT,ScoreT> operator++(int) {
+        GeneScoreIterator<std::string> prev(*this);
+        ++*this;
+        return prev;
+    }
+
+    // De-reference
+    const pair_type operator*() const {
+        return value_gene_score;
+    }
+    const pair_type* operator->() const {
+        return &value_gene_score;
+    }
+
+    bool operator!=(const GeneScoreIterator<GeneT,ScoreT>& other) const {
+        return is != other.is;
+    }
+
+    bool operator==(const GeneScoreIterator<GeneT,ScoreT>& other) const {
+        return !(*this != other);
+    }
+
+    const std::string test_value() const { return value; }
+
+protected:
+    istream_type* is;
+    std::string value;
+    pair_type value_gene_score;
+};

data/ext/rocker/rocker.cpp

@@ -0,0 +1,113 @@
+/* Rocker gem C++ extension
+ * Part of crossval, in the Phenolog project
+ * (C) John O. Woods, The Marcotte Lab, 2010
+ *
+ * Requires boost, boost_filesystem, rice (Ruby in C++ Extension), and of course
+ * Ruby (1.8). Use at your own risk if you're not a lab member!
+ *
+ * To compile, run irb or script/console and do:
+ *  require 'extconf'
+ *
+ * Then leave the console, and type:
+ *  make
+ *
+ * You will then load the module from within the ruby shell using:
+ *  require 'rocker'
+ *
+ * Instantiate using:
+ *  Rocker.new("dbname=crossval_production username=youruser password=yourpass", 1, 167)
+ *
+ * (That connects to the specified PostgreSQL database and autoloads matrix 1
+ *  data. Updates will be made to experiment 167. This is just an example.)
+ */
+
+// g++ -I/usr/include -I/usr/local/include -L/usr/lib -L/usr/local/lib -lpqxx -lboost_filesystem rocker.cpp -o rocker
+#include <rice/Data_Type.hpp>
+#include <rice/Constructor.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+using std::cout;
+using std::endl;
+using namespace Rice;
+
+#include "rocker.h"
+
+//#include "line_input_iterator.h"
+
+typedef LineInputIterator<std::string> line_input_iterator;
+
+
+extern "C"
+void Init_rocker() {
+
+    // Expose Rocker class to Ruby
+    //database_string dbarg(DBNAME, USER, PASSWORD);
+    Data_Type<Rocker> rb_cRocker =
+            define_class<Rocker>("Rocker")
+             .define_constructor(Constructor<Rocker,std::string,uint,uint>())
+             .define_method("process_results", &Rocker::process_results)
+             .define_method("fetch", &Rocker::fetch, (Arg("j")))
+             .define_method("calculate_statistic",
+                            &Rocker::calculate_statistic,
+                            (Arg("j"), Arg("threshold") = (double)(0.0)))
+             .define_method("read_candidates", &Rocker::read_candidates, (Arg("j")))
+             .define_method("mean_auc", &Rocker::mean_auc);
+
+}
+
+extern "C"
+void Init_DatabaseString() {
+    Data_Type<database_string> rb_cDatabaseString =
+        define_class<database_string>("DatabaseString")
+         .define_constructor(Constructor<database_string,std::string,std::string,std::string>())
+         .define_method("to_s", &database_string::operator());
+}
+
+// Uncomment to test -- probably unnecessary now that the Ruby extensions are
+// built.
+/*
+int main(int argc, char* argv[]) {
+    database_string dbarg(DBNAME, USER, PASSWORD);
+    Rocker rocker(dbarg(), 1, 167);
+
+    uint j = 0, m = 0, x = 0;
+    cout << "Args: " << argc << endl;
+    if (argc < 4) {
+        cerr << "Please provide matrix id, experiment id, and column as arguments." << endl;
+        return EXIT_FAILURE;
+    } else {
+        // Read command line arguments.
+        m = atoi(argv[1]);
+        x = atoi(argv[2]);
+        j = atoi(argv[3]);
+    }
+
+    set<uint> gene_ids = rocker.fetch(42);
+    for (set<uint>::const_iterator i = gene_ids.begin(); i != gene_ids.end(); ++i)
+        cout << *i << endl;
+
+    cout << "---" << endl;
+    gene_score_list candidates = rocker.read_candidates(42);
+    for (gene_score_list::iterator i = candidates.begin(); i != candidates.end(); ++i)
+        cout << "hi:\t" << i->first << '\t' << i->second << endl;
+
+    cout << "---" << endl;
+    auc_info test = rocker.calculate_statistic(42);
+    cout << "auc\t=" << test.auc << endl;
+    cout << " tp\t=" << test.tp << endl;
+    cout << " fp\t=" << test.fp << endl;
+    cout << " tn\t=" << test.tn << endl;
+    cout << " fn\t=" << test.fn << endl;
+
+    cerr << "m=" << m << endl;
+    cerr << "x=" << x << endl;
+    cerr << "j=" << j << endl;
+
+    rocker.process_results();
+
+    return EXIT_SUCCESS;
+}
+*/

data/ext/rocker/rocker.h

@@ -0,0 +1,227 @@
+#include "constants.h"
+#include "line_input_iterator.h"
+#include "fetcher.h"
+#include "updater.h"
+#include "auc_info.h"
+
+#include <string>
+#include <utility>
+#include <sstream>
+#include <list>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/lexical_cast.hpp>
+
+using boost::filesystem::exists;
+using boost::filesystem::ifstream;
+using std::string;
+using std::list;
+using std::ostringstream;
+
+// typedef unordered_map<uint, double> gene_score_map;
+typedef list<std::pair<uint,double> > gene_score_list;
+typedef GeneScoreIterator<unsigned int,double> gene_score_iterator;
+
+
+string path_to_s(const boost::filesystem::path& p) {
+    return p.string().substr(2);
+}
+
+bool path_to_uint(const boost::filesystem::path& p, uint& n) {
+    using boost::lexical_cast;
+    using boost::bad_lexical_cast;
+    
+    string s = path_to_s(p);
+    try {
+        n = lexical_cast<uint>(s);
+    } catch(bad_lexical_cast &) {
+        cerr << "Unable to read phenotype file '" << s << "': not numeric" << endl;
+        return false;
+    }
+    return true;
+}
+
+
+class Rocker {
+public:
+
+    // Connect to the database and create the read transaction
+    Rocker(string dbarg, uint m_id, uint e_id) : c(dbarg), mean_auc_(0.0) {
+        // Make sure the fetcher knows which matrix to restrict queries to.
+        fetcher.matrix_id = m_id;
+
+        // Set up a transaction
+        action = new pqxx::transaction<>(c, READ_TRANSACTION);
+
+        fetcher(*action); // Perform the fetch.
+
+        delete action;
+
+        updater.experiment_id = e_id;
+        updater.aucs = process_results();
+
+        action = new pqxx::transaction<>(c, WRITE_TRANSACTION);
+
+        updater(*action);
+
+        delete action;
+    }
+
+
+    //
+    ~Rocker() { }
+
+
+    // Return the mean AUC calculated -- requires that process_results was called,
+    // which happens in the constructor, so it's okay.
+    double mean_auc() { return mean_auc_; }
+    
+    // Go through the results directory
+    map<uint,auc_info> process_results() {
+        using namespace boost::filesystem;
+        map<uint, auc_info> rocs;
+        
+        double temp_auc_accum = 0.0; // Keep track of AUCs so we can get a mean
+        size_t divide_by      = 1;
+        
+        // Look at all files in the directory
+        for (basic_directory_iterator<path> jit(path(".")); jit != directory_iterator(); ++jit) {
+            uint j = 0;
+            if (path_to_uint(jit->path(), j)) {
+                // Read the file and calculate AUCs.
+                rocs[j] = calculate_statistic(j);
+                temp_auc_accum += rocs[j].auc;
+                ++divide_by;
+                
+                cout << "AUC: " << rocs[j].auc << endl;
+            }
+        }
+
+        // Calculate the mean AUC
+        if (divide_by > 0)
+            mean_auc_ = temp_auc_accum / (double)(divide_by);
+        else
+            mean_auc_ = 0;
+
+        return rocs;
+    }
+
+
+    // Get genes with a specific phenotype association (phenotype id = j).
+    set<uint> fetch(uint j) const {
+        return fetcher.known_correct[j];
+    }
+
+
+    // For some phenotype j, determine AUC, fp, tp, fn, tn, etc.
+    auc_info calculate_statistic(uint j, double threshold = 0.0) const {
+        set<uint> known_correct = fetch(j);
+        gene_score_list candidates = read_candidates(j);
+        //cerr << "Size of known_correct: " << known_correct.size() << endl;
+
+        // Attempted transcription of code from Ruby into C++, after having taken
+        // it from Python the first time.
+        // No guarantees!
+        vector<size_t> t;
+        t.reserve(candidates.size()+1); t.push_back(0);
+        vector<size_t> f = t;
+
+        auc_info result;
+
+        for (gene_score_list::const_iterator i = candidates.begin(); i != candidates.end(); ++i) {
+            if (known_correct.find(i->first) != known_correct.end()) {
+                t.push_back( *(t.rbegin()) + 1 );
+                f.push_back( *(f.rbegin()) );
+
+                // Update true positives / false negatives
+                if (i->second > threshold) result.tp++;
+                else                       result.fn++;
+                
+            } else {
+                t.push_back( *(t.rbegin()) );
+                f.push_back( *(f.rbegin()) + 1 );
+
+                // Update false positives / true negatives
+                if (i->second > threshold) result.fp++;
+                else                       result.tn++;
+            }
+
+        }
+
+        vector<double> tpl; tpl.reserve(candidates.size()+1);
+        // vector<double> fpl = tpl;
+        size_t last_f = 0;
+        for (size_t i = 0; i < t.size(); ++i) {
+            if (f[i] > last_f) {
+                tpl.push_back(t[i]);
+                // fpl.push_back(f[i]);
+                last_f = f[i];
+            }
+        }
+
+        size_t last_t = *(t.rbegin());
+        double sum = 0.0;
+        // Divide each by the last item in that array
+        // Also keep track of the sum for calculating the final AUC value
+        for (size_t i = 0; i < tpl.size(); ++i) {
+            // tpl[i] /= (double)(last_t);
+            // fpl[i] /= (double)(last_f);
+            sum += tpl[i];
+        }
+
+        result.auc = (sum / (double)(last_t)) / (double)(tpl.size());
+        if (tpl.size() == 0) result.auc = 0; // prevent NaN return.
+
+        return result;
+    }
+
+
+    // Assume we're in the correct directory and read the correct phenotype file
+    // First two lines are comment.
+    // Assumes the files are pre-sorted by sortall.pl (by column 2 descending).
+    // column 1 is the gene, column 2 is the prediction score (higher is better).
+    gene_score_list read_candidates(uint j) const {
+        ostringstream fn; fn << j;
+        boost::filesystem::path filepath(fn.str());
+        //cerr << "Opening file: '" << filepath << "'" << endl;
+
+        if (!exists(filepath)) {
+            //cerr << "Error: File '" << filepath << "' does not exist." << endl;
+            throw;
+        }
+
+        gene_score_list res;
+
+        // Open a filestream
+        ifstream fin(filepath);
+
+        // Ignore two header lines
+        fin.ignore(500, '\n');
+        fin.ignore(500, '\n');
+        //cout << "Next character is: '" << fin.peek() << "'" << endl;
+
+        // Iterate through the gene-score pairs in the file
+        for (gene_score_iterator gsit(fin); gsit != gene_score_iterator(); ++gsit) {
+            //cerr << "Adding " << gsit->first << '\t' << gsit->second << endl;
+            res.push_back(*gsit);
+        }
+
+        fin.close();
+
+        return res;
+    }
+    
+    
+protected:
+
+    uint matrix_id;
+    uint experiment_id;
+    uint current_j;
+    pqxx::connection c;
+    pqxx::transaction<>* action;
+
+    double mean_auc_;
+
+    Fetcher fetcher;
+    Updater updater;
+};

data/ext/rocker/updater.h

@@ -0,0 +1,86 @@
+#include "auc_info.h"
+
+#include <iostream>
+#include <set>
+#include <vector>
+#include <string>
+#include <list>
+#include <map>
+#include <sstream>
+#include <pqxx/transactor.hxx>
+#include <pqxx/result.hxx>
+#include <boost/algorithm/string/join.hpp>
+
+using std::cout;
+using std::cerr;
+using std::endl;
+using std::set;
+using std::vector;
+using std::string;
+using std::list;
+using std::map;
+using std::ostringstream;
+using pqxx::transactor;
+using pqxx::result;
+using boost::algorithm::join;
+
+typedef unsigned int  uint;
+
+
+//std::string join(const SequenceT<std::string>& strings, std::string join_str = "") {
+//    std::ostringstream o;
+//
+//    SequenceT<string>::const_iterator i = strings.begin();
+//    o << *i;
+//    ++i;
+//
+//    for (; i != strings.end(); ++i) {
+//        o << join_str << *i;
+//    }
+//
+//    return o.str();
+//}
+
+
+
+class Updater : public transactor <> {
+public:
+    Updater() : transactor<>("Updater") {}
+
+    uint experiment_id;
+    map<uint,auc_info> aucs;
+    string query;
+
+    void operator()(argument_type &T) {
+        result R;
+
+        if (aucs.size() == 0) {
+            cerr << "No updates necessary." << endl;
+            return;
+        }
+
+        query = make_known_correct_query().c_str();
+
+        try {
+            //R = T.exec(query);
+            cout << "Query:" << endl;
+            cout << query << endl;
+        } catch (pqxx::sql_error e) {
+            cerr << "SQL error in Fetcher transactor." << endl;
+            cerr << "Query: " << e.query() << endl;
+            cerr << "Error: " << e.what()  << endl;
+        }
+    }
+
+protected:
+    string make_known_correct_query() const {
+        ostringstream q;
+        q << "INSERT INTO rocs " << AUC_COLUMNS << " VALUES \n";
+        list<string> insertions;
+        for (map<uint,auc_info>::const_iterator i = aucs.begin(); i != aucs.end(); ++i) {
+            insertions.push_back( i->second.entry(experiment_id, i->first) );
+        }
+        q << join(insertions, ",\n") << ';';
+        return q.str();
+    }
+};

data/lib/rocker.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'ext/rocker/rocker.so'
+
+class Rocker
+  VERSION = '0.0.4'
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rocker.rb'}"
+puts "Loading rocker gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/rocker'

data/test/test_rocker.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestRocker < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+end

data/test/test_rocker_extn.rb

@@ -0,0 +1,21 @@
+require "test/unit"
+
+$:.unshift File.dirname(__FILE__) + "/../ext/rocker"
+require "rocker.so"
+
+def database_string dbn = "crossval_development", u = "jwoods", p = "youwish1"
+  "dbname=#{dbn} user=#{u} password=#{p}"
+end
+
+class TestRockerExtn < Test::Unit::TestCase
+  def test_working
+    t = Rocker.new(database_string, 1, 167)
+    x = t.mean_auc
+    puts "Mean AUC was #{x}"
+  end
+
+  def test_version_string
+    puts Rocker::VERSION
+  end
+
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: rocker
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- John Woods
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-23 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rubyforge
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 4
+        version: 2.0.4
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id002
+description: |-
+  This gem is very fast C++ code for calculating AUCs on results of cross-validation.
+  
+  It is specific to the crossval database schema, which has not been released yet.
+  
+  Chances are you will not find this very useful unless you are the author.
+  
+  It is in gem form to ensure that each lab machine can compile its own arch-specific
+  version.
+email: 
+- john.woods@marcottelab.org
+executables: []
+
+extensions: 
+- ext/rocker/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/rocker.rb
+- script/console
+- script/destroy
+- script/generate
+- test/test_helper.rb
+- test/test_rocker.rb
+- ext/rocker/extconf.rb
+- ext/rocker/auc_info.h
+- ext/rocker/constants.h
+- ext/rocker/fetcher.h
+- ext/rocker/updater.h
+- ext/rocker/line_input_iterator.h
+- ext/rocker/rocker.h
+- ext/rocker/rocker.cpp
+has_rdoc: true
+homepage: http://github.com/MarcotteLabGit/rocker
+licenses: []
+
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+- ext/rocker
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rocker
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: This gem is very fast C++ code for calculating AUCs on results of cross-validation
+test_files: 
+- test/test_helper.rb
+- test/test_rocker.rb
+- test/test_rocker_extn.rb