davidrichards-just_enumerable_stats 0.0.11 → 0.0.12

data/README.rdoc

@@ -23,55 +23,62 @@ Looking at the library through jes, you can see that we have all the usual goodi
 The list of methods are:
 
 * average
-* avg (average)
+* avg
 * cartesian_product
+* categories
+* category_values
 * compliment
-* cor (correlation)
+* cor
 * correlation
-* cp (cartesian_product)
-* cum_max (cumulative_max)
-* cum_min (cumulative_min)
-* cum_prod (cumulative_product)
-* cum_sum (cumulative_sum)
+* count_if
+* covariance
+* cum_max
+* cum_min
+* cum_prod
+* cum_sum
 * cumulative_max
 * cumulative_min
 * cumulative_product
 * cumulative_sum
 * default_block
 * default_block=
+* dichotomize
 * euclidian_distance
 * exclusive_not
 * intersect
+* is_numeric?
 * max
 * max_index
 * max_of_lists
-* mean (average)
+* mean
 * median
 * min
 * min_index
 * min_of_lists
 * new_sort
 * order
-* original_max
-* original_min
-* permutations (cartesian_product)
+* pearson_correlation
+* permutations
 * product
 * quantile
 * rand_in_range
 * range
 * range_as_range
 * range_class
-* range_class=
+* range_instance
 * rank
+* set_range
+* set_range_class
 * sigma_pairs
 * standard_deviation
-* std (standard_deviation)
+* std
 * sum
-* tanimoto_correlation (tanimoto_pairs)
+* tanimoto_correlation
 * tanimoto_pairs
+* to_f!
 * to_pairs
 * union
-* var (variance)
+* var
 * variance
 * yield_transpose
 
@@ -97,7 +104,54 @@ Another interesting feature is the default block getter and setter.  Sometimes I
   # => [2,4,6]
   a.std
   # => 2.0 instead of 1.0
-    
+  
+== Scaling
+
+There are a few new features for scaling data:
+
+  >> a = [1,2,3]
+  => [1, 2, 3]
+  >> a.scale(2)
+  => [2, 4, 6]
+  >> a
+  => [1, 2, 3]
+  >> a.scale!(2)
+  => [2, 4, 6]
+  >> a
+  => [2, 4, 6]
+  >> a.scale {|e| e - 1}
+  => [1, 3, 5]
+  >> a
+  => [2, 4, 6]
+  >> a.scale! {|e| e - 1}
+  => [1, 3, 5]
+  >> a                   
+  => [1, 3, 5]
+  >> a.scale_between(3,4)
+  => [3.0, 3.5, 4.0]
+  >> a
+  => [1, 3, 5]
+  >> a.scale_between!(3,4)
+  => [3.0, 3.5, 4.0]
+  >> a
+  => [3.0, 3.5, 4.0]
+  >> a = [1,2,3]
+  => [1, 2, 3]
+  >> a.normalize
+  => [0.166666666666667, 0.333333333333333, 0.5]
+  >> a      
+  => [1, 2, 3]
+  >> a.normalize!
+  => [0.166666666666667, 0.333333333333333, 0.5]
+  >> a
+  => [0.166666666666667, 0.333333333333333, 0.5]
+
+Basically:
+
+* scale can scale by a number or with a block.  The block is a transformation for a single element.
+* scale_between sets the minimum and maximum values, and keeps each value proportionate to each other.
+* normalize calculates the percentage of an element to the whole.
+
 == Categories
 
 Once I started using this gem with my distribution table classes, I needed to have flexible categories on an enumerable.  What that looks like is:

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 0
-:patch: 11
+:patch: 12

data/lib/just_enumerable_stats.rb

@@ -400,6 +400,8 @@ module Enumerable
 
   end
   safe_alias :_jes_rank
+  safe_alias :_jes_ordinalize, :_jes_rank
+  safe_alias :ordinalize, :_jes_rank
 
   # Given values like [10,5,5,1]
   # Rank should produce something like [4,2,2,1]
@@ -696,8 +698,69 @@ module Enumerable
     return true if @_jes_to_f
     @_jes_to_f = self.map! {|e| e.to_f}
   end
+  
+  # Scale a list by a number.  The implementation of this can be self-referential.
+  # Example: a.scale!(a.standard_deviation)
   safe_alias :_jes_to_f!
+
+  def _jes_scale(val=nil, &block)
+    if block
+      self.map{|e| block.call(e)}
+    else
+      self.map{|e| e * val}
+    end
+  end
+  safe_alias :_jes_scale
+  
+  def _jes_scale!(val=nil, &block)
+    if block
+      self.map!{|e| block.call(e)}
+    else
+      self.map!{|e| e * val}
+    end
+  end
+  safe_alias :_jes_scale!
   
+  def _jes_scale_to_sigmoid!
+    self._jes_scale! { |e| 1 / (1 + Math.exp( -1 * (e))) }
+  end
+  safe_alias :_jes_scale_to_sigmoid!
+
+  def _jes_normalize
+    self.map {|e| e.to_f / self._jes_sum }
+  end
+  safe_alias :_jes_normalize
+  
+  def _jes_normalize!
+    sum = self._jes_sum
+    self.map! {|e| e.to_f / sum }
+  end
+  safe_alias :_jes_normalize!
+  
+  def _jes_scale_between(*values)
+    raise ArgumentError, "Must provide two values" unless values.size == 2
+    values.sort!
+    min = values[0]
+    max = values[1]
+    orig_min = self._jes_min
+    scalar = (max - min) / (self._jes_max - orig_min).to_f
+    shift = min - (orig_min * scalar)
+    self._jes_scale{|e| (e * scalar) + shift}
+  end
+  safe_alias :_jes_scale_between
+
+  def _jes_scale_between!(*values)
+    raise ArgumentError, "Must provide two values" unless values.size == 2
+    values.sort!
+    min = values[0]
+    max = values[1]
+    orig_min = self._jes_min
+    scalar = (max - min) / (self._jes_max - orig_min).to_f
+    shift = min - (orig_min * scalar)
+    self._jes_scale!{|e| (e * scalar) + shift}
+  end
+  safe_alias :_jes_scale_between!
+
 end
 
 @a = [1,2,3]

data/spec/just_enumerable_stats_spec.rb

@@ -527,200 +527,68 @@ describe "JustEnumerableStats" 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 have the ability to scale the list by a number" do
+    a = [1,2,3,4]
+    a.scale!(0.5)
+    a.should eql([0.5, 1.0, 1.5, 2.0])
+  end
+  
+  it "should be able to scale a list by a calculation on the list" do
+    a = (1..10).inject([]) {|list, i| list << rand}
+    std = a.std
+    b = a.map {|e| e * std}
+    a.should_receive(:std).once.and_return(std)
+    a.scale!(a.std)
+    a.should eql(b)
+  end
+  
+  it "should be able to scale by a function" do
+    a = [-4, -2, 0, 2, 4]
+    a.scale! { |e| 1 / (1 + Math.exp( -1 * (e))) }
+    a[0].should be_close(0.01798, 1.0e-5)
+    a[1].should be_close(0.11920, 1.0e-5)
+    a[2].should eql(0.5)
+    a[3].should be_close(0.88079, 1.0e-5)
+    a[4].should be_close(0.98201, 1.0e-5)
+  end
+  
+  it "should be able to scale to a signoid" do
+    a = [-4, -2, 0, 2, 4]
+    a.scale_to_sigmoid!
+    a[0].should be_close(0.01798, 1.0e-5)
+    a[1].should be_close(0.11920, 1.0e-5)
+    a[2].should eql(0.5)
+    a[3].should be_close(0.88079, 1.0e-5)
+    a[4].should be_close(0.98201, 1.0e-5)
+  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 be able to normalize a list" do
+    b = @a.normalize
+    b.should eql([1/6.0, 2/6.0, 3/6.0])
+    @a.normalize!
+    @a.should eql(b)
+  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
+  context "scale_between" do
+    before do
+      @a = [-4, -2, 0, 2, 4]
     end
     
-    it "should not use the native covariance" do
-      lambda{@a._jes_covariance(@b)}.should_not raise_error
+    it "should require two parameters" do
+      lambda{@a.scale_between(1)}.should raise_error(ArgumentError, 'Must provide two values')
+      lambda{@a.scale_between(1,2)}.should_not raise_error
+      lambda{@a.scale_between(1,2,3)}.should raise_error(ArgumentError, 'Must provide two values')
     end
     
-    it "should not use the native pearson_correlation" do
-      lambda{@a._jes_pearson_correlation(@b)}.should_not raise_error
+    it "should return a new array between the scaled values" do
+      b = @a.scale_between(1,2)
+      b.should eql([1.0, 1.25, 1.5, 1.75, 2.0])
     end
     
-    it "should not use the native to_f!" do
-      lambda{@a._jes_to_f!}.should_not raise_error
+    it "should be able to transform into a scaled set" do
+      b = @a.scale_between(1,2)
+      @a.scale_between!(1,2)
+      @a.should eql(b)
     end
-    
   end
-  
 end

data/spec/spec_helper.rb

@@ -40,6 +40,7 @@ class BusyClass
   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 ordinalize(&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
@@ -64,7 +65,12 @@ class BusyClass
   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
-  
+  def scale!; raise ArgumentError, "Should not be called"; end
+  def scale_to_sigmoid!; raise ArgumentError, "Should not be called"; end
+  def normalize; raise ArgumentError, "Should not be called"; end
+  def normalize!; raise ArgumentError, "Should not be called"; end
+  def scale_between; raise ArgumentError, "Should not be called"; end
+  def scale_between!; raise ArgumentError, "Should not be called"; end
 end
 
     

data/spec/unobtrusive_just_enumerable_stats_spec.rb

@@ -0,0 +1,229 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "JustEnumerableStats" do
+  
+  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 ordinalize" do
+      lambda{@a._jes_ordinalize}.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
+    
+    it "should not use the native scale!" do
+      lambda{@a._jes_scale!(1)}.should_not raise_error
+    end
+    
+    it "should not use the native scale_to_sigmoid!" do
+      lambda{@a._jes_scale_to_sigmoid!}.should_not raise_error
+    end
+    
+    it "should not use the native normalize" do
+      lambda{@a._jes_normalize}.should_not raise_error
+    end
+    
+    it "should not use the native normalize!" do
+      lambda{@a._jes_normalize!}.should_not raise_error
+    end
+    
+    it "should not use the native scale_between" do
+      lambda{@a._jes_scale_between(6,8)}.should_not raise_error
+    end
+    
+    it "should not use the native scale_between!" do
+      lambda{@a._jes_scale_between!(6,8)}.should_not raise_error
+    end
+    
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: davidrichards-just_enumerable_stats
 version: !ruby/object:Gem::Version 
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors: 
 - David Richards
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-11 00:00:00 -07:00
+date: 2009-08-17 00:00:00 -07:00
 default_executable: jes
 dependencies: []
 
@@ -30,6 +30,7 @@ files:
 - spec/fixed_range_spec.rb
 - spec/just_enumerable_stats_spec.rb
 - spec/spec_helper.rb
+- spec/unobtrusive_just_enumerable_stats_spec.rb
 has_rdoc: true
 homepage: http://github.com/davidrichards/just_enumerable_stats
 licenses: