bullshit 0.1.1 → 0.1.2

data/tests/test_continued_fraction.rb

@@ -1,40 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'bullshit'
-
-class TestContinuedFraction < Test::Unit::TestCase
-  include Bullshit
-
-  def setup
-    @none1 = ContinuedFraction.for_a proc {}
-    @none2 = ContinuedFraction.for_a {}
-    @phi = ContinuedFraction.new
-    @finite = ContinuedFraction.for_a [3, 4, 12, 3, 1]
-    @sqrt_2 = ContinuedFraction.for_a { |n| n == 0 ? 1 : 2 }
-    @pi_finite = ContinuedFraction.for_a [3, 7, 15, 1, 292, 1, 1, 1, 2]
-    @e = ContinuedFraction.for_a { |n| (n + 1) }.for_b { |n| (n + 1) }
-    @a113011 = ContinuedFraction.for_a { |n| 2 * n + 1 }.for_b { |n| 2 * n }
-    @a073333 = ContinuedFraction.for_a { |n| n }.for_b { |n| n }
-    @atan = ContinuedFraction.for_a do |n, x|
-      n == 0 ? 0 : 2 * n - 1
-    end.for_b do |n, x|
-      n <= 1 ? x : ((n - 1) * x) ** 2
-    end
-    @pi = lambda { 4 * @atan[1] }
-  end
-
-  def test_continued_fractions
-    assert @none1[1].nan?
-    assert @none2[1].nan?
-    assert_in_delta 1.618033, @phi[], 1E-6
-    assert_in_delta 3.245, @finite[], 1E-4
-    assert_in_delta Math.sqrt(2), @sqrt_2[], 1E-10
-    assert_in_delta Math::PI, @pi_finite[], 1E-10
-    assert_in_delta Math::E, 1 + @e[], 1E-10
-    assert_in_delta 1.541494, @a113011[], 1E-6
-    assert_in_delta 0.581976, @a073333[], 1E-6
-    assert_in_delta Math.atan(0.5), @atan[0.5], 1E-10
-    assert_in_delta Math::PI, @pi[], 1E-10
-  end
-end

data/tests/test_distribution.rb

@@ -1,69 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'bullshit'
-
-class TestDistribution < Test::Unit::TestCase
-  include Bullshit
-
-  def setup
-    @td23 = TDistribution.new 23
-    @td100 = TDistribution.new 100
-    @chi23 = ChiSquareDistribution.new 23
-    @chi100 = ChiSquareDistribution.new 100
-  end
-
-  def test_tdistribution
-    xs = [ 75, 80, 85, 90, 95, 97.5, 99, 99.5, 99.75, 99.9, 99.95 ].map { |x|
-      x / 100.0 }
-    ys = [ 0.685, 0.858, 1.060, 1.319, 1.714, 2.069, 2.500, 2.807, 3.104,
-      3.485, 3.767 ]
-    xs.zip(ys) do |x, y|
-      assert_in_delta y, @td23.inverse_probability(x), 1E-2
-    end
-    assert_equal @td23.inverse_probability(-0.1), -1 / 0.0
-    assert_equal @td23.inverse_probability(1.1), 1 / 0.0
-    ys = [ 0.677, 0.845, 1.042, 1.290, 1.660, 1.984, 2.364, 2.626, 2.871,
-      3.174, 3.390 ]
-    xs.zip(ys) do |x, y|
-      assert_in_delta y, @td100.inverse_probability(x), 1E-2
-    end
-    assert_equal @td100.inverse_probability(-0.1), -1 / 0.0
-    assert_equal @td100.inverse_probability(1.1), 1 / 0.0
-  end
-
-  def test_standard_normal_distribution
-    std = STD_NORMAL_DISTRIBUTION
-    ps = [ 0.001, 0.005, 0.010, 0.025, 0.050, 0.100 ]
-    zs = [ -3.090, -2.576, -2.326, -1.960, -1.645, -1.282 ]
-    ps.zip(zs) do |p, z|
-      assert_in_delta z, std.inverse_probability(p), 1E-2
-    end
-    assert_equal std.inverse_probability(-0.1), -1 / 0.0
-    assert_equal std.inverse_probability(1.1), 1 / 0.0
-    ps.zip(zs) do |p, z|
-      assert_in_delta(-z, std.inverse_probability(1 - p), 1E-2)
-    end
-  end
-
-  def test_chisquaredistribution
-    xs = [ 0.0, 1, 9.260, 11.689, 28.429, 32.007, 35.172, 38.076, 38.968, 41.638,
-      44.181, 47.391, 49.728 ]
-    ys = [ 0.0, 1.593887e-12, 0.004998304, 0.025006129, 0.800007427, 0.900002084, 0.949994698,
-      0.975002306, 0.979998428, 0.989998939, 0.994999617, 0.997999729,
-      0.998999930 ]
-    xs.zip(ys) do |x, y|
-      assert_in_delta y, @chi23.probability(x), 1E-6
-      assert_in_delta x, @chi23.inverse_probability(y), 1E-6
-    end
-    assert_in_delta @chi23.probability(-0.1), 0.0, 1E-6
-    ys = [ 0.0, 1.788777e-80, 6.705663e-34, 2.337654e-29, 1.321036e-13, 8.695875e-12,
-      2.085529e-10, 2.691731e-09, 5.559949e-09, 4.192445e-08, 2.373762e-07,
-      1.678744e-06, 6.034997e-06 ]
-    xs.zip(ys) do |x, y|
-      assert_in_delta y, @chi100.probability(x), 1E-6
-      assert_in_delta x, @chi100.inverse_probability(y), 1E-6
-    end
-    assert_in_delta @chi100.probability(-0.1), 0.0, 1E-6
-  end
-end

data/tests/test_functions.rb

@@ -1,33 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'bullshit'
-
-class TestFunctions < Test::Unit::TestCase
-  include Bullshit::Functions
-
-  def gammaP5_2(x)
-    gammaP_regularized(x, 5 / 2.0)
-  end
-
-  def gammaQ5_2(x)
-    gammaQ_regularized(x, 5 / 2.0)
-  end
-
-  X1 = [ 0.0, 0.1, 0.5, 0.9, 0.95, 0.995, 1.0, 2, 3, 5, 10, 100 ]
-
-  Y1 = [ 0.0000000000, 0.0008861388, 0.0374342268, 0.1239315997, 0.1371982774,
-    0.1494730091, 0.1508549639, 0.4505840486, 0.6937810816, 0.9247647539,
-    0.9987502694, 1.0000000000 ]
-
-  def test_gammaPQ
-    assert gammaQ_regularized(1, -1).nan?
-    assert gammaP_regularized(1, -1).nan?
-    assert gammaP5_2(-1).nan?
-    assert gammaQ5_2(-1).nan?
-    X1.zip(Y1) do |x, y|
-      assert_in_delta y, gammaP5_2(x), 1E-10
-      assert_in_delta y, 1 - gammaQ5_2(x), 1E-10
-    end
-  end
-end

data/tests/test_newton_bisection.rb

@@ -1,28 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'test/unit'
-require 'bullshit'
-
-class TestNewtonBisection < Test::Unit::TestCase
-  include Bullshit
-
-  def test_bracket
-    solver = NewtonBisection.new { |x| x ** 2 - 3 }
-    assert_raises(ArgumentError) { solver.bracket(1..1) }
-    assert_raises(ArgumentError) { solver.bracket(1..-1) }
-    range = solver.bracket(0..0.1)
-    assert_in_delta range.first, 0, 1E-6
-    assert_in_delta range.last, 1.7576, 1E-6
-    range = solver.bracket(2..3)
-    assert_in_delta range.first, 0.4, 1E-6
-    assert_in_delta range.last, 3, 1E-6
-  end
-
-  def test_zero
-    solver = NewtonBisection.new { |x| x ** 2 - 3 }
-    assert_in_delta 1.73205, solver.solve, 1E-6
-    assert_in_delta(-1.73205, solver.solve(-5..-1), 1E-6)
-    assert_in_delta 1.73205, solver.solve(solver.bracket(0..0.1)), 1E-6
-    assert_in_delta 1.73205, solver.solve(solver.bracket(2..3)), 1E-6
-  end
-end