rbbt-dm 0.0.1 → 0.0.2

data/lib/rbbt/network/paths.rb

@@ -0,0 +1,136 @@
+require 'priority_queue'
+module Paths
+
+  def self.dijkstra(adjacency, start_node, end_node = 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
+    best = 1.0 / 0.0
+    until active.empty?
+      u, distance = active.delete_min
+      distances[u] = distance
+      d = distance + 1
+      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))
+      end    
+    end
+
+
+    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
+    else
+      parents
+    end
+  end
+
+  def self.weighted_dijkstra(adjacency, start_node, end_node = 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
+    best = 1.0 / 0.0
+    until active.empty?
+      u, distance = active.delete_min
+      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
+        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))
+      end    
+    end
+
+    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
+    else
+      parents
+    end
+  end
+
+  def self.random_weighted_dijkstra(adjacency, l, start_node, end_node = 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
+    best = 1.0 / 0.0
+    until active.empty?
+      u, distance = active.delete_min
+      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
+        parents[v] = u
+        best = d if (String === end_node ? end_node == v : end_node.include?(v))
+      end    
+    end
+
+    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
+    else
+      parents
+    end
+  end
+end
+
+module Entity
+  module Adjacent
+    def path_to(adjacency, entities)
+      if Array === self
+        self.collect{|gene| gene.path_to(adjacency, entities)}
+      else
+        if adjacency.type == :flat
+          Paths.dijkstra(adjacency, self, entities)
+        else
+          Paths.weighted_dijkstra(adjacency, self, entities)
+        end
+      end
+    end
+
+    def random_paths_to(adjacency, l, times, entities)
+      if Array === self
+        self.inject([]){|acc,gene| acc += gene.random_paths_to(adjacency, l, times, entities)}
+      else
+        paths = []
+        times.times do 
+          paths << Paths.random_weighted_dijkstra(adjacency, l, self, entities)
+        end
+        paths
+      end
+    end
+  end
+end

data/lib/rbbt/statistics/hypergeometric.rb

@@ -1,5 +1,8 @@
 require 'inline'
-require 'rbbt/util/tsv'
+require 'rbbt/tsv'
+require 'rbbt/persist'
+require 'rbbt/statistics/fdr'
+require 'rbbt/entity'
 
 module Hypergeometric
   class << self
@@ -88,49 +91,47 @@ double hypergeometric(double total, double support, double list, double found)
   end
 end
 
-class TSV
+module TSV
 
-  def annotation_counts(fields = nil)
+  def annotation_counts(fields = nil, persistence = false)
     fields ||= self.fields
     fields = [fields] if String === fields or Symbol === fields
 
-    annotation_count_cache_file = TSV.get_persistence_file(File.basename(filename) + "_" + fields.inspect, File.expand_path(File.dirname(filename)))
-
-    if File.exists?(annotation_count_cache_file)
-      Log.low "Loading annotation counts from #{ annotation_count_cache_file }"
-      TCHash.get(annotation_count_cache_file)
-    else
-      Log.low "Saving annotation counts to #{ annotation_count_cache_file }"
-      hash = TCHash.get(annotation_count_cache_file)
-
-      counts = Hash.new(0)
-      through :main, fields do |key, values|
-        values.flatten.compact.uniq.each{|value| counts[value] += 1}
+    Persist.persist(filename, :marshal, :fields => fields, :persist => persistence, :prefix => "Hyp.Geo.Counts") do 
+      data ||= Hash.new(0)
+      through :key, fields do |key, values|
+        values.flatten.compact.uniq.each{|value| data[value] += 1}
       end
-      hash.merge! counts
+
+      data
     end
   end
 
-  def enrichment(list, fields, options = {})
-    options = Misc.add_defaults options, :min_support => 3
+  def enrichment(list, fields = nil, options = {})
+    fields ||= self.fields.first
+    options = Misc.add_defaults options, :min_support => 3, :fdr => true, :cutoff => false
     Log.debug "Enrichment analysis of field #{fields.inspect} for #{list.length} entities"
-    selected = select :main => list
-    
+
+    selected = select :key => list
+
     tsv_size = keys.length
     total = selected.keys.length
     Log.debug "Found #{total} of #{list.length} entities"
 
-    counts = annotation_counts fields
+    counts = annotation_counts fields, options[:persist]
 
     annotations = Hash.new 0
-    selected.through :main, fields do |key, values|
-      values.flatten.compact.uniq.each{|value| annotations[value] += 1}
+    with_unnamed do
+      selected.through :key, fields do |key, values|
+        values.flatten.compact.uniq.reject{|value| value.empty?}.each{|value| 
+          annotations[value] += 1
+        }
+      end
     end
 
     pvalues = {}
     annotations.each do |annotation, count|
-      Log.debug "Hypergeometric: #{ annotation } - #{[tsv_size, counts[annotation], total, count].inspect}"
-      next if count < options[:min_support]
+      next if count < options[:min_support] or not counts.include? annotation
       pvalue = Hypergeometric.hypergeometric(tsv_size, counts[annotation], total, count)
       pvalues[annotation] = pvalue
     end
@@ -138,9 +139,30 @@ class TSV
     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)
+
     pvalues
   end
+
+  def enrichment_for(tsv, field, options = {} )
+    tsv = tsv.tsv if Path === tsv
+    index = TSV.find_traversal(self, tsv, :in_namespace => false, :persist_input => true)
+
+    raise "Cannot traverse identifiers" if index.nil?
+
+    source_keys = index.values_at(*self.keys).flatten.compact.uniq
+
+    tsv.enrichment source_keys, field, options
+  end
 end
 
+module Entity
+  module Enriched
+    def enrichment(file, fields = nil, options = {})
+      file = file.tsv if Path === file
+      file.enrichment self, fields, options
+    end
+  end
+end
 
 

data/lib/rbbt/statistics/random_walk.rb

@@ -0,0 +1,158 @@
+require 'png'
+require 'inline'
+
+module RandomWalk
+
+  class << self
+      inline do |builder|
+
+        builder.c_raw <<-'EOC'
+    double weight(int position, int mean){
+        double rel_pos = (double) abs(position - mean) / mean; 
+        double weight =  0.3 *  0.5 * rel_pos +  0.7 * (exp(30*rel_pos)/exp(30));
+        return(weight);
+    }
+        EOC
+
+        builder.c <<-'EOC'
+    double fast_score_scale(VALUE positions, int total, int missing){
+      int idx;
+    
+      int mean = total / 2;
+
+      VALUE rel_q = rb_ary_new();
+      VALUE rel_l = rb_ary_new();
+      
+      rb_ary_push(rel_q,rb_float_new(0));
+
+      // Rescale positions and accumulate weights
+      double total_weights = 0;
+      for (idx = 0; idx < RARRAY(positions)->len; idx++){
+        int position = FIX2INT(rb_ary_entry(positions, idx));
+
+        rb_ary_push(rel_l, rb_float_new((double) position / total));
+
+        total_weights += weight(position, mean);
+        rb_ary_push(rel_q, rb_float_new(total_weights));
+      }
+
+      // Add penalty for missing genes
+      double penalty = missing * weight(mean * 0.8, mean);
+      total_weights  = total_weights + penalty;
+      
+      // Traverse list and get extreme values
+      double max_top, max_bottom;
+      max_top = max_bottom = 0;
+      for (idx = 0; idx < RARRAY(positions)->len; idx++){
+        double top    = RFLOAT(rb_ary_entry(rel_q, idx + 1))->value / total_weights -
+                        RFLOAT(rb_ary_entry(rel_l, idx))->value;
+        double bottom = - (penalty + RFLOAT(rb_ary_entry(rel_q, idx))->value) / total_weights +
+                        RFLOAT(rb_ary_entry(rel_l, idx))->value;
+
+        if (top > max_top)       max_top    = top;
+        if (bottom > max_bottom) max_bottom = bottom;
+      }
+        
+     if (max_top > max_bottom) return max_top;
+     else                      return -max_bottom;
+    }
+        EOC
+
+      end
+  end
+
+  class << self
+    alias score fast_score_scale
+  end
+
+  def self.combine(up, down)
+    return down if up == 0
+    return up if down == 0
+
+    return up - down
+    if (up > 0) == (down > 0)
+      return 0
+    else
+      up - down
+    end
+  end
+
+  def self.score_up_down(up, down, total, missing = 0)
+    scores_up   = score(up, total, missing)
+    scores_down = score(down, total, missing)
+
+    combine(scores_up, scores_down)
+  end
+
+  # Two sided
+  def self.permutations(size, total, missing = 0, times = 10000)
+    if size == 0
+      [0] * times
+    else
+      (1..times).collect do
+        score(Array.new(size){ (rand * total).to_i }.sort, total, missing).abs
+      end
+    end
+  end
+
+  def self.permutations_up_down(size_up, size_down, total, missing = 0, times = 10000)
+    (1..times).collect do
+      score_up_down(Array.new(size_up){ (rand * total).to_i }.sort, Array.new(size_down){ (rand * total).to_i }.sort, total, missing).abs
+    end
+  end
+
+  def self.pvalue(permutations, score)
+    score = score.abs
+    permutations.inject(0){|acc, per| 
+      acc += 1 if per > score
+      acc
+    }.to_f / permutations.length
+  end
+
+  COLORS = {
+    :red =>   PNG::Color::Red,
+    :green => PNG::Color::Green,
+    :white => PNG::Color::White,
+    :black => PNG::Color::Black,
+
+  }
+
+  def self.draw_hits(hits, total, filename = nil, options = {})
+
+    size = options[:size] || total
+    bg_color = options[:bg_color] || :white
+    width = options[:width] || 20
+    sections = options[:sections] || []
+
+    size = [size, total].min
+
+    hits = hits.collect{|h| h - 1}
+    if size < total
+      hits = hits.collect{|h| (h.to_f * size / total).to_i}
+    end
+
+    canvas = PNG::Canvas.new size, width, COLORS[bg_color]
+
+    sections.each{|color, info|
+      start = info[0]
+      finish = info[1]
+      (start..finish).each{|x|
+        (0..width - 1).each{|y|
+          canvas[x,y] = COLORS[color]
+        }
+      }
+    }
+
+    hits.each{|hit|
+      canvas.line hit, 0, hit , width - 1, PNG::Color::Black
+    }
+
+    png = PNG.new canvas
+
+    if filename
+      png.save filename
+    else
+      png.to_blob
+    end
+  end
+end

data/lib/rbbt/vector/model/svm.rb

@@ -0,0 +1,20 @@
+require 'rbbt/vector/model'
+class SVMModel < VectorModel
+  def initialize(dir)
+    super(dir)
+
+    @extract_features = Proc.new{|element|
+      element
+    }
+
+    @train_model =<<-EOF
+library(e1071);
+model = svm(class ~ ., data = features);
+    EOF
+ 
+    @eval_model =<<-EOF
+library(e1071);
+label = predict(model, features);
+    EOF
+  end
+end

data/lib/rbbt/vector/model.rb

@@ -0,0 +1,122 @@
+require 'rbbt/util/R'
+
+class VectorModel
+  attr_accessor :directory, :model_file, :extract_features, :train_model, :eval_model
+  attr_accessor :features, :labels
+
+  def self.R_train(model_file, features, labels, code)
+    TmpFile.with_file do |feature_file|
+      Open.write(feature_file, features.collect{|feats| feats * "\t"} * "\n")
+      Open.write(feature_file + '.class', labels * "\n")
+
+      R.run <<-EOF
+features = read.table("#{ feature_file }", sep ="\\t", stringsAsFactors=FALSE);
+labels = scan("#{ feature_file }.class");
+features = cbind(features, class = labels);
+#{code}
+save(model, file='#{model_file}')
+      EOF
+    end
+  end
+
+  def self.R_eval(model_file, features, list, code)
+    TmpFile.with_file do |feature_file|
+      TmpFile.with_file do |results|
+        if list
+          Open.write(feature_file, features.collect{|feat| feat * "\t"} * "\n" + "\n")
+        else
+          Open.write(feature_file, features * "\t" + "\n")
+        end
+
+        io = R.run <<-EOF
+features = read.table("#{ feature_file }", sep ="\\t", stringsAsFactors=FALSE);
+load(file="#{model_file}");
+#{code}
+cat(paste(label, sep="\\n"));
+        EOF
+
+        res = io.read.sub(/WARNING: .*?\n/s,'').split(/\s+/).collect{|l| l.to_f}
+
+        if list
+          res
+        else
+          res.first
+        end
+      end
+    end
+  end
+
+  def initialize(directory, extract_features = nil, train_model = nil, eval_model = nil)
+    @directory = directory
+    FileUtils.mkdir_p @directory unless File.exists? @directory
+    @model_file = File.join(@directory, "model")
+    extract_features = @extract_features 
+    train_model = @train_model 
+    eval_model = @eval_model
+    @features = []
+    @labels = []
+  end
+
+  def add(element, label = nil)
+    @features << extract_features.call(element)
+    @labels << label unless label.nil?
+  end
+
+  def train
+    case 
+    when Proc === train_model
+      train_model.call(@model_file, @features, @labels)
+    when String === train_model
+      SVMModel.R_train(@model_file,  @features, @labels, train_model)
+    end
+  end
+
+  def eval(element)
+    case 
+    when Proc === eval_model
+      eval_model.call(@model_file, extract_features.call(element), false)
+    when String === eval_model
+      SVMModel.R_eval(@model_file,  extract_features.call(element), false, eval_model)
+    end
+  end
+
+  def eval_list(elements, extract = true)
+    case 
+    when Proc === eval_model
+      eval_model.call(@model_file, extract ? elements.collect{|element| extract_features.call(element)} : elements, true)
+    when String === eval_model
+      SVMModel.R_eval(@model_file, extract ? elements.collect{|element| extract_features.call(element)} : elements, true, eval_model)
+    end
+  end
+
+  def cross_validation(folds = 10)
+    saved_features = @features
+    saved_labels = @labels
+    seq = (0..features.length - 1).to_a
+
+    chunk_size = features.length / folds
+
+    acc = []
+    folds.times do
+      seq = seq.shuffle
+      eval_chunk = seq[0..chunk_size]
+      train_chunk = seq[chunk_size.. -1]
+
+      eval_features = @features.values_at *eval_chunk
+      eval_labels = @labels.values_at *eval_chunk
+
+      @features = @features.values_at *train_chunk
+      @labels = @labels.values_at *train_chunk
+
+      train
+      predictions = eval_list eval_features, false
+
+      acc << predictions.zip(eval_labels).collect{|pred,lab| pred - lab < 0.5 ? 1 : 0}.inject(0){|acc,e| acc +=e} / chunk_size
+
+      @features = saved_features
+      @labels = saved_labels
+    end
+
+    acc
+  end
+end

data/test/rbbt/network/test_paths.rb

@@ -0,0 +1,68 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'rbbt/network/paths'
+require 'test/unit'
+require 'rbbt/sources/string'
+require 'set'
+
+
+class TestNetwork < Test::Unit::TestCase
+  def test_dijsktra
+    string = STRING.protein_protein.tsv :persist => false, :fields => ["Interactor Ensembl Protein ID"], :type => :flat 
+    string.unnamed = true
+
+    start_node = "ENSP00000256078"
+    end_node = "ENSP00000306245"
+
+    path = Paths.dijkstra(string, start_node, [end_node])
+
+    assert path != nil
+    assert path.include? start_node
+    assert path.include? end_node
+  end
+
+  def test_weighted_dijsktra
+    string = STRING.protein_protein.tsv 
+
+    string.process "Score" do |scores|
+      scores.collect{|score| 1000 - score.to_i}
+    end
+    string.unnamed = true
+
+    start_node = "ENSP00000256078"
+    end_node = "ENSP00000306245"
+
+    path = Paths.weighted_dijkstra(string, start_node, end_node)
+
+    assert path != nil
+    assert path.include? start_node
+    assert path.include? end_node
+    
+    path = Paths.weighted_dijkstra(string, start_node, Set.new([end_node]))
+
+    assert path != nil
+    assert path.include? start_node
+    assert path.include? end_node
+ 
+  end
+
+  def test_random_weighted_dijsktra
+    string = STRING.protein_protein.tsv 
+
+    string.process "Score" do |scores|
+      scores.collect{|score| 1000 - score.to_i}
+    end
+    string.unnamed = true
+
+    start_node = "ENSP00000256078"
+    end_node = "ENSP00000306245"
+
+    path = Paths.random_weighted_dijkstra(string, 0.8, start_node, end_node)
+
+    assert path != nil
+    assert path.include? start_node
+    assert path.include? end_node
+  end
+
+end
+
+

data/test/rbbt/statistics/test_hypergeometric.rb

@@ -17,7 +17,7 @@ row3    a    C    Id4
     EOF
     
     TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(filename + '#:sep=/\s+/')
+      tsv = TSV.open(filename, :sep => /\s+/)
       counts = tsv.annotation_counts
       assert_equal 2, counts['a']
     end
@@ -36,10 +36,9 @@ row7    A    B    Id3
     EOF
     
     TmpFile.with_file(content) do |filename|
-      tsv = TSV.new(filename + '#:sep=/\s+/')
+      tsv = TSV.open(filename, :sep => /\s+/)
 
-      assert_equal %w(a), tsv.enrichment(%w(row1 row3 row4 row5), "ValueA").collect{|annot,pvalue| pvalue < 0.05 ? annot : nil}.compact
-      assert_equal %w(aa aaa), tsv.enrichment(%w(row1 row3 row4 row5), "ValueA").collect{|annot,pvalue| pvalue > 0.05 ? annot : nil}.compact
+      assert_equal %w(a), tsv.enrichment(%w(row1 row3 row4 row5), "ValueA", :fdr => false).collect{|annot,pvalue| pvalue < 0.05 ? annot : nil}.compact
     end
   end
 end

data/test/rbbt/vector/model/test_svm.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../../test_helper')
+require 'rbbt/vector/model/svm'
+require 'rbbt/util/R'
+require 'test/unit'
+
+class TestSVMModel < Test::Unit::TestCase
+
+  def test_model
+    text =<<-EOF
+1 0;1;1
+1 1;0;1
+1 1;1;1
+1 0;1;1
+1 1;1;1
+0 0;1;0
+0 1;0;0
+0 0;1;0
+0 1;0;0
+    EOF
+
+    TmpFile.with_file() do |dir|
+      FileUtils.mkdir_p dir
+      model = SVMModel.new(dir)
+
+      model.extract_features = Proc.new{|element|
+        element.split(";")
+      }
+
+      text.split(/\n/).each do |line|
+        label, features = line.split(" ")
+        model.add(features, label)
+      end
+
+      model.train
+
+      assert model.eval("1;1;1") > 0.5
+      assert model.eval("0;0;0") < 0.5
+
+      assert_equal [true, false], model.eval_list(%w(1;1;1 0;0;0)).collect{|v| v > 0.5}
+    end
+  end
+
+end

data/test/rbbt/vector/test_model.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+require 'rbbt/vector/model'
+require 'rbbt/util/R'
+require 'test/unit'
+
+class TestVectorModel < Test::Unit::TestCase
+
+  def test_model
+    text =<<-EOF
+1 0;1;1
+1 1;0;1
+1 1;1;1
+1 0;1;1
+1 1;1;1
+0 0;1;0
+0 1;0;0
+0 0;1;0
+0 1;0;0
+    EOF
+
+    TmpFile.with_file() do |dir|
+      FileUtils.mkdir_p dir
+      model = VectorModel.new(dir)
+
+      model.extract_features = Proc.new{|element|
+        element.split(";")
+      }
+
+      model.train_model = Proc.new{|model_file,features,labels|
+        TmpFile.with_file do |feature_file|
+          Open.write(feature_file, features.collect{|feats| feats * "\t"} * "\n")
+          Open.write(feature_file + '.class', labels * "\n")
+          R.run <<-EOF
+features = read.table("#{ feature_file }", sep ="\\t", stringsAsFactors=FALSE);
+labels = scan("#{ feature_file }.class", what=numeric());
+features = cbind(features, class = labels);
+library(e1071)
+model = svm(class ~ ., data = features) 
+save(model, file="#{ model_file }");
+          EOF
+        end
+      }
+
+      model.eval_model = Proc.new{|model_file,features|
+        TmpFile.with_file do |feature_file|
+          TmpFile.with_file do |results|
+            Open.write(feature_file, features * "\t")
+            puts R.run(<<-EOF
+features = read.table("#{ feature_file }", sep ="\\t", stringsAsFactors=FALSE);
+library(e1071)
+load(file="#{ model_file }")
+label = predict(model, features);
+cat(label, file="#{results}");
+            EOF
+            ).read
+            Open.read(results)
+          end
+        end
+
+      }
+
+      text.split(/\n/).each do |line|
+        label, features = line.split(" ")
+        model.add(features, label)
+      end
+
+      model.train
+
+      assert model.eval("1;1;1").to_f > 0.5
+      assert model.eval("0;0;0").to_f < 0.5
+    end
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rbbt-dm
 version: !ruby/object:Gem::Version 
-  hash: 29
-  prerelease: false
+  hash: 27
+  prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Miguel Vazquez
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-20 00:00:00 +01:00
+date: 2011-10-04 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,34 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rbbt-entities
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: RubyInline
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
 description: Data-mining and statistics
 email: miguel.vazquez@fdi.ucm.es
 executables: []
@@ -42,10 +70,17 @@ extra_rdoc_files:
 - LICENSE
 files: 
 - LICENSE
+- lib/rbbt/network/paths.rb
 - lib/rbbt/statistics/fdr.rb
 - lib/rbbt/statistics/hypergeometric.rb
+- lib/rbbt/statistics/random_walk.rb
+- lib/rbbt/vector/model.rb
+- lib/rbbt/vector/model/svm.rb
 - test/rbbt/statistics/test_fdr.rb
 - test/rbbt/statistics/test_hypergeometric.rb
+- test/rbbt/vector/test_model.rb
+- test/rbbt/vector/model/test_svm.rb
+- test/rbbt/network/test_paths.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/mikisvaz/rbbt-phgx
@@ -77,11 +112,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Data-mining and statistics
 test_files: 
 - test/rbbt/statistics/test_fdr.rb
 - test/rbbt/statistics/test_hypergeometric.rb
+- test/rbbt/vector/test_model.rb
+- test/rbbt/vector/model/test_svm.rb
+- test/rbbt/network/test_paths.rb
 - test/test_helper.rb