0
@@ -0,0 +1 @@
0
+I use this stats module to do math stuff on things.

0
@@ -0,0 +1,247 @@
0
+module Stats
0
+  class Counter
0
+    include Enumerable
0
+    
0
+    def initialize(enumerable = nil)
0
+      @hash = Hash.new
0
+      @counts = 0
0
+      add_all(enumerable) unless enumerable.nil?
0
+    end
0
+    def add_with_count(key,c)
0
+      @hash[key] = (@hash[key] || 0) + c
0
+      @counts += c
0
+    end
0
+    def add_all(enumerable)
0
+      enumerable.each {|key| self << key }
0
+    end
0
+    def <<(key)
0
+      add_with_count(key,1)
0
+    end
0
+    def size
0
+      @hash.size
0
+    end
0
+    def [](key)
0
+      @hash[key]
0
+    end
0
+    def each
0
+      @hash.each_key { |k|
0
+        yield k
0
+      }
0
+    end
0
+    
0
+    def delete_if
0
+      @hash.delete_if do |k,v|
0
+        returning(yield(k,v)) do |deleted|
0
+          @counts -= v if deleted
0
+        end
0
+      end
0
+    end
0
+    
0
+    def first
0
+      [(k = @hash.keys.first),@hash[k]]
0
+    end
0
+    
0
+    def each_count
0
+      @hash.each_value { |v|
0
+        yield v
0
+      }
0
+    end
0
+    def each_with_count
0
+      each { |k|
0
+        yield k, self[k]
0
+      }
0
+    end
0
+    def total
0
+      return @counts
0
+    end
0
+    def max_count
0
+      each_to_a(:each_count).max
0
+    end
0
+    def count_histogram
0
+      return nil if @total == 0
0
+      max = max_count
0
+      returning(Histogram.new(max,max+1, 1)) do |histogram|
0
+        each_count do |c|
0
+          histogram << c
0
+        end
0
+      end
0
+    end
0
+    
0
+    def each_t_value
0
+      xbar = mean
0
+      s = standard_deviation
0
+      each_count do |c|
0
+        yield compute_t_value(c, xbar, s)
0
+      end
0
+    end
0
+    
0
+    def compute_t_value(c, xbar = mean, s = standard_deviation)
0
+      Math::sqrt(size)*(xbar - c)/s
0
+    end
0
+    
0
+    def normal?(allowed_variance = 0.1)
0
+      lr = LinearRegression.new
0
+      x = -1
0
+      each_t_value do |t|
0
+        lr.add_point(x += 1, t)
0
+      end
0
+      puts "slope is #{lr.slope}"
0
+      m = lr.slope
0
+      m < allowed_variance && m > -allowed_variance
0
+    end
0
+    
0
+    def sum_of_squares
0
+      sos = 0
0
+      each_count {|c| sos += c*c}
0
+      return sos
0
+    end
0
+    
0
+    def zscores(width = 3, center = 0, &block)
0
+      silence_warnings do
0
+        each_to_a(:each_with_zscore, width, center, &block)
0
+      end
0
+    end
0
+    
0
+    def mean
0
+      total.to_f / size
0
+    end
0
+    
0
+    def variance
0
+      (sum_of_squares - total*mean)/(size)
0
+    end
0
+    
0
+    def standard_deviation
0
+      Math::sqrt(variance)
0
+    end
0
+    
0
+    def each_with_zscore(width = 3, center = 0, &block)
0
+      if size == 0
0
+      elsif size == 1
0
+        each {|k|
0
+          yield k, center
0
+        }
0
+      else
0
+        each_with_count { |k,v|
0
+          zscore = (v - mean) / standard_deviation
0
+          zscore = 0 if zscore.nan?
0
+          block.call k, zscore*(width/3)+center
0
+        }
0
+      end
0
+      nil
0
+    end
0
+
0
+    def poisson_lambda
0
+      total/size
0
+    end
0
+  end
0
+  
0
+  class Histogram
0
+    attr_accessor :bucket_count, :max_value, :min_value
0
+    def initialize(bucket_count, max_value, min_value = 0, counts = nil)
0
+      @bucket_count = bucket_count
0
+      @min_value = min_value
0
+      @max_value = max_value
0
+      @counts = counts || [0] * bucket_count
0
+    end
0
+    
0
+    def bucket_width
0
+      @bucket_width ||= (@max_value - @min_value)/@bucket_count
0
+    end
0
+    
0
+    def bucket_index_for(floor_bucket_value)
0
+      ((floor_bucket_value - min_value).to_f/bucket_width).floor
0
+    end
0
+    
0
+    def count_for(floor_bucket_value)
0
+      @counts[bucket_index_for(floor_bucket_value)] || 0
0
+    end
0
+    
0
+    def +(other)
0
+      raise ArgumentError.new("incompatible histograms (#{self.bucket_width} != #{other.bucket_width})") unless self.bucket_width == other.bucket_width
0
+      new_max = [max_value, other.max_value].max
0
+      new_min = [min_value, other.min_value].min
0
+      returning(Histogram.new((new_max-new_min)/bucket_width, new_max, new_min)) do |h|
0
+        bv = new_min
0
+        while bv < new_max
0
+          h[h.bucket_index_for(bv)] = self.count_for(bv) + other.count_for(bv)
0
+          bv += bucket_width
0
+        end
0
+      end
0
+    end
0
+    
0
+    def bucket_index(value)
0
+      (@bucket_count *(value - @min_value).to_f / (@max_value - @min_value)).floor
0
+    end
0
+    
0
+    def <<(value)
0
+      returning(bucket_index(value)) do |c|
0
+        @counts[c] += 1
0
+      end
0
+    end
0
+    
0
+    def [](i)
0
+      @counts[i]
0
+    end
0
+    
0
+    def []=(i,v)
0
+      @counts[i] = v
0
+    end
0
+    
0
+    def to_s(options = {})
0
+      if options[:max_width]
0
+        max = @counts.max
0
+        if max > options[:max_width]
0
+          scale = options[:max_width] / max.to_f
0
+        else
0
+          scale = 1
0
+        end
0
+      else
0
+        scale = 1
0
+      end
0
+      @counts.map {|c| "| "+"*"*(c*scale).ceil}.join("\n")
0
+    end
0
+  end
0
+  
0
+  class LinearRegression
0
+    def initialize(points = [])
0
+      @points = points
0
+    end
0
+    
0
+    def add_point(x,y)
0
+      @points << [x,y]
0
+    end
0
+    
0
+    def sum(index)
0
+      @points.inject(0){|s, p| s+p[index]}
0
+    end
0
+    
0
+    def mean(index)
0
+      sum(index) / @points.size
0
+    end
0
+    
0
+    def sum_x;  sum(0);  end
0
+    def mean_x; mean(0); end
0
+    def sum_y;  sum(1);  end
0
+    def mean_y; mean(1); end
0
+    
0
+    
0
+    def sum_of_product_of_deviations
0
+      my = mean_y
0
+      mx = mean_x
0
+      @points.inject(0) {|s,p| s + ((p[0] - mx) * (p[1] - my))}
0
+    end
0
+    
0
+    def sum_of_squares_of_deviations(index = 0)
0
+      m = mean(index)
0
+      @points.inject(0){|s,p| s+((p[index] - m)**2)}
0
+    end
0
+    
0
+    def slope
0
+      sum_of_product_of_deviations / sum_of_squares_of_deviations
0
+    end
0
+    
0
+    def y_intercept
0
+      mean_y - mean_x * slope
0
+    end
0
+  end
0
+end
0
\ No newline at end of file