rbbt-dm 0.0.4 → 1.0.0

data/lib/rbbt/network/paths.rb

@@ -1,71 +1,87 @@
 require 'priority_queue'
+
 module Paths
 
-  def self.dijkstra(adjacency, start_node, end_node = nil)
+  def self.dijkstra(adjacency, start_node, end_node = nil, max_steps = nil)
     return nil unless adjacency.include? start_node
 
     active = PriorityQueue.new         
     distances = Hash.new { 1.0 / 0.0 } 
     parents = Hash.new                 
 
-    active[start_node] = 0
+    active[start_node] << 0
     best = 1.0 / 0.0
     until active.empty?
-      u, distance = active.delete_min
+      u = active.priorities.first
+      distance = active.shift
       distances[u] = distance
       d = distance + 1
+      path = extract_path(parents, start_node, u)
+      next if path.length > max_steps if max_steps 
       adjacency[u].each do |v|
         next unless d < distances[v] and d < best # we can't relax this one
-        active[v] = distances[v] = d
-        parents[v] = u
         best = d if (String === end_node ? end_node == v : end_node.include?(v))
+        active[v] << d if adjacency.include? v
+        distances[v] = d
+        parents[v] = u
       end    
     end
 
 
     if end_node
-      end_node = (end_node & parents.keys).first unless String === end_node
+      end_node = end_node.select{|n| parents.keys.include? n}.first unless String === end_node
       return nil if not parents.include? end_node
-      path = [end_node]
-      while not path.last === start_node
-        path << parents[path.last]
-      end
-      path
+      extract_path(parents, start_node, u)
     else
       parents
     end
   end
 
-  def self.weighted_dijkstra(adjacency, start_node, end_node = nil)
+  def self.extract_path(parents, start_node, end_node)
+    path = [end_node]
+    while not path.last === start_node
+      path << parents[path.last]
+    end
+    path
+  end
+
+  def self.weighted_dijkstra(adjacency, start_node, end_node = nil, threshold = nil, max_steps = nil)
     return nil unless adjacency.include? start_node
 
     active = PriorityQueue.new         
     distances = Hash.new { 1.0 / 0.0 } 
     parents = Hash.new                 
 
-    active[start_node] = 0
+    active[start_node] << 0
     best = 1.0 / 0.0
+    found = false
     until active.empty?
-      u, distance = active.delete_min
+      u = active.priorities.first
+      distance = active.shift
       distances[u] = distance
-      next if not adjacency.include?(u) or adjacency[u].nil? or adjacency[u].empty?
+      path = extract_path(parents, start_node, u)
+      next if path.length > max_steps if max_steps 
+      next if not adjacency.include?(u) or adjacency[u].nil? or adjacency[u].empty? 
       Misc.zip_fields(adjacency[u]).each do |v,node_dist|
+        next if threshold and node_dist > threshold
         d = distance + node_dist
         next unless d < distances[v] and d < best # we can't relax this one
-        active[v] = distances[v] = d
+        active[v] << d
+        distances[v] = d
         parents[v] = u
-        best = d if (String === end_node ? end_node == v : end_node.include?(v))
+        if (String === end_node ? end_node == v : end_node.include?(v))
+          best = d 
+          found = true
+        end
       end    
     end
 
+    return nil unless found
+
     if end_node
       end_node = (end_node & parents.keys).first unless String === end_node
       return nil if not parents.include? end_node
-      path = [end_node]
-      while not path.last === start_node
-        path << parents[path.last]
-      end
-      path
+      extract_path(parents, start_node, end_node)
     else
       parents
     end
@@ -78,16 +94,17 @@ module Paths
     distances = Hash.new { 1.0 / 0.0 } 
     parents = Hash.new                 
 
-    active[start_node] = 0
+    active[start_node] << 0
     best = 1.0 / 0.0
     until active.empty?
-      u, distance = active.delete_min
+      u = active.priorities.first
+      distance = active.shift
       distances[u] = distance
       next if not adjacency.include?(u) or adjacency[u].nil? or adjacency[u].empty?
       Misc.zip_fields(adjacency[u]).each do |v,node_dist|
         d = distance + (node_dist * (l + rand))
         next unless d < distances[v] and d < best # we can't relax this one
-        active[v] = distances[v] = d
+        active[v] << distances[v] = d
         parents[v] = u
         best = d if (String === end_node ? end_node == v : end_node.include?(v))
       end    
@@ -109,14 +126,15 @@ end
 
 module Entity
   module Adjacent
-    def path_to(adjacency, entities)
+    def path_to(adjacency, entities, threshold = nil, max_steps = nil)
       if Array === self
-        self.collect{|gene| gene.path_to(adjacency, entities)}
+        self.collect{|gene| gene.path_to(adjacency, entities, threshold, max_steps)}
       else
         if adjacency.type == :flat
-          Paths.dijkstra(adjacency, self, entities)
+          max_steps ||= threshold
+          Paths.dijkstra(adjacency, self, entities, max_steps)
         else
-          Paths.weighted_dijkstra(adjacency, self, entities)
+          Paths.weighted_dijkstra(adjacency, self, entities, threshold, max_steps)
         end
       end
     end

data/lib/rbbt/plots/bar.rb

@@ -0,0 +1,152 @@
+require 'png'
+require 'rbbt/util/misc'
+
+module BarPlot
+
+  COLORS = {
+    :red =>   PNG::Color::Red,
+    :green => PNG::Color::Green,
+    :blue => PNG::Color::Blue,
+    :white => PNG::Color::White,
+    :black => PNG::Color::Black,
+    :gray => PNG::Color::Gray,
+    :yellow => PNG::Color::Yellow,
+  }
+
+  def self.get_color(color)
+    return color if PNG::Color === color
+    return COLORS[color] if COLORS.include? color
+    PNG::Color.from(color)
+  end
+
+  def self.gradient_color(values, options = {})
+    options = Misc.add_defaults options, :start_color => :green, :end_color => :red, :missing_color => :blue
+    start_color, end_color, missing_color = Misc.process_options options, :start_color, :end_color, :missing_color
+
+    start_color = get_color start_color 
+    end_color = get_color end_color
+    
+    max = values.reject{|v| v.nan? || v.infinite?}.max
+    min = values.reject{|v| v.nan? || v.infinite?}.min
+
+    case
+    when (max.nil? or min.nil?)
+      return [missing_color] * values.length 
+    when max == min
+      return [end_color] * values.length 
+    else
+      diff = max - min
+
+      r_start = start_color.r
+      g_start = start_color.g
+      b_start = start_color.b
+
+      r_end = end_color.r
+      g_end = end_color.g
+      b_end = end_color.b
+
+      values.collect{|v|
+        if v.infinite? or v.nan?
+          missing_color
+        else
+          ratio = (255 * (v - min)) / diff
+          r = (r_start.to_f * (1-ratio) + (r_end.to_f * ratio)).to_i
+          b = (b_start.to_f * (1-ratio) + (b_end.to_f * ratio)).to_i
+          g = (g_start.to_f * (1-ratio) + (g_end.to_f * ratio)).to_i
+          PNG::Color.new(r, g, b)
+        end
+      }
+    end
+  end
+
+  def self.draw_hits_on_canvas(hits, total, canvas, color = PNG::Color::Black)
+    width = canvas.width
+    height = canvas.height
+
+    # fix hits
+    hits = hits.collect{|h| h - 1} # make it start at 0
+
+    if width < total
+      hits = hits.collect{|h| (h.to_f * width / total).floor}
+    end
+
+    if Array === color
+      hits.zip(color).each{|hit, color|
+        canvas.line hit, 0, hit , height - 1, get_color(color)
+      }
+    else
+      color = get_color color
+      hits.each{|hit|
+        canvas.line hit, 0, hit , height - 1, color
+      }
+    end
+
+    canvas
+  end
+
+  def self.draw_sections_on_canvas(ranges, total, canvas, color = PNG::Color::Black)
+    width = canvas.width
+    height = canvas.height
+
+    # fix hits
+    ranges = ranges.collect{|r| (r.begin-1..r.end)} # make it start at 0
+
+    if width < total
+      ratio = width.to_f / total
+      ranges = ranges.collect{|range| ((range.begin.to_f*ratio).floor..(range.end.to_f*ratio).floor)} # make it start at 0
+    end
+
+    if Array === color
+      ranges.zip(color).each{|range, color|
+        range.each do |hit|
+          canvas.line hit, 0, hit , height - 1, get_color(color)
+        end
+      }
+    else
+      color = get_color color
+      ranges.each{|range|
+        range.each do |hit|
+          canvas.line hit, 0, hit , height - 1, color
+        end
+      }
+    end
+
+    canvas
+  end
+
+  MAX_WIDTH = 2000
+  def self.get_canvas(options = {})
+    options = Misc.add_defaults options, :width => [options[:total], MAX_WIDTH].min, :height => 20, :background => PNG::Color::White
+    width, height, background, canvas = Misc.process_options options, :width, :height, :background, :canvas
+
+    canvas ||= if options[:update] and options[:filename] and File.exists? options[:filename]
+                 PNG.load_file options[:filename]
+               else
+                 PNG::Canvas.new width, height, get_color(background) 
+               end
+  end
+
+  def self.draw(items, total, options = {})
+    options = options.merge :total => total
+    canvas = get_canvas(options)
+    items = [items] if Range === items
+    return canvas if items.empty? and options[:filename].nil?
+
+    color = options.delete(:color) || PNG::Color::Black
+    if Range === items.first
+      draw_sections_on_canvas(items, total, canvas, color)
+    else
+      draw_hits_on_canvas(items, total, canvas, color)
+    end
+
+    case options[:filename]
+    when :string
+      PNG.new(canvas).to_blob
+    when nil
+      canvas
+    else
+      PNG.new(canvas).save options[:filename]
+    end
+  end
+end
+

data/lib/rbbt/plots/heatmap.rb

@@ -0,0 +1,63 @@
+require 'rbbt/util/R'
+
+module Heatmap
+  def self.heatmap(values, filename, options = {})
+    scale, take_log, add_to_height, colors = Misc.process_options options, 
+      :scale, :take_log, :add_to_height, :colors
+
+    width = 200 + (values.fields.length * 16)
+    height = 200 + (values.length * 16)
+    size = [width, height].max
+    size = [size, 10000].min
+
+    heatmap_script = <<-EOF 
+    #{ take_log ? "data <- log(data)" : ""}
+        my.hclust <- function(d){ hclust(d, method="ward") }; 
+        my.hclust <- function(d){ hclust(d) }; 
+        rbbt.png_plot(
+          '#{filename}', 
+    #{ size }, 
+    #{ (defined?(add_to_height) and not add_to_height.nil?) ? (size + (add_to_height * 16 * [1, (height.to_f / width)].max).to_i) : size }, 
+          'heatmap(as.matrix(data),
+    #{
+    case scale.to_s
+    when "true", 'row'
+      'scale="row",' 
+    when 'column' 
+      'scale="column",' 
+    when "none", ""
+      'scale="none",'
+    end
+    }
+    #{colors.nil? ? "" : "ColSideColors=#{colors},"} 
+          hclustfun=my.hclust, 
+          )',
+          pointsize=12, type='cairo', res=150)
+        data = NULL;
+    EOF
+
+    values.R heatmap_script
+    
+    filename
+  end
+
+  def self.heatmap2(values, filename, options = {})
+    scale, take_log, add_to_height, colors = Misc.process_options options, 
+      :scale, :take_log, :add_to_height, :colors
+
+    width = 200 + (values.fields.length * 16)
+    height = 200 + (values.length * 16)
+    size = [width, height].max
+    size = [size, 20000].min
+
+    heatmap_script = <<-EOF 
+    library(ggplot2);
+
+    EOF
+
+    values.R heatmap_script
+    
+    filename
+  end
+
+end

data/lib/rbbt/statistics/fdr.rb

@@ -31,17 +31,33 @@ module FDR
     adjusted.reverse
   end
 
-  class << self
-    inline do |builder|
-      builder.c <<-EOC
+  inline do |builder|
+
+    builder.prefix  <<-EOC_CODE
+//{{{ Make compatible with 1.9 and 1.8
+#ifndef RUBY_19
+#ifndef RFLOAT_VALUE
+#define RFLOAT_VALUE(v) (RFLOAT(v)->value)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(v) (RARRAY(v)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(v) (RARRAY(v)->len)
+#endif
+#endif
+//}}} Make compatible with 1.9 and 1.8
+    EOC_CODE
+
+    c_code = <<-EOC_CODE
         double step_up_fast(VALUE ps, double rate){
            long idx;
-           int total = RARRAY(ps)->len;
-  
+           int total = RARRAY_LEN(ps);
+
            double last_value = 0;
            for (idx = 0; idx < total; idx++){
-             double p  = (double) RFLOAT(rb_ary_entry(ps, idx))->value;
-             
+             double p  = (double) RFLOAT_VALUE(rb_ary_entry(ps, idx));
+
              if (p > rate * (double) (idx + 1) / (double) total){
                 return last_value;
              }
@@ -51,47 +67,47 @@ module FDR
            return last_value;
         }
 
-      EOC
+    EOC_CODE
+    builder.c_singleton c_code
 
-
-      builder.c <<-EOC
-          
+    c_code = <<-EOC_CODE
          VALUE adjust_fast_self(VALUE ps){
            long idx;
-      
-           int total = RARRAY(ps)->len;
+
+           int total = RARRAY_LEN(ps);
 
            VALUE new = rb_ary_new();
 
            double last = 1;
            for (idx = total - 1; idx >= 0 ; idx-- ){
-             double p  = (double) RFLOAT(rb_ary_entry(ps, idx))->value;
+             double p  = (double) RFLOAT_VALUE(rb_ary_entry(ps, idx));
+
 
-      
              p = p * (double) total / (double) (idx + 1);
              if (p > last) p = last;
              last = p;
 
-             RFLOAT(rb_ary_entry(ps, idx))->value = p;
+             RFLOAT_VALUE(rb_ary_entry(ps, idx)) = p;
            }
 
           return ps;
          }
-      EOC
-         
-      builder.c <<-EOC
+    EOC_CODE
+    builder.c_singleton c_code
+
+    c_code = <<-EOC_CODE
          VALUE adjust_fast(VALUE ps){
            long idx;
-      
-           int total = RARRAY(ps)->len;
+
+           int total = RARRAY_LEN(ps);
 
            VALUE new = rb_ary_new();
 
            double last = 1;
            for (idx = total - 1; idx >= 0 ; idx-- ){
-             double p  = (double) RFLOAT(rb_ary_entry(ps, idx))->value;
+             double p  = (double) RFLOAT_VALUE(rb_ary_entry(ps, idx));
+
 
-      
              p = p * (double) total / (double) (idx + 1);
              if (p > last) p = last;
              last = p;
@@ -101,14 +117,17 @@ module FDR
 
            return new;
          }
-      EOC
-    end
+    EOC_CODE
+    builder.c_singleton c_code
+
+    builder
   end
 
+
   class << self
-    alias_method :adjust, :adjust_fast
-    alias_method :adjust!, :adjust_fast_self
-    alias_method :step_up, :step_up_fast
+    alias :adjust :adjust_fast
+    alias :adjust! :adjust_fast_self
+    alias :step_up :step_up_fast
   end
 
   # This will change the values of the floats in situ
@@ -116,13 +135,22 @@ module FDR
     keys = []
     values = []
 
-    data.collect{|key, value| [key, field.nil? ? value : value[field]] }.sort{|a,b| 
+    if data.respond_to? :unnamed
+      unnamed = data.unnamed 
+      data.unnamed = true
+    end
+
+    data.collect{|key, value| [key, Array === ( v = field.nil? ? value : value[field] ) ? v.first : v] }.sort{|a,b| 
       a[1] <=> b[1]
     }.each{|p|
       keys << p[0]
       values << p[1]
     }
 
+    if data.respond_to? :unnamed
+      data.unnamed = unnamed
+    end
+
     FDR.adjust!(values)
 
     data
@@ -130,3 +158,5 @@ module FDR
 
 end
 
+
+