bullshit 0.1.1 → 0.1.2

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+Gemfile.lock
+.*.sw[pon]

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ruby-head
+  - ree
+  - rbx
+  - jruby

data/CHANGES

@@ -1,3 +1,6 @@
+2011-07-14 (0.1.2)
+  * Extract mathemacial computations into its own gem.
+  * Use gem_hadar to shorten Rakefile
 2009-10-17 (0.1.1)
   * Added the display of a speedup matrix in the comparison.
   * Added a bs_compare executble in order to compare data files.

data/Gemfile

@@ -0,0 +1,5 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source :rubygems
+
+gemspec

data/Rakefile

@@ -1,85 +1,33 @@
-begin
-  require 'rake/gempackagetask'
-rescue LoadError
-end
-require 'rake/clean'
-require 'rbconfig'
-include Config
-
-PKG_NAME = 'bullshit'
-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 = "Benchmarking is Bullshit"
-    s.description = ""
-
-    s.add_dependency('dslkit', '>= 0.2.5')
-
-    s.files = PKG_FILES
-
-    s.require_path = 'lib'
-    s.executables = 'bs_compare'
-
-    s.has_rdoc = true
-    s.rdoc_options <<
-      '--title' <<  'Bullshit -- Benchmarking in Ruby' << '--main' << '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
+# vim: set filetype=ruby et sw=2 ts=2:
+
+require 'gem_hadar'
+
+GemHadar do
+  name        'bullshit'
+  author      'Florian Frank'
+  email       'flori@ping.de'
+  homepage    "http://flori.github.com/#{name}"
+  summary     'Benchmarking is Bullshit'
+  description 'Library to benchmark ruby code and analyse the results'
+  test_dir    'tests'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock'
+  readme      'README.rdoc'
+  title       "#{name.camelize} -- Benchmarking in Ruby"
+  executables  << 'bs_compare'
+
+  dependency  'spruz', '~>0.2'
+  dependency  'dslkit', '~>0.2'
+  dependency  'more_math', '~>0.0.1'
+  clobber     'data/*.{dat,log}'
+
+  install_library do
+    libdir = CONFIG["sitelibdir"]
+    install('lib/bullshit.rb', libdir, :mode => 0644)
+    mkdir_p subdir = File.join(libdir, 'bullshit')
+    for f in Dir['lib/bullshit/*.rb']
+      install(f, subdir)
+    end
+    bindir = CONFIG["bindir"]
+    install('bin/bs_compare', bindir, :mode => 0755)
   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 Bullshit
-  # Bullshit 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

@@ -1 +1 @@
-0.1.1
+0.1.2

data/bullshit.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bullshit}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Florian Frank"]
+  s.date = %q{2011-07-17}
+  s.default_executable = %q{bs_compare}
+  s.description = %q{Library to benchmark ruby code and analyse the results}
+  s.email = %q{flori@ping.de}
+  s.executables = ["bs_compare"]
+  s.extra_rdoc_files = ["README.rdoc", "lib/bullshit/version.rb", "lib/bullshit.rb"]
+  s.files = [".gitignore", ".travis.yml", "CHANGES", "COPYING", "Gemfile", "README.rdoc", "Rakefile", "VERSION", "bin/bs_compare", "bullshit.gemspec", "data/.keep", "examples/compare.rb", "examples/fibonacci.rb", "examples/iteration.rb", "examples/josephus.rb", "examples/sorting.rb", "examples/throw_raise.rb", "lib/bullshit.rb", "lib/bullshit/version.rb", "tests/test_bullshit.rb", "tests/test_window.rb"]
+  s.homepage = %q{http://flori.github.com/bullshit}
+  s.rdoc_options = ["--title", "Bullshit -- Benchmarking in Ruby", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Benchmarking is Bullshit}
+  s.test_files = ["tests/test_bullshit.rb", "tests/test_window.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<gem_hadar>, ["~> 0.0.5"])
+      s.add_runtime_dependency(%q<spruz>, ["~> 0.2"])
+      s.add_runtime_dependency(%q<dslkit>, ["~> 0.2"])
+      s.add_runtime_dependency(%q<more_math>, ["~> 0.0.1"])
+    else
+      s.add_dependency(%q<gem_hadar>, ["~> 0.0.5"])
+      s.add_dependency(%q<spruz>, ["~> 0.2"])
+      s.add_dependency(%q<dslkit>, ["~> 0.2"])
+      s.add_dependency(%q<more_math>, ["~> 0.0.1"])
+    end
+  else
+    s.add_dependency(%q<gem_hadar>, ["~> 0.0.5"])
+    s.add_dependency(%q<spruz>, ["~> 0.2"])
+    s.add_dependency(%q<dslkit>, ["~> 0.2"])
+    s.add_dependency(%q<more_math>, ["~> 0.0.1"])
+  end
+end

data/lib/bullshit.rb

@@ -1,10 +1,8 @@
 require 'dslkit'
 require 'enumerator'
 
-begin
-  require 'bullshit/version'
-rescue LoadError
-end
+require 'bullshit/version'
+require 'more_math'
 
 # Module that includes all constants of the bullshit library.
 module Bullshit
@@ -12,147 +10,10 @@ module Bullshit
 
   NAME_COLUMN_SIZE = 5    # Number of columns used for row names.
 
-  Infinity = 1.0 / 0      # Refers to floating point infinity.
-
   RUBY_DESCRIPTION = "ruby %s (%s patchlevel %s) [%s]" %
     [ RUBY_VERSION, RUBY_RELEASE_DATE, RUBY_PATCHLEVEL, RUBY_PLATFORM ]
 
-  # 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
+  include MoreMath
 
   module ModuleFunctions
     module_function
@@ -203,6 +64,8 @@ module Bullshit
 
   # A Clock instance is used to take measurements while benchmarking.
   class Clock
+    include MoreMath
+
     TIMES = [ :real, :total, :user, :system ]
 
     ALL_COLUMNS = [ :scatter ] + TIMES + [ :repeat ]
@@ -314,12 +177,12 @@ module Bullshit
       self
     end
 
-    # Returns a Hash of Analysis object for all of TIMES's time keys.
+    # Returns a Hash of Sequence object for all of TIMES's time keys.
     def analysis
       @analysis ||= Hash.new do |h, time|
         time = time.to_sym
         times = @times[time]
-        h[time] = Analysis.new(times)
+        h[time] = MoreMath::Sequence.new(times)
       end
     end
 
@@ -342,7 +205,7 @@ module Bullshit
     def to_a
       if @repeat >= 1
         (::Bullshit::Clock::ALL_COLUMNS).map do |t|
-          analysis[t].measurements
+          analysis[t].elements
         end.transpose
       else
         []
@@ -530,7 +393,7 @@ module Bullshit
       truncation = self.case.truncate_data
       slope_angle = self.case.truncate_data.slope_angle.abs
       time = self.case.compare_time.to_sym
-      ms = analysis[time].measurements.reverse
+      ms = analysis[time].elements.reverse
       offset = ms.size - 1
       @slopes = []
       ModuleFunctions.array_window(ms, truncation.window_size) do |data|
@@ -544,802 +407,6 @@ module Bullshit
     end
   end
 
-  # A histogram gives an overview of measurement time values.
-  class Histogram
-    # Create a Histogram for +clock+ using the measurements for +time+.
-    def initialize(analysis, bins)
-      @analysis = analysis
-      @bins = bins
-      @result = compute
-    end
-
-    # Number of bins for this Histogram.
-    attr_reader :bins
-
-    # Return the computed histogram as an array of arrays.
-    def to_a
-      @result
-    end
-
-    # Display this histogram to +output+, +width+ is the parameter for
-    # +prepare_display+
-    def display(output = $stdout, width = 50)
-      d = prepare_display(width)
-      for l, bar, r in d
-        output << "%11.5f -|%s\n" % [ (l + r) / 2.0, "*" * bar ]
-      end
-      self
-    end
-
-    private
-
-    # Returns an array of tuples (l, c, r) where +l+ is the left bin edge, +c+
-    # the +width+-normalized frequence count value, and +r+ the right bin
-    # edge. +width+ is usually an integer number representing the width of a
-    # histogram bar.
-    def prepare_display(width)
-      r = @result.reverse
-      factor = width.to_f / (r.transpose[1].max)
-      r.map { |l, c, r| [ l, (c * factor).round, r ] }
-    end
-
-    # Computes the histogram and returns it as an array of tuples (l, c, r).
-    def compute
-      @analysis.measurements.empty? and return []
-      last_r = -Infinity
-      min = @analysis.min
-      max = @analysis.max
-      step = (max - min) / bins.to_f
-      Array.new(bins) do |i|
-        l = min + i  * step
-        r = min + (i + 1) * step
-        c = 0
-        @analysis.measurements.each do |x|
-          x > last_r and (x <= r || i == bins - 1) and c += 1
-        end
-        last_r = r
-        [ l, c, r ]
-      end
-    end
-  end
-
-  # This class is used to find the root of a function with Newton's bisection
-  # method.
-  class NewtonBisection
-    # Creates a NewtonBisection instance for +function+, a one-argument block.
-    def initialize(&function)
-      @function = function
-    end
-
-    # The function, passed into the constructor.
-    attr_reader :function
-
-    # Return a bracket around a root, starting from the initial +range+. The
-    # method returns nil, if no such bracket around a root could be found after
-    # +n+ tries with  the scaling +factor+.
-    def bracket(range = -1..1, n = 50, factor =  1.6)
-      x1, x2 = range.first.to_f, range.last.to_f
-      x1 >= x2 and raise ArgumentError, "bad initial range #{range}"
-      f1, f2 = @function[x1], @function[x2]
-      n.times do
-        f1 * f2 < 0 and return x1..x2
-        if f1.abs < f2.abs
-          f1 = @function[x1 += factor * (x1 - x2)]
-        else
-          f2 = @function[x2 += factor * (x2 - x1)]
-        end
-      end
-      return
-    end
-
-    # Find the root of function in +range+ and return it. The method raises a
-    # BullshitException, if no such root could be found after +n+ tries and in
-    # the +epsilon+ environment.
-    def solve(range = nil, n = 1 << 16, epsilon = 1E-16)
-      if range
-        x1, x2 = range.first.to_f, range.last.to_f
-        x1 >= x2 and raise ArgumentError, "bad initial range #{range}"
-      elsif range = bracket
-        x1, x2 = range.first, range.last
-      else
-        raise ArgumentError, "bracket could not be determined"
-      end
-      f = @function[x1]
-      fmid = @function[x2]
-      f * fmid >= 0 and raise ArgumentError, "root must be bracketed in #{range}"
-      root = if f < 0
-               dx = x2 - x1
-               x1
-             else
-               dx = x1 - x2
-               x2
-             end
-      n.times do
-        fmid = @function[xmid = root + (dx *= 0.5)]
-        fmid < 0 and root = xmid
-        dx.abs < epsilon or fmid == 0 and return root
-      end
-      raise BullshitException, "too many iterations (#{n})"
-    end
-  end
-
-  module Functions
-    module_function
-
-    include Math
-    extend Math
-
-    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 * log(2 * Math::PI)
-
-    # Returns the natural logarithm of Euler gamma function value for +x+ using
-    # the Lanczos approximation.
-    if method_defined?(: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
-          (LANCZOS_COEFFICIENTS.size - 1).downto(1) do |i|
-            sum += LANCZOS_COEFFICIENTS[i] / (x + i)
-          end
-          sum += LANCZOS_COEFFICIENTS[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
-
-    ROOT2 = sqrt(2)
-
-    A = -8 * (Math::PI - 3) / (3 * Math::PI * (Math::PI - 4))
-
-    # Returns an approximate value for the error function's value for +x+.
-    def erf(x)
-      r = sqrt(1 - exp(-x ** 2 * (4 / Math::PI + A * x ** 2) / (1 + A * x ** 2)))
-      x < 0 ? -r : r
-    end unless method_defined?(:erf)
-  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
-
-  # This class is used to compute the Normal Distribution.
-  class NormalDistribution
-    include Functions
-
-    # 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 computes a linear regression for the given image and domain data
-  # sets.
-  class LinearRegression
-    def initialize(image, domain = (0...image.size).to_a)
-      image.size != domain.size and raise ArgumentError,
-        "image and domain have unequal sizes"
-      @image, @domain = image, domain
-      compute
-    end
-
-    # The image data as an array.
-    attr_reader :image
-
-    # The domain data as an array.
-    attr_reader :domain
-
-    # The slope of the line.
-    attr_reader :a
-
-    # The offset of the line.
-    attr_reader :b
-
-    # Return true if the slope of the underlying data (not the sample data
-    # passed into the constructor of this LinearRegression instance) is likely
-    # (with alpha level _alpha_) to be zero.
-    def slope_zero?(alpha = 0.05)
-      df = @image.size - 2
-      return true if df <= 0 # not enough values to check
-      t = tvalue(alpha)
-      td = TDistribution.new df
-      t.abs <= td.inverse_probability(1 - alpha.abs / 2.0).abs
-    end
-
-    # Returns the residues of this linear regression in relation to the given
-    # domain and image.
-    def residues
-      result = []
-      @domain.zip(@image) do |x, y|
-        result << y - (@a * x + @b)
-      end
-      result
-    end
-
-    private
-
-    def compute
-      size = @image.size
-      sum_xx = sum_xy = sum_x = sum_y = 0.0
-      @domain.zip(@image) do |x, y|
-        x += 1
-        sum_xx += x ** 2
-        sum_xy += x * y
-        sum_x += x
-        sum_y += y
-      end
-      @a = (size * sum_xy - sum_x * sum_y) / (size * sum_xx - sum_x ** 2)
-      @b = (sum_y - @a * sum_x) / size
-      self
-    end
-
-    def tvalue(alpha = 0.05)
-      df = @image.size - 2
-      return 0.0 if df <= 0
-      sse_y = 0.0
-      @domain.zip(@image) do |x, y|
-        f_x = a * x + b
-        sse_y += (y - f_x) ** 2
-      end
-      mean = @image.inject(0.0) { |s, y| s + y } / @image.size
-      sse_x = @domain.inject(0.0) { |s, x| s + (x - mean) ** 2 }
-      t = a / (Math.sqrt(sse_y / df) / Math.sqrt(sse_x))
-      t.nan? ? 0.0 : t
-    end
-  end
-
-  # This class is used to analyse the time measurements and compute their
-  # statistics.
-  class Analysis
-    def initialize(measurements)
-      @measurements = measurements
-      @measurements.freeze
-    end
-
-    # Returns the array of measurements.
-    attr_reader :measurements
-
-    # Returns the number of measurements, on which the analysis is based.
-    def size
-      @measurements.size
-    end
-
-    # Returns the variance of the measurements.
-    def variance
-      @variance ||= sum_of_squares / size
-    end
-
-    # Returns the sample_variance of the measurements.
-    def sample_variance
-      @sample_variance ||= size > 1 ? sum_of_squares / (size - 1.0) : 0.0
-    end
-
-    # Returns the sum of squares (the sum of the squared deviations) of the
-    # measurements.
-    def sum_of_squares
-      @sum_of_squares ||= @measurements.inject(0.0) { |s, t| s + (t - arithmetic_mean) ** 2 }
-    end
-
-    # Returns the standard deviation of the measurements.
-    def standard_deviation
-      @sample_deviation ||= Math.sqrt(variance)
-    end
-
-    # Returns the standard deviation of the measurements in percentage of the
-    # arithmetic mean.
-    def standard_deviation_percentage
-      @standard_deviation_percentage ||= 100.0 * standard_deviation / arithmetic_mean
-    end
-
-    # Returns the sample standard deviation of the measurements.
-    def sample_standard_deviation
-      @sample_standard_deviation ||= Math.sqrt(sample_variance)
-    end
-
-    # Returns the sample standard deviation of the measurements in percentage
-    # of the arithmetic mean.
-    def sample_standard_deviation_percentage
-      @sample_standard_deviation_percentage ||= 100.0 * sample_standard_deviation / arithmetic_mean
-    end
-
-    # Returns the sum of all measurements.
-    def sum
-      @sum ||= @measurements.inject(0.0) { |s, t| s + t }
-    end
-
-    # Returns the arithmetic mean of the measurements.
-    def arithmetic_mean
-      @arithmetic_mean ||= sum / size
-    end
-
-    alias mean arithmetic_mean
-
-    # Returns the harmonic mean of the measurements. If any of the measurements
-    # is less than or equal to 0.0, this method returns NaN.
-    def harmonic_mean
-      @harmonic_mean ||= (
-        sum = @measurements.inject(0.0) { |s, t|
-          if t > 0
-            s + 1.0 / t
-          else
-            break nil
-          end
-        }
-        sum ? size / sum : 0 / 0.0
-      )
-    end
-
-    # Returns the geometric mean of the measurements. If any of the
-    # measurements is less than 0.0, this method returns NaN.
-    def geometric_mean
-      @geometric_mean ||= (
-        sum = @measurements.inject(0.0) { |s, t|
-          case
-          when t > 0
-            s + Math.log(t)
-          when t == 0
-            break :null
-          else
-            break nil
-          end
-        }
-        case sum
-        when :null
-          0.0
-        when Float
-          Math.exp(sum / size)
-        else
-          0 / 0.0
-        end
-      )
-    end
-
-    # Returns the minimum of the measurements.
-    def min
-      @min ||= @measurements.min
-    end
-
-    # Returns the maximum of the measurements.
-    def max
-      @max ||= @measurements.max
-    end
-
-    # Returns the +p+-percentile of the measurements.
-    # There are many methods to compute the percentile, this method uses the
-    # the weighted average at x_(n + 1)p, which allows p to be in 0...100
-    # (excluding the 100).
-    def percentile(p = 50)
-      (0...100).include?(p) or
-        raise ArgumentError, "p = #{p}, but has to be in (0...100)"
-      p /= 100.0
-      @sorted ||= @measurements.sort
-      r = p * (@sorted.size + 1)
-      r_i = r.to_i
-      r_f = r - r_i
-      if r_i >= 1
-        result = @sorted[r_i - 1]
-        if r_i < @sorted.size
-          result += r_f * (@sorted[r_i] - @sorted[r_i - 1])
-        end
-      else
-        result = @sorted[0]
-      end
-      result
-    end
-
-    alias median percentile
-
-    # Use an approximation of the Welch-Satterthwaite equation to compute the
-    # degrees of freedom for Welch's t-test.
-    def compute_welch_df(other)
-      (sample_variance / size + other.sample_variance / other.size) ** 2 / (
-        (sample_variance ** 2 / (size ** 2 * (size - 1))) +
-        (other.sample_variance ** 2 / (other.size ** 2 * (other.size - 1))))
-    end
-
-    # Returns the t value of the Welch's t-test between this Analysis
-    # instance and the +other+.
-    def t_welch(other)
-      signal = arithmetic_mean - other.arithmetic_mean
-      noise = Math.sqrt(sample_variance / size +
-        other.sample_variance / other.size)
-      signal / noise
-    rescue Errno::EDOM
-      0.0
-    end
-
-    # Returns an estimation of the common standard deviation of the
-    # measurements of this and +other+.
-    def common_standard_deviation(other)
-      Math.sqrt(common_variance(other))
-    end
-
-    # Returns an estimation of the common variance of the measurements of this
-    # and +other+.
-    def common_variance(other)
-      (size - 1) * sample_variance + (other.size - 1) * other.sample_variance /
-        (size + other.size - 2)
-    end
-
-    # Compute the # degrees of freedom for Student's t-test.
-    def compute_student_df(other)
-      size + other.size - 2
-    end
-
-    # Returns the t value of the Student's t-test between this Analysis
-    # instance and the +other+.
-    def t_student(other)
-      signal = arithmetic_mean - other.arithmetic_mean
-      noise = common_standard_deviation(other) *
-        Math.sqrt(size ** -1 + size ** -1)
-    rescue Errno::EDOM
-      0.0
-    end
-
-    # Compute a sample size, that will more likely yield a mean difference
-    # between this instance's measurements and those of +other+. Use +alpha+
-    # and +beta+ as levels for the first- and second-order errors.
-    def suggested_sample_size(other, alpha = 0.05, beta = 0.05)
-      alpha, beta = alpha.abs, beta.abs
-      signal = arithmetic_mean - other.arithmetic_mean
-      df = size + other.size - 2
-      pooled_variance_estimate = (sum_of_squares + other.sum_of_squares) / df
-      td = TDistribution.new df
-      (((td.inverse_probability(alpha) + td.inverse_probability(beta)) *
-        Math.sqrt(pooled_variance_estimate)) / signal) ** 2
-    end
-
-    # Return true, if the Analysis instance covers the +other+, that is their
-    # arithmetic mean value is most likely to be equal for the +alpha+ error
-    # level.
-    def cover?(other, alpha = 0.05)
-      t = t_welch(other)
-      td = TDistribution.new(compute_welch_df(other))
-      t.abs < td.inverse_probability(1 - alpha.abs / 2.0)
-    end
-
-    # Return the confidence interval for the arithmetic mean with alpha level +alpha+ of
-    # the measurements of this Analysis instance as a Range object.
-    def confidence_interval(alpha = 0.05)
-      td = TDistribution.new(size - 1)
-      t = td.inverse_probability(alpha / 2).abs
-      delta = t * sample_standard_deviation / Math.sqrt(size)
-      (arithmetic_mean - delta)..(arithmetic_mean + delta)
-    end
-
-    # Returns the array of autovariances (of length size - 1).
-    def autovariance
-      Array.new(size - 1) do |k|
-        s = 0.0
-        0.upto(size - k - 1) do |i|
-          s += (@measurements[i] - arithmetic_mean) * (@measurements[i + k] - arithmetic_mean)
-        end
-        s / size
-      end
-    end
-
-    # Returns the array of autocorrelation values c_k / c_0 (of length size -
-    # 1).
-    def autocorrelation
-      c = autovariance
-      Array.new(c.size) { |k| c[k] / c[0] }
-    end
-
-    # Returns the d-value for the Durbin-Watson statistic. The value is d << 2
-    # for positive, d >> 2 for negative and d around 2 for no autocorrelation.
-    def durbin_watson_statistic
-      e = linear_regression.residues
-      e.size <= 1 and return 2.0
-      (1...e.size).inject(0.0) { |s, i| s + (e[i] - e[i - 1]) ** 2 } /
-        e.inject(0.0) { |s, x| s + x ** 2 }
-    end
-
-    # Returns the q value of the Ljung-Box statistic for the number of lags
-    # +lags+. A higher value might indicate autocorrelation in the measurements of
-    # this Analysis instance. This method returns nil if there weren't enough
-    # (at least lags) lags available.
-    def ljung_box_statistic(lags = 20)
-      r = autocorrelation
-      lags >= r.size and return
-      n = size
-      n * (n + 2) * (1..lags).inject(0.0) { |s, i| s + r[i] ** 2 / (n - i) }
-    end
-
-    # This method tries to detect autocorrelation with the Ljung-Box
-    # statistic. If enough lags can be considered it returns a hash with
-    # results, otherwise nil is returned. The keys are
-    # :lags:: the number of lags,
-    # :alpha_level:: the alpha level for the test,
-    # :q:: the value of the ljung_box_statistic,
-    # :p:: the p-value computed, if p is higher than alpha no correlation was detected,
-    # :detected:: true if a correlation was found.
-    def detect_autocorrelation(lags = 20, alpha_level = 0.05)
-      if q = ljung_box_statistic(lags)
-        p = ChiSquareDistribution.new(lags).probability(q)
-        return {
-          :lags         => lags,
-          :alpha_level  => alpha_level,
-          :q            => q,
-          :p            => p,
-          :detected     => p >= 1 - alpha_level,
-        }
-      end
-    end
-
-    # Return a result hash with the number of :very_low, :low, :high, and
-    # :very_high outliers, determined by the box plotting algorithm run with
-    # :median and :iqr parameters. If no outliers were found or the iqr is
-    # less than epsilon, nil is returned.
-    def detect_outliers(factor = 3.0, epsilon = 1E-5)
-      half_factor = factor / 2.0
-      quartile1 = percentile(25)
-      quartile3 = percentile(75)
-      iqr = quartile3 - quartile1
-      iqr < epsilon and return
-      result = @measurements.inject(Hash.new(0)) do |h, t|
-        extreme =
-          case t
-          when -Infinity..(quartile1 - factor * iqr)
-            :very_low
-          when (quartile1 - factor * iqr)..(quartile1 - half_factor * iqr)
-            :low
-          when (quartile1 + half_factor * iqr)..(quartile3 + factor * iqr)
-            :high
-          when (quartile3 + factor * iqr)..Infinity
-            :very_high
-          end and h[extreme] += 1
-        h
-      end
-      unless result.empty?
-        result[:median] = median
-        result[:iqr] = iqr
-        result[:factor] = factor
-        result
-      end
-    end
-
-    # Returns the LinearRegression object for the equation a * x + b which
-    # represents the line computed by the linear regression algorithm.
-    def linear_regression
-      @linear_regression ||= LinearRegression.new @measurements
-    end
-
-    # Returns a Histogram instance with +bins+ as the number of bins for this
-    # analysis' measurements.
-    def histogram(bins)
-      Histogram.new(self, bins)
-    end
-  end
-
   CaseMethod = Struct.new(:name, :case, :clock)
 
   # This class' instance represents a method to be benchmarked.