facets 2.9.0.pre.1 → 2.9.0.pre.2

data/lib/more/facets/math/log2.rb

@@ -0,0 +1,14 @@
+module Math
+
+  INVERSE_LN_2 = 1.0 / ::Math.log(2.0)
+
+  unless defined?(log2)
+
+    # Logarithmus dualis of +x+.
+    def self.log2(x)
+      Math.log(x) * INVERSE_LN_2
+    end
+
+  end
+
+end

data/lib/more/facets/math/max.rb

@@ -0,0 +1 @@
+require 'facets/math/min'

data/lib/more/facets/math/mean.rb

@@ -0,0 +1,16 @@
+require  'facets/math/sum'
+
+module Math
+
+  # Mean average.
+  def self.mean(array, &blk)
+    s = array.size
+    return 0.0 if s == 0
+    sum(array, &blk) / s
+  end
+
+  class << self
+    alias_method :mean_average, :mean
+  end
+
+end

data/lib/more/facets/math/median.rb

@@ -0,0 +1,15 @@
+module Math
+
+  #
+  def self.median(array)
+    return 0 if array.size == 0
+    tmp = array.sort
+    mid = tmp.size / 2
+    if (tmp.size % 2) == 0
+	    (tmp[mid-1] + tmp[mid]).to_f / 2
+    else
+	    tmp[mid]
+    end
+  end
+
+end

data/lib/more/facets/math/min.rb

@@ -0,0 +1,35 @@
+module Math
+
+  #
+  def self.min(array, &block)
+    if block_given?
+      if min = array.find{ |i| i }
+        min = yield(min)
+        array.each do |i|
+          j = yield(i)
+          min = j if min > j
+        end
+        min
+      end
+    else
+      array.min
+    end
+  end
+
+  #
+  def self.max(array, block)
+    if block_given?
+      if max = find{|i| i}
+        max = yield(max)
+        each{|i|
+          j = yield(i)
+          max = j if max < j
+        }
+        max
+      end
+    else
+      array.max
+    end
+  end
+
+end

data/lib/more/facets/math/pow.rb

@@ -0,0 +1,8 @@
+module Math
+
+  # +x+ to the power +y+
+  def self.pow(x, y)
+    x ** y
+  end
+
+end

data/lib/more/facets/math/pstd.rb

@@ -0,0 +1 @@
+require 'facets/math/std'

data/lib/more/facets/math/pvariance.rb

@@ -0,0 +1 @@
+require 'facets/math/variance'

data/lib/more/facets/math/rmd.rb

@@ -0,0 +1,16 @@
+require 'facets/math/approx_equal'
+
+module Math
+
+  # Calculates the relative mean difference of this sample.
+  # Makes use of the fact that the Gini Coefficient is half the RMD.
+  def self.rmd(array)
+    return 0.0 if approx_equal(mean(array), 0.0)
+    gini_coefficient(array) * 2
+  end
+
+  class << self
+    alias_method  :relative_mean_difference, :rmd
+  end
+
+end

data/lib/more/facets/math/root.rb

@@ -0,0 +1,8 @@
+module Math
+
+  # The +y+ root of +x+.
+  def self.root(x, y)
+    x ** (1.0 / y)
+  end
+
+end

data/lib/more/facets/math/sec.rb

@@ -0,0 +1,8 @@
+module Math
+
+  # Secans of +x+.
+  def self.sec(x)
+    1.0 / cos(x)
+  end
+
+end

data/lib/more/facets/math/sech.rb

@@ -0,0 +1,8 @@
+module Math
+
+  # Secans hyperbolicus of +x+
+  def self.sech(x)
+    1.0 / cosh(x)
+  end
+
+end

data/lib/more/facets/math/sign.rb

@@ -0,0 +1,9 @@
+module Math
+
+  # Sign of +x+.
+  # Returns -1 for negative x, +1 for positive x and zero for x = 0 
+  def self.sign(x)
+    (x > 0.0) ? 1.0 : ((x < 0.0) ? -1.0 : 0.0)
+  end
+
+end

data/lib/more/facets/math/sinc.rb

@@ -0,0 +1,8 @@
+module Math
+
+  # Sinc function of +x+.
+  def self.sinc(x)
+    (x == 0.0) ? 1.0 : sin(x) / x
+  end
+
+end

data/lib/more/facets/math/sqr.rb

@@ -0,0 +1,8 @@
+module Math
+
+  # Square of number.
+  def self.sqr(x)
+    x * x
+  end
+
+end

data/lib/more/facets/math/sqsolve.rb

@@ -0,0 +1,53 @@
+module Math
+
+  # Returns array of real solution of <code>ax**2 + bx + c = d</code>
+  # or <code>nil</code> if no or an infinite number of solutions exist.
+  # If +d+ is missing it is assumed to be 0.
+  #
+  # == Solving second order equations
+  # In order to solve <code>ax**2 + bx + c = d</code> +Extmath.sqsolve+ identifies several cases:
+  # * <code>a == 0:</code>
+  #   The equation to be solved is the linear equation <code>bx + c = d</code>. #sqsolve> delegates the computation to
+  #   #linsolve>. If it results in +nil+, +nil+ is returned (not <code>[nil]</code>!). Otherwise a one-element array
+  #   containing result of #linsolve is returned.
+  # * <code>a != 0:</code>
+  #    The equation to be solved actually is a second order one.
+  #    * <code>c == d</code>
+  #      The equation to be solved is <code>ax**2 + bx = 0</code>. One solution of this equation obviously is
+  #      <code>x = 0</code>, the second one solves <code>ax + b = 0</code>. The solution of the latter is
+  #      delegated to +Extmath.linsolve+. An array containing both results in ascending order is returned.
+  #    * <code>c != d</code>
+  #      The equation cannot be separated into <code>x</code> times some factor.
+  #      * <code>b == 0</code>
+  #        The equation to be solved is <code>ax**2 + c = d</code>. This can be written as the linear equation
+  #        <code>ay + c = d</code> with <code>y = x ** 2</code>. The solution of the linear equation is delegated
+  #        to +Extmath.linsolve+. If the returned value for +y+ is +nil+, that becomes the overall return value.
+  #        Otherwise an array containing the negative and positive squareroot of +y+ is returned
+  #      * <code>b != 0 </code>
+  #        The equation cannot be reduced to simpler cases. We now first have to compute what is called the
+  #        discriminant <code>x = b**2 + 4a(d - c)</code> (that's what we need to compute the square root of).
+  #        If the descriminant is negative no real solution exists and <code>nil</code> is returned. The ternary
+  #        operator checking whether <code>b</code> is negative does ensure better numerical stability --only one
+  #        of the two solutions is computed using the widely know formula for solving second order equations.
+  #        The second one is computed from the fact that the product of both solutions is <code>(c - d) / a</code>.
+  #        Take a look at a book on numerical mathematics if you don't understand why this should be done.
+  #
+  def self.sqsolve(a, b, c, d = 0.0)
+    if a == 0.0
+      x = linsolve(b, c, d)
+      return x.nil? ? nil: [ linsolve(b, c, d) ]
+    else
+      return [0.0, linsolve(a, b)].sort if c == d
+      if b == 0.0
+        x = Extmath.linsolve(a, c, d)
+        x < 0.0 ? nil : [-Math.sqrt(x), Math.sqrt(x)]
+      else
+        x = b * b + 4.0 * a * (d - c)
+        return nil if x < 0.0
+        x = b < 0 ? b - Math.sqrt(x) : b + Math.sqrt(x)
+        [-0.5 * x / a, 2.0 * (d - c) / x].sort
+      end
+    end
+  end
+
+end

data/lib/more/facets/math/std.rb

@@ -0,0 +1,27 @@
+require 'facets/math/variance'
+
+module Math
+
+  # Standard deviation of a sample.
+  #
+  def self.std(array, &block)
+    sqrt(variance(array, &block))
+  end
+
+  class << self
+    alias_method :standard_deviation, :std
+  end
+
+  # Standard deviation of a population.
+  #
+  def self.pstd(array, &block)
+    Math::sqrt(pvariance(array, &block))
+  end
+
+  # Calculates the standard error of a sample.
+  def self.stderr(array)
+    return 0.0 if array.size < 2
+    std(array) / sqrt(array.size)
+  end
+
+end

data/lib/more/facets/math/stderr.rb

@@ -0,0 +1 @@
+require 'facets/math/std'

data/lib/more/facets/math/sum.rb

@@ -0,0 +1,16 @@
+module Math
+
+  # Returns sum.  When a block is given, summation is taken over the 
+  # each result of block evaluation.
+  #
+  def self.sum(array) #:yield:
+    sum = 0.0
+    if block_given?
+      array.each{|i| sum += yield(i)}
+    else
+      array.each{|i| sum += i}
+    end
+    sum
+  end
+
+end

data/lib/more/facets/math/summed_sqdevs.rb

@@ -0,0 +1,14 @@
+require 'facets/math/sum'
+require 'facets/math/mean'
+
+module Math
+
+  # The sum of the squared deviations from the mean.
+  #
+  def self.summed_sqdevs(array)
+    return 0 if array.size < 2
+    m = mean(array)
+    sum(array.map{ |x| (x - m) ** 2 })
+  end
+
+end

data/lib/more/facets/math/theil_index.rb

@@ -0,0 +1,24 @@
+require 'facets/math/sum'
+require 'facets/math/mean'
+require 'facets/math/approx_equal'
+
+module Math
+
+  # Calculates the Theil index (a statistic used to measure
+  # economic inequality).
+  #
+  # TI = \sum_{i=1}^N \frac{x_i}{\sum_{j=1}^N x_j} ln \frac{x_i}{\bar{x}}
+  #
+  #   http://en.wikipedia.org/wiki/Theil_index
+  #
+  def self.theil_index(array)
+    return -1 if array.size <= 0 or any? { |x| x < 0 }
+    return  0 if array.size <  2 or all? { |x| approx_equal(x, 0) }
+    m = mean(array)
+    s = sum(array).to_f
+    inject(0) do |theil, xi|
+	    theil + ((xi > 0) ? (log(xi.to_f/m) * xi.to_f/s) : 0.0)
+    end
+  end
+
+end

data/lib/more/facets/math/variance.rb

@@ -0,0 +1,31 @@
+require 'facets/math/summed_sqdevs'
+
+module Math
+
+  #
+  def self.variance(array, &block)
+    sum2 = if block_given?
+      sum(array){ |i| j = block[i]; j*j }
+    else
+      sum(array){ |i| i**2 }
+    end
+    sum2/array.size - mean(array, &block)**2
+  end
+
+  # Variance of the sample.
+  # Variance of 0 or 1 elements is 0.0.
+  #
+  # TODO: Same as #variance? Then choose one.
+  def self.variance2(array)
+    return 0.0 if array.size < 2
+    summed_sqdevs(array) / (array.size - 1)
+  end
+
+  # Variance of a population.
+  # Variance of 0 or 1 elements is 0.0.
+  def self.pvariance(array)
+    return 0.0 if array.size < 2
+    summed_sqdevs(array) / array.size
+  end
+
+end

data/lib/more/facets/thread.rb

@@ -71,4 +71,28 @@ module Enumerable
 
 end
 
+
+module Kernel
+  private
+
+  # CREDIT: Zucker
+  def sandbox(rescueblock_or_default=nil) #:yield:
+    Thread.start do
+      $SAFE = 4
+      yield
+    end.value
+  rescue SecurityError => e
+    if !rescueblock_or_default.nil?
+      if rescueblock_or_default.is_a? Proc
+        rescueblock_or_default.call e
+      else
+        rescueblock_or_default
+      end
+    else
+      raise e
+    end
+  end
+
+end
+
 # Copyright (c) 2006 Sean O'Halpin, Thomas Sawyer

data/lib/tour/facets/array/op_pow.rb

@@ -0,0 +1,5 @@
+require 'facets/array/product'
+
+class Array
+  alias_method :**, :product
+end

data/lib/tour/facets/module/enclosure.rb

@@ -58,5 +58,19 @@ class Module
     n
   end
 
-end
+  # Eclosure name.
+  #
+  #   module ::EncExample
+  #     module M
+  #       module N
+  #       end
+  #     end
+  #   end
+  #
+  #   EncExample::M::N.encname  #=> "EncExample::M"
+  #
+  def encname
+    /::[^:]+\Z/ =~ self.name ? $` : nil
+  end
 
+end

data/lib/tour/facets/module/preextend.rb

@@ -0,0 +1,26 @@
+class Module
+
+  # Prepend an +aspect+ module to a module.
+  # This only works at the module level.
+  #
+  #   module ::PreX
+  #     def x; "x"; end
+  #   end
+  #
+  #   module ::PreU
+  #     def x; '{' + super + '}'; end
+  #   end
+  #
+  #   PreX.preextend(PreU)
+  #
+  #   PreX.x  # => "{x}"
+  #
+  # CREDIT Trans
+
+  def preextend(aspect)
+    aspect.__send__(:include, self)
+    extend aspect
+  end
+
+end
+