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

data/lib/more/facets/math.rb

@@ -0,0 +1,6 @@
+dir, base = *File.split(__FILE__)
+base = base.chomp('.rb')
+Dir[File.join(dir, base, '*')].each do |lib|
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Absolute value of +x+.
+  def self.abs(x)
+    x.abs
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Arcus cotangens of +x+
+  def self.acot(x)
+    (PI * 0.5) - atan(x)
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Area cotangens hyperbolicus of +x+
+  def self.acoth(x)
+    0.5 * log((x + 1.0) / (x - 1.0))
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Arcus cosecans of +x+
+  def self.acsc(x)
+    asin(1.0 / x)
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Area cosecans hyperbolicus of +x+
+  def acsch(x)
+    ::Math.log(1.0 / x + Math.sqrt(1.0 + 1.0 / (x * x)))
+  end
+
+end

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

@@ -0,0 +1,17 @@
+require 'facets/math/rmd'
+require 'facets/math/mean'
+
+module Math
+    
+  # The average absolute difference of two independent values drawn 
+  # from the sample. Equal to the RMD * mean.
+  def self.amd(array)
+	  rmd(array) * mean(array)
+  end
+
+  class << self
+    alias_method :absolute_mean_difference, :amd
+    #alias_method :md, :mean_difference
+  end
+
+end

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

@@ -0,0 +1,15 @@
+module Math
+
+  #
+  EPSILON = 0.000000001
+
+  # Approximately equal.
+  #
+  # TODO: Use core extension Numeric#approx? instead.
+  def self.approx_equal(a, b, epsilon=EPSILON)
+	  c = a - b
+	  c *= -1.0 if c < 0
+    c < epsilon
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Arcus secans of +x+
+  def self.asec(x)
+    acos(1.0 / x)
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Area secans hyperbolicus of +x+
+  def asech(x)
+    log((1.0 + sqrt(1.0 - x * x)) / x)
+  end
+
+end

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

@@ -0,0 +1,16 @@
+require 'facets/math/theil_index'
+
+module Math
+
+  # Closely related to the Theil index and easily expressible
+  # in terms of it.
+  #
+  # AI = 1-e^{theil_index}
+  #
+  # http://en.wikipedia.org/wiki/Atkinson_index
+  def self.atkinson_index(array)
+    t = theil_index(array)
+    (t < 0) ? -1 : 1-Math::E**(-t)
+  end
+
+end

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

@@ -0,0 +1,9 @@
+module Math
+
+  # Beta function of +x+ and +y+ - <code>beta(+x+, +y+) =
+  # tgamma(+x+) * tgamma(+y+) / tgamma(+x+ + +y+)</code>
+  def self.beta(x, y)
+    exp(lgamma(x) + lgamma(y) - lgamma(x+y))
+  end
+
+end

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

@@ -0,0 +1,10 @@
+module Math
+
+  # Returns the Cumulative Density Function of this
+  # sample (normalised to a fraction of 1.0).
+  def self.cdf(array, normalised=1.0)
+    s = sum(array).to_f
+    array.sort.inject([0.0]) { |c,d| c << c[-1] + normalised*d.to_f/s }
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Smallest integer not smaller than +x+.
+  def self.ceil(x)
+    x.ceil
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Cotangens of +x+
+  def self.cot(x)
+    tan((PI * 0.5) - x)
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Cotangens hyperbolicus of +x+
+  def self.coth(x)
+    1.0 / tanh(x)
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Cosecans of +x+
+  def self.csc(x)
+    1.0 / sin(x)
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Cosecans hyperbolicus of +x+
+  def self.csch(x)
+    1.0 / sinh(x)
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Kronecker symbol of +i+ and +j+ - 1 if +i+ and +j+ are equal, 0 otherwise.
+  def self.delta(i, j)
+    return Integer(i) == Integer(j) ? 1 : 0
+  end
+
+end

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

@@ -0,0 +1,21 @@
+module Math
+
+  # Levi-Civita symbol of +i+, +j+, and +k+ - 1 if (+i+, +j+, +k+)
+  # is (1, 2, 3), (2, 3, 1), or (3, 1, 2), -1 if it is (1, 3, 2),
+  # (2, 1, 3), or (3, 2, 1), 0 as long as +i+, +j+, and +k+ are
+  # all elements of {1, 2, 3}, otherwise returns <code>nil</code>.
+  def self.epsilon(i, j, k)
+    i = Integer(i)
+    return nil if i < 1 or i > 3
+    j = Integer(j)
+    return nil if j < 1 or j > 3
+    k = Integer(k)
+    return nil if k < 1 or k > 3
+    case i * 16 + j * 4 + k
+      when 27, 45, 54 then return  1
+      when 30, 39, 57 then return -1
+    end
+    0
+  end
+
+end

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

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

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

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

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

@@ -0,0 +1,37 @@
+module Math
+
+  # First 16 factorials.
+  FACTORIALS = [
+    1,
+    1,
+    2,
+    6,
+    24,
+    120,
+    720,
+    5_040,
+    40_320,
+    362_880,
+    3_628_800,
+    39_916_800,
+    479_001_600,
+    6_227_020_800,
+    87_178_291_200,
+    1_307_674_368_000
+  ]
+
+  # 1 * 2 * ... * +n+, <code>nil</code> for negative numbers
+  def self.factorial(n)
+    n = Integer(n)
+    if n < 0
+      nil
+    elsif FACTORIALS.length > n
+      FACTORIALS[n]
+    else
+      h = FACTORIALS.last
+      (FACTORIALS.length .. n).each { |i| FACTORIALS.push h *= i }
+      h
+    end
+  end
+
+end

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

@@ -0,0 +1,8 @@
+module Math
+
+  # Largest integer not larger than +x+.
+  def self.floor(x)
+    x.floor
+  end
+
+end

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

@@ -0,0 +1,12 @@
+require 'facets/math/lgamma'
+
+module Math
+
+  unless defined?(gamma)
+    #
+    def self.gamma(x)
+      exp(lgamma(x))
+    end
+  end
+
+end

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

@@ -0,0 +1,23 @@
+module Math
+
+  # Greatest common divisor of +m+ and +n+, +nil+ for non-positive
+  # numbers - gcd is computed by means of the Euclidian algorithm.
+  def self.gcd(m, n)
+    m = Integer(m)
+    n = Integer(n)
+    if m <= 0 || n <= 0
+      return nil
+    end
+    loop {
+      if m < n
+        m, n = n, m
+      end
+      if (l = m % n) == 0
+        break
+      end
+      m = l
+    }
+    n
+  end
+
+end

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

@@ -0,0 +1,33 @@
+require 'facets/math/approx_equal'
+
+module Math
+
+  # Calculates the Gini Coefficient (a measure of inequality of a distribution
+  # based on the area between the Lorenz curve and the uniform curve).
+  #
+  # http://en.wikipedia.org/wiki/Gini_coefficient
+  #
+  # This is a slightly cleaner way of calculating the Gini Coefficient then
+  # the previous implementationj.
+  #
+  #   GC = \frac{\sum_{i=1}^N (2i-N-1)x_i}{N^2-\bar{x}}
+  #
+  def self.gini_coefficient(array)
+    return -1 if size <= 0 or any? { |x| x < 0 }
+    return 0 if size < 2 or all? { |x| approx_equal(x,0) }
+    s = 0
+    sort.each_with_index { |li,i| s += (2*i+1-size)*li }
+    s.to_f/(size**2*mean).to_f
+  end
+
+  ## OLD WAY
+  ##   GC = \frac{1}{N} \left ( N+1-2\frac{\sum_{i=1}^N (N+1-i)y_i}{\sum_{i=1}^N y_i} \right )
+  ## def self.gini_coefficient2(array)
+  ##   return -1 if size <= 0 or any? { |x| x < 0 }
+  ##   return 0 if size < 2 or all? { |x| Math::float_equal(x,0) }
+  ##   s = 0
+  ##   sort.each_with_index { |yi,i| s += (size - i)*yi }
+  ##   (size+1-2*(s.to_f/sum.to_f)).to_f/size.to_f
+  ## end
+
+end

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

@@ -0,0 +1,19 @@
+module Math
+
+  # The Kullback-Leibler divergence from this array to that of +q+.
+  #
+  # NB: You will possibly want to sort both P and Q before calling this
+  # depending on what you're actually trying to measure.
+  #
+  # http://en.wikipedia.org/wiki/Kullback-Leibler_divergence
+  #
+  def self.kldivergence(array, q)
+    fail "Buggy."
+    fail "Cannot compare differently sized arrays." unless size = q.size
+    kld = 0
+    each_with_index { |pi,i| kld += pi*Math::log(pi.to_f/q[i].to_f) }
+    kld
+  end
+
+end
+

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

@@ -0,0 +1,15 @@
+module Math
+
+  # Least common multiple of +m+ and +n+, computed by multiplying
+  # +m+ and +n+ and dividing the product by the gcd of +m+ and +n+,
+  # +nil+ for non-positive numbers.
+  def self.lcm(m, n)
+    m = Integer(m)
+    n = Integer(n)
+    if m <= 0 || n <= 0
+      return nil
+    end
+    m / gcd(m, n) * n
+  end
+
+end

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

@@ -0,0 +1,21 @@
+module Math
+
+  unless defined?(lgamma)
+
+    # Logarithmus naturalis of gamma function of +x+
+    def self.lgamma(x)
+      h  = x + 5.5
+      h -= (x + 0.5) * log(h)
+      sum  =  1.000_000_000_190_015
+      sum += 76.180_091_729_471_46	     / (x + 1.0)
+      sum -= 86.505_320_329_416_77	     / (x + 2.0)
+      sum += 24.014_098_240_830_91	     / (x + 3.0)
+      sum -=  1.231_739_572_450_155	     / (x + 4.0)
+      sum +=  0.120_865_097_386_617_9e-2 / (x + 5.0)
+      sum -=  0.539_523_938_495_3e-5     / (x + 6.0)
+      -h + log(2.506_628_274_631_000_5 * sum / x)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,10 @@
+module Math
+
+  # Returns real solution(s) of <code>+a+x + +b+ = +c+</code> or +nil+
+  # if no or an infinite number of solutions exist. If
+  # <code>c</code> is missing it is assumed to be 0.
+  def self.linsolve(a, b, c = 0.0)
+    a == 0 ? nil : (c - b) / a
+  end
+
+end