more_math 0.0.0

data/CHANGES

@@ -0,0 +1,2 @@
+2010-11-01 (0.0.0)
+  * Initial Version

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010 Florian Frank
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X
+CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,20 @@
+= MoreMath - More mathematics in Ruby
+
+== Description
+
+Ruby library that contains various mathematical functions and algorithms.
+
+== Download
+
+The homepage of this library is located at
+
+* http://flori.github.com/more_math
+
+== Author
+
+Florian Frank mailto:flori@ping.de
+
+== License
+
+This software is licensed under the X11 (or MIT) license:
+http://www.xfree86.org/3.3.6/COPYRIGHT2.html#3

data/Rakefile

@@ -0,0 +1,84 @@
+begin
+  require 'rake/gempackagetask'
+rescue LoadError
+end
+require 'rake/clean'
+require 'rbconfig'
+include Config
+
+PKG_NAME = 'more_math'
+PKG_VERSION = File.read('VERSION').chomp
+PKG_FILES = FileList['**/*'].exclude(/^(doc|CVS|pkg|coverage)/)
+CLEAN.include 'coverage', 'doc'
+CLOBBER.include FileList['data/*']
+
+desc "Run unit tests"
+task :test do
+  sh %{RUBYOPT="-Ilib $RUBYOPT" testrb tests/*.rb}
+end
+
+desc "Testing library with coverage"
+task :coverage do
+  sh 'rcov -x tests -Ilib tests/*.rb'
+end
+
+desc "Installing library"
+task :install  do
+  ruby 'install.rb'
+end
+
+desc "Creating documentation"
+task :doc do
+  ruby 'make_doc.rb'
+end
+
+if defined? Gem
+  spec = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.summary =  "Library that provides more mathematics."
+    s.description = "Library that provides more mathematical functions/algorithms than standard Ruby."
+    s.add_dependency('dslkit', '~> 0.2')
+
+    s.files = PKG_FILES
+
+    s.require_path = 'lib'
+
+    s.has_rdoc = true
+    s.rdoc_options <<
+      '--title' <<  'MoreMath -- More Math in Ruby' << '--main' << 'README'
+    s.extra_rdoc_files << 'README'
+    s.test_files = Dir['tests/*.rb']
+
+    s.author = "Florian Frank"
+    s.email = "flori@ping.de"
+    s.homepage = "http://flori.github.com/#{PKG_NAME}"
+    s.rubyforge_project = PKG_NAME
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+    pkg.package_files += PKG_FILES
+  end
+end
+
+desc m = "Writing version information for #{PKG_VERSION}"
+task :version do
+  puts m
+  File.open(File.join('lib', PKG_NAME, 'version.rb'), 'w') do |v|
+    v.puts <<EOT
+module MoreMath
+  # MoreMath version
+  VERSION         = '#{PKG_VERSION}'
+  VERSION_ARRAY   = VERSION.split(/\\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end
+EOT
+  end
+end
+
+task :default => [ :version, :test ]
+
+task :release => [ :clobber, :version, :package ]

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/install.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+require 'fileutils'
+include FileUtils::Verbose
+
+include Config
+
+file = 'lib/more_math.rb'
+libdir = CONFIG["sitelibdir"]
+install(file, libdir, :mode => 0755)
+mkdir_p subdir = File.join(libdir, 'more_math')
+for f in Dir['lib/more_math/*.rb']
+  install(f, subdir)
+end
+mkdir_p subdir = File.join(libdir, 'more_math', 'constants')
+for f in Dir['lib/more_math/constants/*.rb']
+  install(f, subdir)
+end

data/lib/more_math/cantor_pairing_funtion.rb

@@ -0,0 +1,49 @@
+require 'more_math'
+
+module MoreMath
+  module CantorPairingFunction
+
+    module_function
+  
+    def cantor_pairing(*xs)
+      if xs.size == 1 and xs.first.respond_to?(:to_ary)
+        xs = xs.first.to_ary
+      end
+      case xs.size
+      when 0, 1
+        raise ArgumentError, "at least two arguments are required"
+      when 2
+        x, y, = *xs
+        (x + y) * (x + y + 1) / 2 + y
+      else
+        cantor_pairing(cantor_pairing(*xs[0..1]), *xs[2..-1])
+      end
+    end
+
+    def self.cantor_pairing_inv_f(z)
+      z * (z + 1) / 2
+    end
+
+    def self.cantor_pairing_inv_q(z)
+      v = 0
+      while cantor_pairing_inv_f(v) <= z
+        v += 1
+      end
+      v - 1
+    end
+   
+    def cantor_pairing_inv(c, n = 2)
+      raise ArgumentError, "n is required to be >= 2" unless n >= 2
+      result = []
+      begin
+        q = CantorPairingFunction.cantor_pairing_inv_q(c)
+        y = c - CantorPairingFunction.cantor_pairing_inv_f(q)
+        x = q - y
+        result.unshift y
+        c = x
+        n -= 1
+      end until n <= 1
+      result.unshift x
+    end
+  end
+end

data/lib/more_math/constants/functions_constants.rb

@@ -0,0 +1,29 @@
+module MoreMath
+  module Constants
+    module FunctionsConstants
+      LANCZOS_COEFFICIENTS = [
+        0.99999999999999709182,
+        57.156235665862923517,
+        -59.597960355475491248,
+        14.136097974741747174,
+        -0.49191381609762019978,
+        0.33994649984811888699e-4,
+        0.46523628927048575665e-4,
+        -0.98374475304879564677e-4,
+        0.15808870322491248884e-3,
+        -0.21026444172410488319e-3,
+        0.21743961811521264320e-3,
+        -0.16431810653676389022e-3,
+        0.84418223983852743293e-4,
+        -0.26190838401581408670e-4,
+        0.36899182659531622704e-5,
+      ]
+
+      HALF_LOG_2_PI = 0.5 * Math.log(2 * Math::PI)
+
+      ERF_A = -8 * (Math::PI - 3) / (3 * Math::PI * (Math::PI - 4))
+
+      ROOT2 = Math.sqrt(2)
+    end
+  end
+end

data/lib/more_math/continued_fraction.rb

@@ -0,0 +1,140 @@
+require 'more_math'
+
+module MoreMath
+  # This class implements a continued fraction of the form:
+  #
+  #                            b_1
+  # a_0 + -------------------------
+  #                            b_2
+  #      a_1 + --------------------
+  #                            b_3
+  #           a_2 + ---------------
+  #                            b_4
+  #                a_3 + ----------
+  #                            b_5
+  #                     a_4 + -----
+  #                            ...
+  #
+  class ContinuedFraction
+    # Creates a continued fraction instance. With the defaults for_a { 1 } and
+    # for_b { 1 } it approximates the golden ration phi if evaluated.
+    def initialize
+      @a = proc { 1.0 }
+      @b = proc { 1.0 }
+    end
+
+    # Creates a ContinuedFraction instances and passes its arguments to a call
+    # to for_a.
+    def self.for_a(arg = nil, &block)
+      new.for_a(arg, &block)
+    end
+
+    # Creates a ContinuedFraction instances and passes its arguments to a call
+    # to for_b.
+    def self.for_b(arg = nil, &block)
+      new.for_b(arg, &block)
+    end
+
+    # This method either takes a block or an argument +arg+. The argument +arg+
+    # has to respond to an integer index n >= 0 and return the value a_n. The
+    # block has to return the value for a_n when +n+ is passed as the first
+    # argument to the block. If a_n is dependent on an +x+ value (see the call
+    # method) the +x+ will be the second argument of the block.
+    def for_a(arg = nil, &block)
+      if arg and !block
+        @a = arg
+      elsif block and !arg
+        @a = block
+      else
+        raise ArgumentError, "exactly one argument or one block required"
+      end
+      self
+    end
+
+    # This method either takes a block or an argument +arg+. The argument +arg+
+    # has to respond to an integer index n >= 1 and return the value b_n. The
+    # block has to return the value for b_n when +n+ is passed as the first
+    # argument to the block. If b_n is dependent on an +x+ value (see the call
+    # method) the +x+ will be the second argument of the block.
+    def for_b(arg = nil, &block)
+      if arg and !block
+        @b = arg
+      elsif block and !arg
+        @b = block
+      else
+        raise ArgumentError, "exactly one argument or one block required"
+      end
+      self
+    end
+
+    # Returns the value for a_n or a_n(x).
+    def a(n, x = nil)
+      result = if x
+        @a[n, x]
+      else
+        @a[n]
+      end and result.to_f
+    end
+
+    # Returns the value for b_n or b_n(x).
+    def b(n, x = nil)
+      result = if x
+        @b[n, x]
+      else
+        @b[n]
+      end and result.to_f
+    end
+
+    # Evaluates the continued fraction for the value +x+ (if any) with the
+    # accuracy +epsilon+ and +max_iterations+ as the maximum number of
+    # iterations using the Wallis-method with scaling.
+    def call(x = nil, epsilon = 1E-16, max_iterations = 1 << 31)
+      c_0, c_1 = 1.0, a(0, x)
+      c_1 == nil and return 0 / 0.0
+      d_0, d_1 = 0.0, 1.0
+      result = c_1 / d_1
+      n = 0
+      error = 1 / 0.0
+      $DEBUG and warn "n=%u, a=%f, b=nil, c=%f, d=%f result=%f, error=nil" %
+        [ n, c_1, c_1, d_1, result ]
+      while n < max_iterations and error > epsilon
+        n += 1
+        a_n, b_n = a(n, x), b(n, x)
+        a_n and b_n or break
+        c_2 = a_n * c_1 + b_n * c_0
+        d_2 = a_n * d_1 + b_n * d_0
+        if c_2.infinite? or d_2.infinite?
+          if a_n != 0
+            c_2 = c_1 + (b_n / a_n * c_0)
+            d_2 = d_1 + (b_n / a_n * d_0)
+          elsif b_n != 0
+            c_2 = (a_n / b_n * c_1) + c_0
+            d_2 = (a_n / b_n * d_1) + d_0
+          else
+            raise Errno::ERANGE
+          end
+        end
+        r = c_2 / d_2
+        error = (r / result - 1).abs
+
+        result = r
+
+        $DEBUG and warn "n=%u, a=%f, b=%f, c=%f, d=%f, result=%f, error=%.16f" %
+          [ n, a_n, b_n, c_1, d_1, result, error ]
+
+        c_0, c_1 = c_1, c_2
+        d_0, d_1 = d_1, d_2
+      end
+      n >= max_iterations and raise Errno::ERANGE
+      result
+    end
+
+    alias [] call
+
+    # Returns this continued fraction as a Proc object which takes the same
+    # arguments like its call method does.
+    def to_proc
+      proc { |*a| call(*a) }
+    end
+  end
+end

data/lib/more_math/distributions.rb

@@ -0,0 +1,134 @@
+require 'more_math'
+require 'more_math/functions'
+require 'more_math/constants/functions_constants'
+
+module MoreMath
+  # This class is used to compute the Normal Distribution.
+  class NormalDistribution
+    include Functions
+    include Constants::FunctionsConstants
+
+    # Creates a NormalDistribution instance for the values +mu+ and +sigma+.
+    def initialize(mu = 0.0, sigma = 1.0)
+      @mu, @sigma = mu.to_f, sigma.to_f
+    end
+
+    attr_reader :mu
+
+    attr_reader :sigma
+
+    # Returns the cumulative probability (p-value) of the NormalDistribution
+    # for the value +x+.
+    def probability(x)
+      0.5 * (1 + erf((x - @mu) / (@sigma * ROOT2)))
+    end
+
+    # Returns the inverse cumulative probability value of the
+    # NormalDistribution for the probability +p+.
+    def inverse_probability(p)
+      case
+      when p <= 0
+        -1 / 0.0
+      when p >= 1
+        1 / 0.0
+      when p == 0.5 # This is a bit sloppy, maybe improve this later.
+        @mu
+      else
+        begin
+          NewtonBisection.new { |x| probability(x) - p }.solve(nil, 1_000_000)
+        rescue
+          0 / 0.0
+        end
+      end
+    end
+  end
+
+  STD_NORMAL_DISTRIBUTION = NormalDistribution.new
+
+  # This class is used to compute the Chi-Square Distribution.
+  class ChiSquareDistribution
+    include Functions
+
+    # Creates a ChiSquareDistribution for +df+ degrees of freedom.
+    def initialize(df)
+      @df = df
+      @df_half = @df / 2.0
+    end
+
+    attr_reader :df
+
+    # Returns the cumulative probability (p-value) of the ChiSquareDistribution
+    # for the value +x+.
+    def probability(x)
+      if x < 0
+        0.0
+      else
+        gammaP_regularized(x / 2, @df_half)
+      end
+    end
+
+    # Returns the inverse cumulative probability value of the
+    # NormalDistribution for the probability +p+.
+    def inverse_probability(p)
+      case
+      when p <= 0, p >= 1
+        0.0
+      else
+        begin
+          bisect = NewtonBisection.new { |x| probability(x) - p }
+          range = bisect.bracket 0.5..10
+          bisect.solve(range, 1_000_000)
+        rescue
+          0 / 0.0
+        end
+      end
+    end
+  end
+
+  # This class is used to compute the T-Distribution.
+  class TDistribution
+    include Functions
+
+    # Returns a TDistribution instance for the degrees of freedom +df+.
+    def initialize(df)
+      @df = df
+    end
+
+    # Degrees of freedom.
+    attr_reader :df
+
+    # Returns the cumulative probability (p-value) of the TDistribution for the
+    # t-value +x+.
+    def probability(x)
+      if x == 0
+        0.5
+      else
+        t = beta_regularized(@df / (@df + x ** 2.0), 0.5 * @df, 0.5)
+        if x < 0.0
+          0.5 * t
+        else
+          1 - 0.5 * t
+        end
+      end
+    end
+   
+    # Returns the inverse cumulative probability (t-value) of the TDistribution
+    # for the probability +p+.
+    def inverse_probability(p)
+      case
+      when p <= 0
+        -1 / 0.0
+      when p >= 1
+        1 / 0.0
+      else 
+        begin
+          bisect = NewtonBisection.new { |x| probability(x) - p }
+          range = bisect.bracket(-10..10)
+          bisect.solve(range, 1_000_000)
+        rescue
+          0 / 0.0
+        end
+      end
+    end
+  end
+end

data/lib/more_math/exceptions.rb

@@ -0,0 +1,6 @@
+module MoreMath
+  module Exceptions
+    class MoreMathException < StandardError; end
+    class DivergentException < MoreMathException ; end
+  end
+end

data/lib/more_math/functions.rb

@@ -0,0 +1,151 @@
+require 'more_math'
+
+module MoreMath
+  module Functions
+    module_function
+
+    include Math
+    extend Math
+
+    # Returns the natural logarithm of Euler gamma function value for +x+ using
+    # the Lanczos approximation.
+    if Math.respond_to?(:lgamma)
+      def log_gamma(x)
+        lgamma(x).first
+      end
+    else
+      def log_gamma(x)
+        if x.nan? || x <= 0
+          0 / 0.0
+        else
+          sum = 0.0
+          lc = Constants::FunctionsConstants::LANCZOS_COEFFICIENTS
+          half_log_2_pi = Constants::FunctionsConstants::HALF_LOG_2_PI
+          (lc.size - 1).downto(1) do |i|
+            sum += lc[i] / (x + i)
+          end
+          sum += lc[0]
+          tmp = x + 607.0 / 128 + 0.5
+          (x + 0.5) * log(tmp) - tmp + half_log_2_pi + log(sum / x)
+        end
+      rescue Errno::ERANGE, Errno::EDOM
+        0 / 0.0
+      end
+    end
+
+    # Returns the natural logarithm of the beta function value for +(a, b)+.
+    def log_beta(a, b)
+      log_gamma(a) + log_gamma(b) - log_gamma(a + b)
+    rescue Errno::ERANGE, Errno::EDOM
+      0 / 0.0
+    end
+
+    # Return an approximation value of Euler's regularized beta function for
+    # +x+, +a+, and +b+ with an error <= +epsilon+, but only iterate
+    # +max_iterations+-times.
+    def beta_regularized(x, a, b, epsilon = 1E-16, max_iterations = 1 << 16)
+      x, a, b = x.to_f, a.to_f, b.to_f
+      case
+      when a.nan? || b.nan? || x.nan? || a <= 0 || b <= 0 || x < 0 || x > 1
+        0 / 0.0
+      when x > (a + 1) / (a + b + 2)
+        1 - beta_regularized(1 - x, b, a, epsilon, max_iterations)
+      else
+        fraction = ContinuedFraction.for_b do |n, x|
+          if n % 2 == 0
+            m = n / 2.0
+            (m * (b - m) * x) / ((a + (2 * m) - 1) * (a + (2 * m)))
+          else
+            m = (n - 1) / 2.0
+            -((a + m) * (a + b + m) * x) / ((a + 2 * m) * (a + 2 * m + 1))
+          end
+        end
+        exp(a * log(x) + b * log(1.0 - x) - log(a) - log_beta(a, b)) / 
+          fraction[x, epsilon, max_iterations]
+      end
+    rescue Errno::ERANGE, Errno::EDOM
+      0 / 0.0
+    end
+
+    # Return an approximation of the regularized gammaP function for +x+ and
+    # +a+ with an error of <= +epsilon+, but only iterate
+    # +max_iterations+-times.
+    def gammaP_regularized(x, a, epsilon = 1E-16, max_iterations = 1 << 16)
+      x, a = x.to_f, a.to_f
+      case
+      when a.nan? || x.nan? || a <= 0 || x < 0
+        0 / 0.0
+      when x == 0
+        0.0
+      when 1 <= a && a < x
+        1 - gammaQ_regularized(x, a, epsilon, max_iterations)
+      else
+        n = 0
+        an = 1 / a
+        sum = an
+        while an.abs > epsilon && n < max_iterations
+          n += 1
+          an *= x / (a + n)
+          sum += an
+        end
+        if n >= max_iterations
+          raise Errno::ERANGE
+        else
+          exp(-x + a * log(x) - log_gamma(a)) * sum
+        end
+      end
+    rescue Errno::ERANGE, Errno::EDOM
+      0 / 0.0
+    end
+
+    # Return an approximation of the regularized gammaQ function for +x+ and
+    # +a+ with an error of <= +epsilon+, but only iterate
+    # +max_iterations+-times.
+    def gammaQ_regularized(x, a, epsilon = 1E-16, max_iterations = 1 << 16)
+      x, a = x.to_f, a.to_f
+      case
+      when a.nan? || x.nan? || a <= 0 || x < 0
+        0 / 0.0
+      when x == 0
+        1.0
+      when a > x || a < 1
+        1 - gammaP_regularized(x, a, epsilon, max_iterations)
+      else
+        fraction = ContinuedFraction.for_a do |n, x|
+          (2 * n + 1) - a + x
+        end.for_b do |n, x|
+          n * (a - n)
+        end
+        exp(-x + a * log(x) - log_gamma(a)) *
+          fraction[x, epsilon, max_iterations] ** -1
+      end
+    rescue Errno::ERANGE, Errno::EDOM
+      0 / 0.0
+    end
+
+    unless Math.respond_to?(:erf)
+      # Returns an approximate value for the error function's value for +x+.
+      def erf(x)
+        erf_a = MoreMath::Constants::FunctionsConstants::ERF_A
+        r = sqrt(1 - exp(-x ** 2 * (4 / Math::PI + erf_a * x ** 2) / (1 + erf_a * x ** 2)))
+        x < 0 ? -r : r
+      end
+    else
+      def erf(x)
+        Math.erf(x)
+      end
+    end
+
+    # Returns Cantor's tuple function for the tuple +*xs+ (the size must be at
+    # least 2).
+    def cantor_pairing(*xs)
+      CantorPairingFunction.cantor_pairing(*xs)
+    end
+
+    # Returns the inverse of Cantor's tuple function for the value +c+. +n+ is
+    # the length of the tuple (defaults to 2, a pair).
+    def cantor_pairing_inv(c, n = 2)
+      CantorPairingFunction.cantor_pairing_inv(c, n)
+    end
+  end
+end