rbbt-dm 0.0.4 → 1.0.0

data/lib/rbbt/statistics/hypergeometric.rb

@@ -1,13 +1,19 @@
 require 'inline'
+require 'rsruby'
 require 'rbbt/tsv'
 require 'rbbt/persist'
 require 'rbbt/statistics/fdr'
 require 'rbbt/entity'
+require 'distribution'
+require 'distribution/hypergeometric'
 
 module Hypergeometric
-  class << self
-    inline do |builder|
-      builder.c_raw <<-EOC
+  inline do |builder|
+    builder.prefix <<-EOC
+#include <math.h>
+    EOC
+
+    builder.c_raw_singleton <<-EOC
 /**
  * Compute log(k!)
  * @param k The value k.
@@ -15,13 +21,13 @@ module Hypergeometric
  */
 double lFactorial(double k)
 {
-	double r = 0;
-	int i;
-	for(i=2 ; i<=(int)k ; i++)
-	{
-		r = r + (double)(log((double)i));
-	}
-	return r;
+  double r = 0;
+  int i;
+  for(i=2 ; i<=(int)k ; i++)
+  {
+    r = r + (double)(log((double)i));
+  }
+  return r;
 }
 
 
@@ -34,25 +40,25 @@ double lFactorial(double k)
  */
 double lBinom(double n, double k)
 {
-	long i;
-	double r = 0;
-	
-	if(n > n-k){
-		k = n-k;
-	}
-
-	for(i = (long)n ; i> (n-k) ; i--)
-	{
-		r = r + log((double)i);
-	}
-		
-	r = r - lFactorial(k);
-	
-	return r;
+  long i;
+  double r = 0;
+
+  if(n > n-k){
+    k = n-k;
+  }
+
+  for(i = (long)n ; i> (n-k) ; i--)
+  {
+    r = r + log((double)i);
+  }
+
+  r = r - lFactorial(k);
+
+  return r;
 }
-  EOC
-  
-      builder.c <<-EOC
+    EOC
+
+    builder.c_singleton <<-EOC
 /**
 *  * Compute the Hypergeometric accumulated value.
 *  * @param total       => total size
@@ -61,49 +67,93 @@ double lBinom(double n, double k)
 *  * @param found       => support
 *  * @return The result
 *  */
-double hypergeometric(double total, double support, double list, double found)
+        //pvalues[annotation] = Hypergeometric.hypergeometric(tsv_size, counts[annotation], total, count)
+        //["200204", 2141, 15, 125, 3, 1.37320769558675e-188, ["Q05193", "P54762", "Q12923"]]
+double hypergeometric_c(double total, double support, double list, double found)
 {
-	double other = total - support;
+  double other = total - support;
 
-	double top = list;
-	if(support < list){
-		top = support;
-	}
+  double top = list;
+  double log_n_choose_k = lBinom(total,list);
 
-	double log_n_choose_k = lBinom(total,list);
+  double lfoo = lBinom(support,top) + lBinom(other, list-top);
 
-	double lfoo = lBinom(support,top) + lBinom(other, list-top);
-	
-	double sum = 0;
+  double sum = 0;
   int i;
-	for (i = (int)top; i >= found; i-- )
-	{
-		sum = sum + exp(lfoo - log_n_choose_k);
-		if ( i > found)
-		{
-			lfoo = lfoo + log(i / (support - i+1)) +  log( (other - list + i) / (list-i+1)  );
-		}
-	}
-	return sum;
+
+  if(support < list){
+    top = support;
+  }
+
+
+  for (i = (int)top; i >= found; i-- )
+  {
+    sum = sum + exp(lfoo - log_n_choose_k);
+    if ( i > found)
+    {
+      lfoo = lfoo + log(i / (support - i+1)) +  log( (other - list + i) / (list-i+1)  );
+    }
+  }
+  return sum;
 }
-      EOC
-    end
+    EOC
+  end
+
+  def self.hypergeometric(total, support, list, found)
+    RSRuby.instance.phyper(found, support, total - support, list, false).to_f
   end
 end
 
 module TSV
 
-  def annotation_counts(fields = nil, persistence = false)
+  def annotation_counts(fields = nil, persistence = false, options = {})
     fields ||= self.fields
     fields = [fields] if String === fields or Symbol === fields
+    rename = options.delete :rename
 
-    Persist.persist(filename, :yaml, :fields => fields, :persist => persistence, :prefix => "Hyp.Geo.Counts") do 
+    Persist.persist(filename, :yaml, :fields => fields, :persist => persistence, :prefix => "Hyp.Geo.Counts", :other => { :rename => rename }) do 
       data ||= Hash.new(0)
 
       with_unnamed do
-        through :key, fields do |key, values|
-          values.flatten.compact.uniq.each{|value| data[value] += 1}
+
+        case type
+        when :single
+          through :key, fields do |key, value|
+            next if value.nil?
+            data[value] += 1
+          end
+        when :double
+          if rename
+            Log.debug("Computing annotation counts with rename: #{rename.values.flatten.compact.uniq.sort * ", "} ")
+            through :key, fields do |key, values|
+              next if values.nil?
+              values.flatten.collect{|elem| rename.include?(elem)? rename[elem] : elem }.compact.uniq.each{|value| data[value] += 1 }
+            end
+          else
+            through :key, fields do |key, values|
+              values.flatten.compact.uniq.each{|value| data[value] += 1}
+            end
+          end
+        when :list
+          through :key, fields do |key, values|
+            next if values.nil?
+            values.compact.uniq.each{|value| data[value] += 1}
+          end
+        when :flat
+          if rename
+            Log.debug("Computing annotation counts with rename: #{rename.values.flatten.compact.uniq.sort * ", "} ")
+            through :key, fields do |key, values|
+              next if values.nil?
+              values.collect{|elem| rename.include?(elem)? rename[elem] : elem }.compact.uniq.each{|value| data[value] += 1 }
+            end
+          else
+            through :key, fields do |key, values|
+              next if values.nil?
+              values.compact.uniq.each{|value| data[value] += 1}
+            end
+          end
         end
+
       end
 
       data
@@ -111,51 +161,106 @@ module TSV
   end
 
   def enrichment(list, fields = nil, options = {})
+    options = Misc.add_defaults options, :skip_missing => true, :background => nil
+    background, skip_missing = Misc.process_options options, :background, :skip_missing
+
+    if Array === background and not background.empty?
+      filter
+      add_filter(:key, background)
+      if defined? AnnotatedArray and AnnotatedArray === list
+        list = list.subset background
+      else
+        list = list & background
+      end
+    end
+
+    list = list.compact.uniq
+
     with_unnamed do
       fields ||= self.fields.first
       options = Misc.add_defaults options, :min_support => 3, :fdr => true, :cutoff => false, :add_keys => true
 
-      add_keys = Misc.process_options options, :add_keys
+      add_keys, rename = Misc.process_options options, :add_keys, :rename
 
       Log.debug "Enrichment analysis of field #{fields.inspect} for #{list.length} entities"
 
-      selected = select :key => list
+      selected = select :key => list.uniq
 
       tsv_size = keys.length
-      total = selected.keys.length
-      Log.debug "Found #{total} of #{list.length} entities"
+      found = selected.keys.length
+      Log.debug "Found #{found} of #{list.length} entities"
 
-      counts = annotation_counts fields, options[:persist]
+      if skip_missing
+        total = found
+        Log.debug "Using #{ found } as sample size; skipping missing"
+      else
+        total = list.uniq.length
+        Log.debug "Using #{ list.length } as sample size"
+      end
+
+      counts = annotation_counts fields, options[:persist], :rename => rename
 
-      annotations = Hash.new 
       annotation_keys = Hash.new
       selected.with_unnamed do
-        selected.through :key, fields do |key, values|
-          values.flatten.compact.uniq.reject{|value| value.empty?}.each{|value| 
+
+        case type
+        when :single
+          selected.through :key, fields do |key, value|
             value = value.dup
-            annotations[value] ||= 0
-            annotations[value] += 1
-            next unless add_keys
             annotation_keys[value] ||= []
             annotation_keys[value] << key
-          }
+          end
+
+        when :double
+          selected.through :key, fields do |key, values|
+            values.flatten.compact.uniq.reject{|value| value.empty?}.each{|value| 
+              value = value.dup
+              annotation_keys[value] ||= []
+              annotation_keys[value] << key
+            }
+          end
+
+        when :list
+          selected.through :key, fields do |key, values|
+            values.compact.uniq.reject{|value| value.empty?}.each{|value| 
+              value = value.dup
+              annotation_keys[value] ||= []
+              annotation_keys[value] << key
+            }
+          end
+
+        when :flat
+          selected.through :key, fields do |key, values|
+            values.compact.uniq.reject{|value| value.empty?}.each{|value| 
+              value = value.dup
+              annotation_keys[value] ||= []
+              annotation_keys[value] << key
+            }
+          end
+
         end
+
+      end
+
+      if Array === background and not background.empty?
+        reset_filters
+        pop_filter
       end
 
       pvalues = {}
-      annotations.each do |annotation, count|
+      annotation_keys.each do |annotation, elems|
+        elems = elems.collect{|elem| rename.include?(elem)? rename[elem] : elem }.compact.uniq if rename
+        count = elems.length
         next if count < options[:min_support] or not counts.include? annotation
-        pvalues[annotation] = Hypergeometric.hypergeometric(tsv_size, counts[annotation], total, count)
+        pvalues[annotation] = RSRuby.instance.phyper(count - 1, counts[annotation], tsv_size - counts[annotation], total, false).to_f
       end
 
       FDR.adjust_hash! pvalues if options[:fdr]
 
       pvalues.delete_if{|k, pvalue| pvalue > options[:cutoff] } if options[:cutoff]
 
-      TSV.setup(pvalues, :key_field => fields, :fields => ["p-value"], :cast => :to_f, :type => :single)
-
       if add_keys
-        tsv = TSV.setup(pvalues.keys, :key_field => fields, :fields => [], :type => :double)
+        tsv = TSV.setup(pvalues.keys.collect{|k| k.dup}, :key_field => fields, :fields => [], :type => :double)
 
         tsv.add_field 'p-value' do |annot, values|
           [pvalues[annot]]
@@ -171,7 +276,7 @@ module TSV
 
         tsv
       else
-        pvalues
+        TSV.setup(pvalues, :key_field => fields, :fields => ["p-value"], :cast => :to_f, :type => :single)
       end
 
     end
@@ -198,4 +303,3 @@ module Entity
   end
 end
 
-