rbbt-marq 2.1.2 → 3.0.0

data/lib/MARQ/MADB.rb

@@ -65,91 +65,42 @@ module MADB
   end
 
   # {{{ Loading Positions
+  
+  def self.num_values(dataset)
+    experiments = 
+      DBcache.load(dataset + '_experiments').
+        sort_by {|p| p[0].to_i }.
+        collect {|p| MARQ::Name.clean(dataset) + ": " + p[1].first }
 
-  # Number of probes in the platform
-  def self.platform_entries(platform)
-    DBcache.num_rows(platform + '_codes')
-  end
-
-  # Return the positions of the genes in the signatures derived from the
-  # dataset. Returns a 3 value array: hash of arrays of positions (keys are
-  # signatures), array of the gene ids in the same order as the positions,
-  # and total number of probes in the platform.
-  #
-  def self.load_positions(dataset, genes, platform_entries) 
-    gene_positions = DBcache.load(dataset, genes) 
-
-    matched = gene_positions.keys.sort 
-
-    # Get signature names
-    experiments = DBcache.load(dataset + '_experiments').sort{|a,b| 
-a[0].to_i <=> b[0].to_i
-    }.collect{|p| 
-      MARQ::Name.clean(dataset) + ": " + p[1].first
-    }
-
-    # Get scale factors (to account for genes missing in the dataset)
-    scale = (0..experiments.length - 1).collect{|i| 
-      rows = DBcache.num_rows(dataset, "C#{i}"); 
-      if rows > 0 
-        platform_entries.to_f / rows 
-      else 
-        nil 
-      end 
-    }
-
-    data = {} 
-    # Get experiment positions and scale them
-    experiment_x_gene = gene_positions.values_at(*matched).transpose
-    experiments.each_with_index{|experiment, i|
-      next if scale[i].nil? || experiment_x_gene[i].nil?
-      values = experiment_x_gene[i].collect{|v| v.nil? ? nil : (v.to_f * scale[i]).to_i}
-      data[experiment] = values
-    }
+    values = {}
+    experiments.each_with_index do |exp, i| values[exp] = DBcache.num_rows(dataset, "C#{i}") end
 
-    [data, matched, platform_entries]
+    values
   end
- 
-  # Load positions of genes in signatures from the given datasets. Returns a
-  # tree value array just like load_positions
-  def self.dataset_positions(dataset, genes)
-    return [{},[],0] if genes.empty?
 
-    genes = genes.collect{|gene| gene.to_s.downcase.strip}
-    platform_entries = platform_entries(dataset)
-
-    load_positions(dataset, genes, platform_entries)
+  def self.num_codes(dataset)
+    DBcache.num_rows(dataset + '_codes')
   end
 
+  def self.load_positions(dataset, genes)
+    positions   = DBcache.load(dataset, genes)
+    experiments = 
+      DBcache.load(dataset + '_experiments').
+        sort_by {|p| p[0].to_i }.
+        collect {|p| MARQ::Name.clean(dataset) + ": " + p[1].first }
 
-  # Loads the data from all signatures for datasets of the platform. The return
-  # value is the same as in dataset_positions and load_positins, except that
-  # the matched gene names need not be in the same order as the actual positions
-  # of the signatures, it just the super set of all genes matched on the
-  # signatures
-  def self.platform_positions(platform, genes)
-    return [{},[],0] if genes.empty?
-
-    genes = genes.collect {|gene| gene.downcase.strip }
-    platform_entries = platform_entries(platform)
-
-    cross_platform = MARQ::Platform.is_cross_platform? platform
-    datasets = MARQ::Platform.datasets(platform).sort
 
-    total_data = {}
-    total_matched = []
-
-    datasets.each do |dataset|
-      dataset = MARQ::Name.cross_platform dataset if cross_platform
-      data, matched = load_positions(dataset, genes, platform_entries)
-      total_data = total_data.merge(data)
-      total_matched +=  matched
+    
+    result = {}; experiments.each {|exp| result[exp] = [] }
+    positions.values_at(*genes).each do |values|
+      experiments.zip(values || []).each do |p|
+        experiment, value = p
+        result[experiment] << (value.nil? ? nil : value.to_i)
+      end
     end
-    total_matched.uniq!
 
-    [total_data, total_matched, platform_entries]
+    result
   end
-
 end
 
 if __FILE__ == $0

data/lib/MARQ/annotations.rb

@@ -165,16 +165,13 @@ double hypergeometric(double total, double support, double list, double found)
         positions[term] <<  rank
       }
     }
- 
-    scores = []
-
 
     sizes = {}
     RANK_SIZE_BINS.each{|size| sizes[size.to_i] = []}
 
-
     # For each term compute the rank score. Also, place it in the closest size
     # bin for the permutations.
+    scores = []
     best.each_with_index{|term, pos|
       if positions[term]
         list = positions[term]
@@ -190,40 +187,32 @@ double hypergeometric(double total, double support, double list, double found)
         }
         sizes[sizes.keys.sort.last] << pos if !found
         
-        scores << Score::score(list, ranks.length, 0)[:score]
+        scores << Score.score(list, ranks.length, 0)
       else # it has no score
         scores << nil
       end
     }
 
     info = {}
-
-    # Go through all the size bins, run the permutations and assign the pvalues
-    # to all terms in the bin.
-    sizes.keys.each{|size|
+    sizes.each do |size, pos_list|
       next if size == 1
-      next if sizes[size].empty?
+      next if pos_list.empty?
 
-      # This are the actual scores for the terms in the bin
-      sub_list_scores = sizes[size].collect{|pos| scores[pos] || 0}
+      size_info = {}
+      pos_list.each do |pos|
+        score = scores[pos]
+        term  = best[pos]
+        hits  = positions[term].nil? ? 0 : positions[term].length
 
-      # Compute the pvalues for all the terms in the bin. The size of the
-      # permutation list is that of the bin
-      pvalues = Score::pvalues(sub_list_scores, size, 0, ranks.length)
+        size_info[term] = {:score => score, :hits => hits}
+      end
 
-      # Save the information from the terms, score, hits, and pvalues.
-      sizes[size].zip(pvalues).each{|p|
-        pos = p[0]
-        pvalue = p[1]
-        score = scores[pos]
-        next if score < 0
+      null_scores     = Score.null_scores(size, 0)
+      size_info       = Score.add_pvalues(size_info, null_scores)
 
-        term = best[pos]
-        hits = positions[term].nil? ? 0 : positions[term].length 
+      info.merge! size_info
+    end
 
-        info[term] = {:score => score, :hits => hits, :pvalue => pvalue}
-      }
-    }
 
     info
   end
@@ -349,7 +338,7 @@ double hypergeometric(double total, double support, double list, double found)
     end
 
     if algorithm == :rank
-      ranks = scores.sort{|a,b| compare(a[1],b[1]) }.collect{|p| p[0]}
+      ranks = scores.sort {|a,b| compare(a[1],b[1]) }.collect {|p| p[0]}
       terms = enrichment_rank(annot, ranks, dict_options)
     else
       terms = enrichment_hypergeometric(annot, relevant, dict_options)

data/lib/MARQ/main.rb

@@ -240,119 +240,35 @@ module MARQ
   end
 
   module RankQuery
-    def self.complete_positions(positions, matched, genes)
-      matched = matched.collect{|gene| gene.strip.downcase}
-      genes   = genes.collect{|gene| gene.strip.downcase}
-
-      pos = Hash[*matched.zip(positions).flatten]
-
-      complete = genes.collect{|gene|
-        if matched.include? gene
-          pos[gene] || "MISSING"
-        else
-          "NOT IN PLATFORM"
-        end
-      }
-      complete
-    end
-
-
-    def self.position_scores(up, down, positions_up, positions_down, platform_entries, matched_up, matched_down, missing_up, missing_down)
-      scores = []
-
-      positions_up.keys.each do |experiment|
-        score = Score.score_up_down(positions_up[experiment], positions_down[experiment], platform_entries, missing_up, missing_down)
-        score[:total_entries]    = platform_entries
-        score[:positions_up]     = complete_positions(positions_up[experiment] || [], matched_up, up) if up.any?
-        score[:positions_down]   = complete_positions(positions_down[experiment] || [], matched_down, down) if down.any?
-        scores << score
-      end
-
-      pvalues = Score.pvalues(scores.collect{|s| s[:score]}, up.length, down.length, platform_entries)
-
-      results = {}
-      positions_up.keys.each_with_index{|experiment,i|
-        results[experiment] = scores[i].merge(:pvalue => pvalues[i])
-      }
-
-      results
-    end
+    NULL_SIZE = 10000
 
     def self.dataset_scores(dataset, up, down)
-      positions_up, matched_up, platform_entries     = MADB.dataset_positions(dataset, up)
-      missing_up = positions_up.length - matched_up.length
-
-      positions_down, matched_down                   = MADB.dataset_positions(dataset, down)
-      missing_down = positions_down.length - matched_down.length
-
-      position_scores(up, down, positions_up, positions_down, platform_entries, matched_up, matched_down, missing_up, missing_down)
+      Score.scores_up_down(dataset, up, down)
     end
 
     def self.platform_scores(platform, up, down)
-      positions_up, matched_up, platform_entries     = MADB.platform_positions(platform, up)
-      missing_up = up.length - matched_up.length
-
-
-      positions_down, matched_down                   = MADB.platform_positions(platform, down)
-      missing_down = down.length - matched_down.length
+      scores = {}
+      MARQ::Platform.datasets(platform).each do |dataset|
+        dataset = MARQ::Name.cross_platform dataset if MARQ::Name.is_cross_platform?(platform)
+        scores.merge!(dataset_scores(dataset, up, down))
+      end
 
-      position_scores(up, down, positions_up, positions_down, platform_entries, matched_up, matched_down, missing_up, missing_down)
+      scores
     end
 
     def self.organism_scores(organism, up, down)
-      platforms = MARQ::Platform.organism_platforms(organism).
-        select  {|p| MARQ::Platform.has_cross_platform? p }.
-        collect {|p| MARQ::Name.cross_platform p }
-
-      total_scores = {}
-      platforms.each do |platform|
-        scores = platform_scores(platform, up, down)
-        total_scores.merge!(scores) 
+      scores = {}
+      MARQ::Platform.organism_platforms(organism).each do |platform|
+        scores.merge!(platform_scores(MARQ::Name.cross_platform(platform), up, down))
       end
 
-      total_scores
+      scores
     end
 
-  end
-end
-
-if __FILE__ == $0
-  p MARQ::Dataset.platform 'GDS2791_cross_platform'
-  p MARQ::Platform.organism 'GPL96'
-  exit
-  #puts MARQ::organism_platforms('human')
-  #puts MARQ.platform_organism("HaploidData")
-  #puts MARQ::platform_scores_up_down("HaploidData",%w( YMR261c YDL140c YIL122w YPL093w YHR211w YDL142c YHR106w YOR103c YDR233c YLR181c),%w()).keys
-
-  up = %w(
-
-  51228_at    215046_at   205009_at   204915_s_at 202707_at  
-  208265_at   210618_at   201185_at   206650_at   200719_at  
-  215661_at   202071_at   214408_s_at 215092_s_at 206168_at  
-  212686_at   214162_at   221008_s_at 217709_at   210957_s_at
-
-  )
-
-
-  require 'MARQ/ID'
-  require 'pp'
-  genes = ID.translate('human',up).compact
-
-  #pp up.zip(genes)
-  #genes = Open.read("/home/miki/git/MARQ/test/GDS1375_malignant_vs_normal_down.genes").collect{|l| l.chomp.strip}
-  positions =  MARQ::GEORQ.dataset_positions('GDS1231_cross_platform',genes)
-  pp positions
-
-
-  #MARQ::GEORQ.platform_scores_up_down('GPL96_cross_platform',genes,[]).each{|ex, r|
-  #  puts ex
-  #  puts r[:pvalue]
-  #}
-
-  #Score.draw_hits(positions["disease.state: malignant melanoma <=> normal"], MADB::GEORQ.experiment_entries('GPL96','GDS1375: disease.state: malignant melanoma <=> normal') , '/tmp/foo.png',:size => 1000)
-
-
+    def self.add_pvalues(scores, up_size, down_size)
+      null_scores = Score.null_scores(up_size, down_size, NULL_SIZE)
+      Score.add_pvalues(scores, null_scores)
+    end
 
+  end
 end
-
-

data/lib/MARQ/score.rb

@@ -2,135 +2,10 @@ require 'png'
 require 'inline'
 
 module Score
-  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.average(list)
-    clean = list.compact
-    clean.inject(0){|acc, e| acc += e}.to_f / clean.length
-  end
-
-  def self.score_area(positions, platform_entries, missing = 0)
-    return {:score => 0, :top => 0, :bottom => 0} if positions.nil? || positions.empty? || positions.compact.empty?
-
-    clean_positions = positions.compact.sort
-
-    total_tags      = positions.length + missing
-    extra           = total_tags - clean_positions.length
-
-    top = 0
-    bottom = 0
-
-    clean_positions.each_with_index{|p,i|
-      rel_qt = (i + 1).to_f / total_tags
-      rel_qb = ( i + extra ).to_f / total_tags
-      rel_p  = p.to_f / platform_entries
-
-
-      top    += rel_qt - rel_p if rel_qt > rel_p
-      bottom += rel_p - rel_qb if rel_p > rel_qb
-    }
-
-
-    {
-      :top => top,
-      :bottom => bottom,
-      :score => top > bottom ? top.to_f / total_tags : - bottom.to_f / total_tags, 
-    }
-  end
-
-  def self.score_max_norm(positions, platform_entries, missing = 0)
-    return {:score => 0, :top => 0, :bottom => 0} if positions.nil? || positions.empty? || positions.compact.empty?
-
-    clean_positions = positions.compact.sort
-
-    extra           = missing + (positions.length - clean_positions.length)
-    total_tags      = extra + clean_positions.length
-
-    mean = platform_entries / 2
-
-    values_top = [0]
-    values_bottom = [0]
-
-    clean_positions.each_with_index{|p,i| 
-      rel_qt = (i + 1).to_f / total_tags
-      rel_qb = ( i + extra ).to_f / total_tags
-      rel_p  = p.to_f / platform_entries
-
-
-      values_top << (rel_qt - rel_p) * ((p - mean).abs.to_f / mean)**2
-      values_bottom << (rel_p - rel_qb) * ((p - mean).abs.to_f / mean)**2
-    }
 
-    top    = values_top.max
-    bottom = values_bottom.max 
-
-
-    {
-      :score => top > bottom ? top : -bottom, 
-    }
-
-
-  end
-
-  def self.scale_score1(positions, platform_entries)
-
-    mean = platform_entries/2
-    max_top = 0
-    max_bottom = 0
-
-    top_list = []
-    bottom_list = []
-
-    weights = positions.sort.collect{|position| 
-      rel_pos = ((position - mean).abs.to_f / mean);
-      0.3 * rel_pos + 0.7 * Math::exp(30*rel_pos)/Math::exp(30)
-    }
-    weights.unshift(0)
-    total_weights = weights.inject(0){|v,acc| acc += v}
-    weights.collect!{|v| v / total_weights}
-
-    rel_qt = 0
-    rel_qb = 0
-    positions.sort.each_with_index{|position, idx|
-
-      rel_qt += weights[idx + 1] 
-      rel_qb += weights[idx]     
-      rel_p   = position.to_f    / platform_entries
- 
-      top    = (rel_qt - rel_p);
-      bottom = (rel_p - rel_qb);
-
-      top_list << top
-      bottom_list << bottom
-
-      if (top > max_top) 
-        max_top = top;
-      end
-      if (bottom > max_bottom) 
-        max_bottom = bottom;
-      end
-    }
-
-    p [top_list, bottom_list]
-    if (max_top > max_bottom)
-      return max_top;
-    else
-      return -max_bottom;
-    end           
-  end
-  
   class << self
       inline do |builder|
+
         builder.c_raw <<-'EOC'
     double weight(int position, int mean){
         double rel_pos = (double) abs(position - mean) / mean; 
@@ -138,171 +13,140 @@ module Score
         return(weight);
     }
         EOC
+
         builder.c <<-'EOC'
-    double fast_score_scale( VALUE positions, int platform_entries, double missing){
+    double fast_score_scale(VALUE positions, int total, int missing){
       int idx;
     
-      int mean = platform_entries / 2;
+      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 / platform_entries));
+        rb_ary_push(rel_l, rb_float_new((double) position / total));
 
-        total_weights = total_weights + weight(position, mean);
-        rb_ary_push(rel_q,rb_float_new(total_weights));
+        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;
+      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;
+        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 (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
 
-
-
-        builder.c <<-'EOC'
-    double fast_norm_score( VALUE positions, int total, int extra, int platform_entries){
-      int idx;
-    
-      double mean = (double) platform_entries / 2;
-      double max_top, max_bottom;
-      max_top = max_bottom = 0;
-    
-      for (idx = 0; idx < RARRAY(positions)->len; idx++){
-        double position  = (double) FIX2INT(rb_ary_entry(positions, (long) idx));
-
-
-        double rel_qt = (double) (idx + 1)     / total;
-        double rel_qb = (double) (idx + extra) / total;
-        double rel_p  = position    / platform_entries;
-        
-        double scale = (abs(position - mean) / mean);
-        scale = scale * scale;
-
-        double top    = (rel_qt - rel_p) * scale;
-        double bottom = (rel_p - rel_qb) * scale;
-
-
-        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
-  def self.score_scale_fast(positions, platform_entries, missing=0)
-    return {:score => 0, :top => 0, :bottom => 0} if positions.nil? || positions.empty? || positions.compact.empty?
 
-    clean_positions = positions.compact.sort
-    missing = missing + positions.length - clean_positions.length
-
-    {
-      :score => fast_score_scale(clean_positions,  platform_entries, missing)
-    }
   end
 
 
-  def self.score_norm_fast(positions, platform_entries, missing = 0)
-    return {:score => 0, :top => 0, :bottom => 0} if positions.nil? || positions.empty? || positions.compact.empty?
-
-    clean_positions = positions.compact.sort
-
-    extra           = missing + (positions.length - clean_positions.length)
-    total_tags      = extra + clean_positions.length
-
-    {
-      :score => fast_norm_score(clean_positions, total_tags, extra, platform_entries)
-    }
+  def self.score(*args)
+    self.fast_score_scale(*args)
   end
 
-  def self.score_max(positions, platform_entries, missing = 0)
-    return {:score => 0, :top => 0, :bottom => 0} if positions.nil? || positions.empty? || positions.compact.empty?
-
-    clean_positions = positions.compact.sort
-
-    extra           = missing + (positions.length - clean_positions.length)
-    total_tags      = extra + clean_positions.length
-
+  def self.scores(dataset, genes)
+    positions   = MADB.load_positions(dataset, genes)
+    values      = MADB.num_values(dataset)
+
+    experiments = positions.keys
+
+    scores      = {}
+    experiments.each do |experiment|
+      hits  = positions[experiment].compact
+      total = values[experiment]
+      if hits.nil? || hits.empty?
+        score = 0
+      else
+        missing = genes.length - hits.length
+        score = self.fast_score_scale(hits.sort, total, missing) 
+      end
+      scores[experiment] = {
+        :positions => positions[experiment],
+        :score     => score,
+        :total     => total,
+      }
+    end
 
-    values = [0]
+    scores
+  end
 
-    clean_positions.each_with_index{|p,i| 
-      
-      up   = (i + 1).to_f / total_tags
-      down = p.to_f       / platform_entries
+  def self.combine(up, down)
+    return down if up == 0
+    return up if down == 0
 
-      values << up - down
-    }
+    return up - down
+    if (up > 0) == (down > 0)
+      return 0
+    else
+      up - down
+    end
+  end
 
-    top    = values.max
-    bottom = values.min + ((extra - 1).to_f/ total_tags)
+  def self.scores_up_down(dataset, up, down)
+    scores_up   = scores(dataset, up)
+    scores_down = scores(dataset, down)
 
+    scores      = {}
+    scores_up.keys.each do |experiment|
+      scores[experiment] = {}
+      scores[experiment][:up]    = scores_up[experiment]
+      scores[experiment][:down]  = scores_down[experiment]
+      scores[experiment][:score] = combine(scores_up[experiment][:score], scores_down[experiment][:score])
+    end
 
-    {
-      :score => top.abs > bottom.abs ? top : bottom, 
-    }
+    scores
   end
 
-  class << self
-    alias_method :score, :score_scale_fast
+  def self.permutations(size, times)
+    total = 10000
+    if size == 0
+      [0] * times
+    else
+      (1..times).collect do
+        fast_score_scale(Array.new(size){ (rand * total).to_i }.sort, total, 0)
+      end
+    end
   end
 
+  def self.null_scores(up_size, down_size, times = 10000)
+    up_perm   = permutations(up_size, times)
+    down_perm = permutations(down_size, times)
 
-  def self.score_up_down(up, down, total, missing_up = 0, missing_down = 0)
-    up = score(up, total, missing_up)
-    down = score(down, total, missing_down)
-
-    {:up =>  up[:score], :down => down[:score], :score => combine(up[:score], down[:score])}
+    up_perm.zip(down_perm).collect{|p| up, down = p; combine(up, down).abs}
   end
 
-  def self.permutations(genes, total, times = 10000)
-    scores = []
-    times.times{
-      positions = Array.new(genes){ (rand * total).to_i }
-      scores << score(positions, total)[:score]
-    }
-    scores
-  end
-
-  def self.pvalues(scores, up, down, total, options = {})
-    times = options[:times]|| 1000
+  def self.add_pvalues(scores, null_scores)
+    null_scores = null_scores.sort
+    times       = null_scores.length
 
-    permutations_up = permutations(up, total, times)
-    permutations_down = permutations(down, total, times )
-    permutations = permutations_up.zip(permutations_down).collect{|p| combine(*p).abs }.sort
+    scores.each do |experiment, info|
+      info[:pvalue] = (times - null_scores.count_smaller(info[:score].abs)).to_f / times
+    end
 
-    scores.collect{|score| 
-      num = permutations.count_smaller(score.abs)
-      (times - num).to_f / times
-    }
+    scores
   end
 
   COLORS = {
@@ -352,44 +196,3 @@ module Score
     end
   end
 end
-
-if __FILE__ == $0
-  size = 1000
-  positions=%w(10 30 200).collect{|v| v.to_i}
-  np = positions.collect{|p| size - p}
-  p Score.score(positions, size )
-  p Score.score(np, size )
-
-
-  p Score.scale_score1(positions,  size )
-  p Score.scale_score1(np,  size )
-
-  require 'benchmark'
-
-
-  p = (0..100).collect{ (rand * 1000).to_i}
-  puts Benchmark.measure{
-    1000.times{|i|
-      Score.score_max_norm(p, 1000);
-    }
-  }
-  puts Benchmark.measure{
-    1000.times{|i|
-      Score.score_max_norm_fast(p, 1000);
-    }
-  }
-
-
-  per_list = []
-  1000.times{
-    per_list << Array.new(200){(rand * 1000).to_i}
-  }
-
-  require 'benchmark'
-  puts Benchmark.measure{
-    per_list.each{|p|
-      Score.score_max_norm(p, 1000);
-    }
-  }
-
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rbbt-marq
 version: !ruby/object:Gem::Version 
-  version: 2.1.2
+  version: 3.0.0
 platform: ruby
 authors: 
 - Miguel Vazquez
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-04 00:00:00 +01:00
+date: 2010-03-09 00:00:00 +01:00
 default_executable: marq_config
 dependencies: 
 - !ruby/object:Gem::Dependency