davidrichards-just_enumerable_stats 0.0.8 → 0.0.11

data/spec/just_enumerable_stats_spec.rb

@@ -271,7 +271,7 @@ describe "JustEnumerableStats" do
   
   it "should be able to dichotomize a list" do
     @a.dichotomize(2, :small, :big)
-    @a.categories.should eql([:small, :big])
+    @a.categories.map{|e| e.to_s}.sort.map{|e| e.to_sym}.should eql([:big, :small])
     @a.category_values[:small].should eql([1,2])
     @a.category_values[:big].should eql([3])
   end
@@ -523,14 +523,204 @@ describe "JustEnumerableStats" do
     a.covariance(b).should eql(0.125)
   end
   
-  it "should be able to return the Pearson correlation" do
-    a = [1,2,3,4]
-    b = [3,3,4,3]
-    a.pearson_correlation(b).should be_close(0.193649167310371, 1.0e-15)
-  end
-  
   it "should be able to force the list into floats" do
     [1,2,3].to_f!.should eql([1.0, 2.0, 3.0])
   end
   
+  context "unobstrusive" do
+    before do
+      @a = BusyClass.new(1,2,3)
+      @b = [2,3,1]
+    end
+    
+    it "should not use the native max" do
+      lambda{@a._jes_max}.should_not raise_error
+    end
+
+    it "should not use the native max_index" do
+      lambda{@a._jes_max_index}.should_not raise_error
+    end
+    
+    it "should not use the native min" do
+      lambda{@a._jes_min}.should_not raise_error
+    end
+    
+    it "should not use the native min_index" do
+      lambda{@a._jes_min_index}.should_not raise_error
+    end
+    
+    it "should not use the native default_block" do
+      lambda{@a._jes_default_block}.should_not raise_error
+    end
+
+    it "should not use the native default_block=" do
+      lambda{@a._jes_default_block= lambda{|e| 1} }.should_not raise_error
+    end
+    
+    it "should not use the native sum" do
+      lambda{@a._jes_sum}.should_not raise_error
+    end
+    
+    it "should not use the native average" do
+      lambda{@a._jes_average}.should_not raise_error
+    end
+    
+    it "should not use the native variance" do
+      lambda{@a._jes_variance}.should_not raise_error
+    end
+    
+    it "should not use the native standard_deviation" do
+      lambda{@a._jes_standard_deviation}.should_not raise_error
+    end
+    
+    it "should not use the native median" do
+      lambda{@a._jes_median}.should_not raise_error
+    end
+    
+    it "should not use the native categories" do
+      lambda{@a._jes_categories}.should_not raise_error
+    end
+    
+    it "should not use the native is_numeric?" do
+      lambda{@a._jes_is_numeric?}.should_not raise_error
+    end
+    
+    it "should not use the native range" do
+      lambda{@a._jes_range}.should_not raise_error
+    end
+    
+    it "should not use the native set_range_class" do
+      lambda{@a._jes_set_range_class(FixedRange)}.should_not raise_error
+    end
+
+    it "should not use the native set_range" do
+      lambda{@a._jes_set_range({:a => 1})}.should_not raise_error
+    end
+    
+    it "should not use the native dichotomize" do
+      lambda{@a._jes_dichotomize(2, :small, :big)}.should_not raise_error
+    end
+
+    it "should not use the native count_if" do
+      lambda{@a._jes_count_if {|e| e == 2}}.should_not raise_error
+    end
+    
+    it "should not use the native category_values" do
+      lambda{@a._jes_category_values}.should_not raise_error
+    end
+    
+    it "should not use the native range_class" do
+      lambda{@a._jes_range_class}.should_not raise_error
+    end
+    
+    it "should not use the native range_as_range" do
+      lambda{@a._jes_range_as_range}.should_not raise_error
+    end
+    
+    it "should not use the native new_sort" do
+      lambda{@a._jes_new_sort}.should_not raise_error
+    end
+    
+    it "should not use the native rank" do
+      lambda{@a._jes_rank}.should_not raise_error
+    end
+    
+    it "should not use the native order" do
+      lambda{@a._jes_order}.should_not raise_error
+    end
+    
+    it "should not use the native quantile" do
+      lambda{@a._jes_quantile}.should_not raise_error
+    end
+    
+    it "should not use the native cum_sum" do
+      lambda{@a._jes_cum_sum}.should_not raise_error
+    end
+    
+    it "should not use the native cum_prod" do
+      lambda{@a._jes_cum_prod}.should_not raise_error
+    end
+    
+    it "should not use the native cum_max" do
+      lambda{@a._jes_cum_max}.should_not raise_error
+    end
+    
+    it "should not use the native cum_min" do
+      lambda{@a._jes_cum_min}.should_not raise_error
+    end
+    
+    it "should not use the native product" do
+      lambda{@a._jes_product}.should_not raise_error
+    end
+    
+    it "should not use the native to_pairs" do
+      lambda{@a._jes_to_pairs(@b) {|a, b| a}}.should_not raise_error
+    end
+    
+    it "should not use the native tanimoto_pairs" do
+      lambda{@a._jes_tanimoto_pairs(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native union" do
+      lambda{@a._jes_union(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native intersect" do
+      lambda{@a._jes_intersect(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native compliment" do
+      lambda{@a._jes_compliment(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native exclusive_not" do
+      lambda{@a._jes_exclusive_not(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native cartesian_product" do
+      lambda{@a._jes_cartesian_product(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native sigma_pairs" do
+      lambda{@a._jes_sigma_pairs(@b) {|a, b| a}}.should_not raise_error
+    end
+    
+    it "should not use the native euclidian_distance" do
+      lambda{@a._jes_euclidian_distance(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native rand_in_range" do
+      lambda{@a._jes_rand_in_range(1, 2)}.should_not raise_error
+    end
+    
+    it "should not use the native correlation" do
+      lambda{@a._jes_correlation(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native yield_transpose" do
+      lambda{@a._jes_yield_transpose(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native max_of_lists" do
+      lambda{@a._jes_max_of_lists(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native min_of_lists" do
+      lambda{@a._jes_min_of_lists(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native covariance" do
+      lambda{@a._jes_covariance(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native pearson_correlation" do
+      lambda{@a._jes_pearson_correlation(@b)}.should_not raise_error
+    end
+    
+    it "should not use the native to_f!" do
+      lambda{@a._jes_to_f!}.should_not raise_error
+    end
+    
+  end
+  
 end

data/spec/spec_helper.rb

@@ -6,3 +6,65 @@ require 'just_enumerable_stats'
 Spec::Runner.configure do |config|
   
 end
+
+class BusyClass
+  include Enumerable
+  def initialize(*vals)
+    @values = vals
+  end
+  
+  def method_missing(sym, *args, &block)
+    @values.send(sym, *args, &block)
+  end
+  
+  def max(&block); raise ArgumentError, "Should not be called"; end
+  def max_index(&block); raise ArgumentError, "Should not be called"; end
+  def min(&block); raise ArgumentError, "Should not be called"; end
+  def min_index(&block); raise ArgumentError, "Should not be called"; end
+  def default_block; raise ArgumentError, "Should not be called"; end
+  def default_block=(block); raise ArgumentError, "Should not be called"; end
+  def sum; raise ArgumentError, "Should not be called"; end
+  def average(&block); raise ArgumentError, "Should not be called"; end
+  def variance(&block); raise ArgumentError, "Should not be called"; end
+  def standard_deviation(&block); raise ArgumentError, "Should not be called"; end
+  def median(ratio=0.5, &block); raise ArgumentError, "Should not be called"; end
+  def categories; raise ArgumentError, "Should not be called"; end
+  def is_numeric?; raise ArgumentError, "Should not be called"; end
+  def range(&block); raise ArgumentError, "Should not be called"; end
+  def set_range_class(klass, *args); raise ArgumentError, "Should not be called"; end
+  def set_range(hash); raise ArgumentError, "Should not be called"; end
+  def dichotomize(split_value, first_label, second_label); raise ArgumentError, "Should not be called"; end
+  def count_if(&block); raise ArgumentError, "Should not be called"; end
+  def category_values(reset=false); raise ArgumentError, "Should not be called"; end
+  def range_class; raise ArgumentError, "Should not be called"; end
+  def range_as_range(&block); raise ArgumentError, "Should not be called"; end
+  def new_sort(&block); raise ArgumentError, "Should not be called"; end
+  def rank(&block); raise ArgumentError, "Should not be called"; end
+  def order(&block); raise ArgumentError, "Should not be called"; end
+  def quantile(&block); raise ArgumentError, "Should not be called"; end
+  def cum_sum(sorted=false, &block); raise ArgumentError, "Should not be called"; end
+  def cum_prod(sorted=false, &block); raise ArgumentError, "Should not be called"; end
+  def cum_max(&block); raise ArgumentError, "Should not be called"; end
+  def cum_min(&block); raise ArgumentError, "Should not be called"; end
+  def product; raise ArgumentError, "Should not be called"; end
+  def to_pairs(other, &block); raise ArgumentError, "Should not be called"; end
+  def tanimoto_pairs(other); raise ArgumentError, "Should not be called"; end
+  def union(other); raise ArgumentError, "Should not be called"; end
+  def intersect(other); raise ArgumentError, "Should not be called"; end
+  def compliment(other); raise ArgumentError, "Should not be called"; end
+  def exclusive_not(other); raise ArgumentError, "Should not be called"; end
+  def cartesian_product(other, &block); raise ArgumentError, "Should not be called"; end
+  def sigma_pairs(other, z=_jes_zero, &block); raise ArgumentError, "Should not be called"; end
+  def euclidian_distance(other); raise ArgumentError, "Should not be called"; end
+  def rand_in_range(*args); raise ArgumentError, "Should not be called"; end
+  def correlation(other); raise ArgumentError, "Should not be called"; end
+  def yield_transpose(*enums, &block); raise ArgumentError, "Should not be called"; end
+  def max_of_lists(*enums); raise ArgumentError, "Should not be called"; end
+  def min_of_lists(*enums); raise ArgumentError, "Should not be called"; end
+  def covariance(other); raise ArgumentError, "Should not be called"; end
+  def pearson_correlation(other); raise ArgumentError, "Should not be called"; end
+  def to_f!; raise ArgumentError, "Should not be called"; end
+  
+end
+
+    

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: davidrichards-just_enumerable_stats
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.0.11
 platform: ruby
 authors: 
 - David Richards
@@ -26,12 +26,8 @@ files:
 - VERSION.yml
 - bin/jes
 - lib/fixed_range.rb
-- lib/just_enumerable_stats
-- lib/just_enumerable_stats/stats.rb
 - lib/just_enumerable_stats.rb
 - spec/fixed_range_spec.rb
-- spec/just_enumerable_stats
-- spec/just_enumerable_stats/stats_spec.rb
 - spec/just_enumerable_stats_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true

data/lib/just_enumerable_stats/stats.rb

@@ -1,597 +0,0 @@
-# This is a namespaced version of the gem, in case you can create a
-# container for your data and only include these methods there. 
-# Example:
-class Object
-  
-  # Simpler way to handle a random number between to values
-  def rand_between(a, b)
-    return rand_in_floats(a, b) if a.is_a?(Float) or b.is_a?(Float)
-    range = (a - b).abs + 1
-    rand(range) + [a,b].min
-  end
-  
-  # Handles non-integers
-  def rand_in_floats(a, b)
-    range = (a - b).abs
-    (rand * range) + [a,b].min
-  end
-  
-end
-
-module JustEnumerableStats #:nodoc:
-  module Stats
-    
-    # To keep max and min DRY.
-    def block_sorter(a, b, &block)
-      if block
-        val = yield(a, b)
-      elsif default_block
-        val = default_block.call(a, b)
-      else
-        val = a <=> b
-      end
-    end
-    protected :block_sorter
-
-    # Returns the max, using an optional block.
-    def max(&block)
-      self.inject do |best, e|
-        val = block_sorter(best, e, &block)
-        best = val > 0 ? best : e
-      end
-    end
-
-    # Returns the first index of the max value
-    def max_index(&block)
-      self.index(max(&block))
-    end
-
-    # Min of any number of items
-    def min(&block)
-      self.inject do |best, e|
-        val = block_sorter(best, e, &block)
-        best = val < 0 ? best : e
-      end
-    end
-
-    # Returns the first index of the min value
-    def min_index(&block)
-      self.index(min(&block))
-    end
-
-    # The block called to filter the values in the object.
-    def default_block
-      @default_stat_block 
-    end
-
-    # Allows me to setup a block for a series of operations.  Example:
-    # a = [1,2,3]
-    # a.sum # => 6.0
-    # a.default_block = lambda{|e| 1 / e}
-    # a.sum # => 1.0
-    def default_block=(block)
-      @default_stat_block = block
-    end
-
-    # Provides zero in the right class (Numeric or Float)
-    def zero
-      any? {|e| e.is_a?(Float)} ? 0.0 : 0
-    end
-    protected :zero
-
-    # Provides one in the right class (Numeric or Float)
-    def one
-      any? {|e| e.is_a?(Float)} ? 1.0 : 1
-    end
-    protected :one
-
-    # Adds up the list.  Uses a block or default block if present.
-    def sum
-      sum = zero
-      if block_given?
-        each{|i| sum += yield(i)}
-      elsif default_block
-        each{|i| sum += default_block[*i]}
-      else
-        each{|i| sum += i}
-      end
-      sum
-    end
-
-    # The arithmetic mean, uses a block or default block.
-    def average(&block)
-      sum(&block)/size
-    end
-    alias :mean :average
-    alias :avg :average
-
-    # The variance, uses a block or default block.
-    def variance(&block)
-      m = mean(&block)
-      sum_of_differences = if block_given?
-        sum{ |i| j=yield(i); (m - j) ** 2 }
-      elsif default_block
-        sum{ |i| j=default_block[*i]; (m - j) ** 2 }
-      else
-        sum{ |i| (m - i) ** 2 }
-      end
-      sum_of_differences / (size - 1)
-    end
-    alias :var :variance
-
-    # The standard deviation.  Uses a block or default block.
-    def standard_deviation(&block)
-      Math::sqrt(variance(&block))
-    end
-    alias :std :standard_deviation
-
-    # The slow way is to iterate up to the middle point.  A faster way is to
-    # use the index, when available.  If a block is supplied, always iterate
-    # to the middle point. 
-    def median(ratio=0.5, &block)
-      return iterate_midway(ratio, &block) if block_given?
-      begin
-        mid1, mid2 = middle_two
-        sorted = new_sort
-        med1, med2 = sorted[mid1], sorted[mid2]
-        return med1 if med1 == med2
-        return med1 + ((med2 - med1) * ratio)
-      rescue
-        iterate_midway(ratio, &block)
-      end
-    end
-
-    def middle_two
-      mid2 = size.div(2)
-      mid1 = (size % 2 == 0) ? mid2 - 1 : mid2
-      return mid1, mid2
-    end
-    protected :middle_two
-
-    def median_position
-      middle_two.last
-    end
-    protected :median_position
-
-    def first_half(&block)
-      fh = self[0..median_position].dup
-    end
-    protected :first_half
-
-    def second_half(&block)
-      # Total crap, but it's the way R does things, and this will most likely
-      # only be used to feed R some numbers to plot, if at all. 
-      sh = size <= 5 ? self[median_position..-1].dup : self[median_position - 1..-1].dup
-    end
-    protected :second_half
-
-    # An iterative version of median
-    def iterate_midway(ratio, &block)
-      mid1, mid2, last_value, j, sorted, sort1, sort2 = middle_two, nil, 0, new_sort, nil, nil
-
-      if block_given?
-        sorted.each do |i|
-          last_value = yield(i)
-          j += 1
-          sort1 = last_value if j == mid1
-          sort2 = last_value if j == mid2
-          break if j >= mid2
-        end
-      elsif default_block
-        sorted.each do |i|
-          last_value = default_block[*i]
-          j += 1
-          sort1 = last_value if j == mid1
-          sort2 = last_value if j == mid2
-          break if j >= mid2
-        end
-      else
-        sorted.each do |i|
-          last_value = i
-          sort1 = last_value if j == mid1
-          sort2 = last_value if j == mid2
-          j += 1
-          break if j >= mid2
-        end
-      end
-      return med1 if med1 == med2
-      return med1 + ((med2 - med1) * ratio)
-    end
-    protected :iterate_midway
-
-    # Takes the range_class and returns its map.
-    # Example:
-    # require 'mathn'
-    # a = [1,2,3]
-    # a
-    # range_class = FixedRange, a.min, a.max, 1/4
-    # a.categories
-    # => [1, 5/4, 3/2, 7/4, 2, 9/4, 5/2, 11/4, 3]
-    # For non-numeric values, returns a unique set, 
-    # ordered if possible.
-    def categories
-      if @categories
-        @categories
-      elsif self.is_numeric?
-        self.range_instance.map
-      else
-        self.uniq.sort rescue self.uniq
-      end
-    end
-
-    def is_numeric?
-      self.all? {|e| e.is_a?(Numeric)}
-    end
-
-    # Just an array of [min, max] to comply with R uses of the work.  Use
-    # range_as_range if you want a real Range. 
-    def range(&block)
-      [min(&block), max(&block)]
-    end
-
-    # Useful for setting a real range class (FixedRange).
-    def set_range_class(klass, *args)
-      @range_class = klass
-      @range_class_args = args
-      self.range_class
-    end
-
-    # Takes a hash of arrays for categories
-    # If Facets happens to be loaded on the computer, this keeps the order
-    # of the categories straight. 
-    def set_range(hash)
-      if defined?(Dictionary)
-        @range_hash = Dictionary.new
-        @range_hash.merge!(hash)
-        @categories = @range_hash.keys
-      else
-        @categories = hash.keys
-        @range_hash = hash
-      end
-      @categories
-    end
-
-    # The hash of lambdas that are used to categorize the enumerable.
-    attr_reader :range_hash
-
-    # The arguments needed to instantiate the custom-defined range class.
-    attr_reader :range_class_args
-
-    # Splits the values in two, <= the value and > the value.
-    def dichotomize(split_value, first_label, second_label)
-      set_range({
-        first_label => lambda{|e| e <= split_value},
-        second_label => lambda{|e| e > split_value}
-      })
-    end
-
-    # Counts each element where the block evaluates to true
-    # Example:
-    # a = [1,2,3]
-    # a.count_if {|e| e % 2 == 0}
-    def count_if(&block)
-      self.inject(0) do |s, e|
-        s += 1 if block.call(e)
-        s
-      end
-    end
-
-    # Returns a Hash or Dictionary (if available) for each category with a
-    # value as the set of matching values as an array. 
-    # Because this is supposed to be lean (just enumerables), but this is an
-    # expensive call, I'm going to cache it and offer a parameter to reset
-    # the cache.  So, call category_values(true) if you need to reset the
-    # cache. 
-    def category_values(reset=false)
-      @category_values = nil if reset
-      return @category_values if @category_values
-      container = defined?(Dictionary) ? Dictionary.new : Hash.new
-      if self.range_hash
-        @category_values = self.categories.inject(container) do |cont, cat|
-          cont[cat] = self.find_all &self.range_hash[cat]
-          cont
-        end
-      else
-        @category_values = self.categories.inject(container) do |cont, cat|
-          cont[cat] = self.find_all {|e| e == cat}
-          cont
-        end
-      end
-    end
-
-    # When creating a range, what class will it be?  Defaults to Range, but
-    # other classes are sometimes useful. 
-    def range_class
-      @range_class ||= Range
-    end
-
-    # Actually instantiates the range, instead of producing a min and max array.
-    def range_as_range(&block)
-      if @range_class_args and not @range_class_args.empty?
-        self.range_class.new(*@range_class_args)
-      else
-        self.range_class.new(min(&block), max(&block))
-      end
-    end
-    alias :range_instance :range_as_range
-
-    # I don't pass the block to the sort, because a sort block needs to look
-    # something like: {|x,y| x <=> y}.  To get around this, set the default 
-    # block on the object.
-    def new_sort(&block)
-      if block_given?
-        map { |i| yield(i) }.sort.dup
-      elsif default_block
-        map { |i| default_block[*i] }.sort.dup
-      else
-        sort().dup
-      end
-    end
-
-    # Doesn't overwrite things like Matrix#rank
-    def rank(&block)
-
-      sorted = new_sort(&block)
-
-      if block_given?
-        map { |i| sorted.index(yield(i)) + 1 }
-      elsif default_block
-        map { |i| sorted.index(default_block[*i]) + 1 }
-      else
-        map { |i| sorted.index(i) + 1 }
-      end
-
-    end unless defined?(rank)
-
-    # Given values like [10,5,5,1]
-    # Rank should produce something like [4,2,2,1]
-    # And order should produce something like [4,2,3,1]
-    # The trick is that rank skips as many as were duplicated, so there
-    # could not be a 3 in the rank from the example above. 
-    def order(&block)
-      hold = []
-      rank(&block).each do |x|
-        while hold.include?(x) do
-          x += 1
-        end
-        hold << x
-      end
-      hold
-    end
-
-    # First quartile: nth_split_by_m(1, 4)
-    # Third quartile: nth_split_by_m(3, 4)
-    # Median: nth_split_by_m(1, 2)
-    # Doesn't match R, and it's silly to try to.
-    # def nth_split_by_m(n, m)
-    #   sorted  = new_sort
-    #   dividers = m - 1
-    #   if size % m == dividers # Divides evenly
-    #     # Because we have a 0-based list, we get the floor
-    #     i = ((size / m.to_f) * n).floor
-    #     j = i
-    #   else
-    #     # This reflects R's approach, which I don't think I agree with.
-    #     i = (((size / m.to_f) * n) - 1)
-    #     i = i > (size / m.to_f) ? i.floor : i.ceil
-    #     j = i + 1
-    #   end
-    #   sorted[i] + ((n / m.to_f) * (sorted[j] - sorted[i]))
-    # end
-    def quantile(&block)
-      [
-        min(&block), 
-        first_half(&block).median(0.25, &block), 
-        median(&block), 
-        second_half(&block).median(0.75, &block), 
-        max(&block)
-      ]
-    end
-
-    # The cummulative sum.  Example:
-    # [1,2,3].cum_sum # => [1, 3, 6]
-    def cum_sum(sorted=false, &block)
-      sum = zero
-      obj = sorted ? self.new_sort : self
-      if block_given?
-        obj.map { |i| sum += yield(i) }
-      elsif default_block
-        obj.map { |i| sum += default_block[*i] }
-      else
-        obj.map { |i| sum += i }
-      end
-    end
-    alias :cumulative_sum :cum_sum
-
-    # The cummulative product.  Example:
-    # [1,2,3].cum_prod # => [1.0, 2.0, 6.0]
-    def cum_prod(sorted=false, &block)
-      prod = one
-      obj = sorted ? self.new_sort : self
-      if block_given?
-        obj.map { |i| prod *= yield(i) }
-      elsif default_block
-        obj.map { |i| prod *= default_block[*i] }
-      else
-        obj.map { |i| prod *= i }
-      end
-    end
-    alias :cumulative_product :cum_prod
-
-    # Used to preprocess the list
-    def morph_list(&block)
-      if block
-        self.map{ |e| block.call(e) }
-      elsif self.default_block
-        self.map{ |e| self.default_block.call(e) }
-      else
-        self
-      end
-    end
-    protected :morph_list
-
-    # Example:
-    # [1,2,3,0,5].cum_max # => [1,2,3,3,5]
-    def cum_max(&block)
-      morph_list(&block).inject([]) do |list, e|
-        found = (list | [e]).max
-        list << (found ? found : e)
-      end
-    end
-    alias :cumulative_max :cum_max
-
-    # Example: 
-    # [1,2,3,0,5].cum_min # => [1,1,1,0,0]
-    def cum_min(&block)
-      morph_list(&block).inject([]) do |list, e|
-        found = (list | [e]).min
-        list << (found ? found : e)
-      end
-    end
-    alias :cumulative_min :cum_min
-
-    # Multiplies the values:
-    # >> product(1,2,3)
-    # => 6.0
-    def product
-      self.inject(one) {|sum, a| sum *= a}
-    end
-
-    # There are going to be a lot more of these kinds of things, so pay
-    # attention. 
-    def to_pairs(other, &block)
-      n = [self.size, other.size].min
-      (0...n).map {|i| block.call(self[i], other[i]) }
-    end
-
-    # Finds the tanimoto coefficient: the intersection set size / union set
-    # size.  This is used to find the distance between two vectors.
-    # >> [1,2,3].cor([2,3,5])
-    # => 0.981980506061966
-    # >> [1,2,3].tanimoto_pairs([2,3,5])
-    # => 0.5
-    def tanimoto_pairs(other)
-      intersect(other).size / union(other).size.to_f
-    end
-    alias :tanimoto_correlation :tanimoto_pairs
-
-    # Sometimes it just helps to have things spelled out.  These are all
-    # part of the Array class. This means, you have methods that you can't
-    # run on some kinds of enumerables. 
-
-    # All of the left and right hand sides, excluding duplicates.
-    # "The union of x and y"
-    def union(other)
-      other = other.to_a unless other.is_a?(Array)
-      self | other
-    end
-
-    # What's shared on the left and right hand sides
-    # "The intersection of x and y"
-    def intersect(other)
-      other = other.to_a unless other.is_a?(Array)
-      self & other
-    end
-
-    # Everything on the left hand side except what's shared on the right
-    # hand side. 
-    # "The relative compliment of y in x"
-    def compliment(other)
-      other = other.to_a unless other.is_a?(Array)
-      self - other
-    end
-
-    # Everything but what's shared
-    def exclusive_not(other)
-      other = other.to_a unless other.is_a?(Array)
-      (self | other) - (self & other)
-    end
-
-    # Finds the cartesian product, excluding duplicates items and self-
-    # referential pairs.  Yields the block value if given. 
-    def cartesian_product(other, &block)
-      x,y = self.uniq.dup, other.uniq.dup
-      pairs = x.inject([]) do |cp, i|
-        cp | y.map{|b| i == b ? nil : [i,b]}.compact
-      end
-      return pairs unless block_given?
-      pairs.map{|p| yield p.first, p.last}
-    end
-    alias :cp :cartesian_product
-    alias :permutations :cartesian_product
-
-    # Sigma of pairs.  Returns a single float, or whatever object is sent in.
-    # Example: [1,2,3].sigma_pairs([4,5,6], 0) {|x, y| x + y}
-    # returns 21 instead of 21.0.
-    def sigma_pairs(other, z=zero, &block)
-      self.to_pairs(other,&block).inject(z) {|sum, i| sum += i}
-    end
-
-    # Returns the Euclidian distance between all points of a set of enumerables
-    def euclidian_distance(other)
-      Math.sqrt(self.sigma_pairs(other) {|a, b| (a - b) ** 2})
-    end
-
-    # Returns a random integer in the range for any number of lists.  This
-    # is a way to get a random vector that is tenable based on the sample
-    # data.  For example, given two sets of numbers: 
-    # 
-    # a = [1,2,3]; b = [8,8,8]
-    # 
-    # rand_in_pair_range will return a value >= 1 and <= 8 in the first
-    # place, >= 2 and <= 8 in the second place, and >= 3 and <= 8 in the
-    # last place. 
-    # Works for integers.  Rethink this for floats.  May consider setting up
-    # FixedRange for floats.  O(n*5)
-    def rand_in_range(*args)
-      min = self.min_of_lists(*args)
-      max = self.max_of_lists(*args)
-      (0...size).inject([]) do |ary, i|
-        ary << rand_between(min[i], max[i])
-      end
-    end
-
-    # Finds the correlation between two enumerables.
-    # Example: [1,2,3].cor [2,3,5]
-    # returns 0.981980506061966
-    def correlation(other)
-      n = [self.size, other.size].min
-      sum_of_products_of_pairs = self.sigma_pairs(other) {|a, b| a * b}
-      self_sum = self.sum
-      other_sum = other.sum
-      sum_of_squared_self_scores = self.sum { |e| e * e }
-      sum_of_squared_other_scores = other.sum { |e| e * e }
-
-      numerator = (n * sum_of_products_of_pairs) - (self_sum * other_sum)
-      self_denominator = ((n * sum_of_squared_self_scores) - (self_sum ** 2))
-      other_denominator = ((n * sum_of_squared_other_scores) - (other_sum ** 2))
-      denominator = Math.sqrt(self_denominator * other_denominator)
-      return numerator / denominator
-    end
-    alias :cor :correlation
-
-    # Transposes arrays of arrays and yields a block on the value.
-    # The regular Array#transpose ignores blocks
-    def yield_transpose(*enums, &block)
-      enums.unshift(self)
-      n = enums.map{ |x| x.size}.min
-      block ||= lambda{|e| e}
-      (0...n).map { |i| block.call enums.map{ |x| x[i] } }
-    end
-
-    # Returns the max of two or more enumerables.
-    # >> [1,2,3].max_of_lists([0,5,6], [0,2,9])
-    # => [1, 5, 9]
-    def max_of_lists(*enums)
-      yield_transpose(*enums) {|e| e.max}
-    end
-
-    # Returns the min of two or more enumerables.
-    # >> [1,2,3].min_of_lists([4,5,6], [0,2,9])
-    # => [0, 2, 3]
-    def min_of_lists(*enums)
-      yield_transpose(*enums) {|e| e.min}
-    end
-
-  end
-end