rb-gsl 1.15.3.1 → 1.15.3.2

data/test/gsl/randist_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+
+class RandistTest < GSL::TestCase
+
+  N = 100000
+  MULTI_DIM = 10
+
+  BINS = 100
+  STEPS = 100
+
+  R_GLOBAL = GSL::Rng.alloc
+
+  def test_shuffle
+    n = 10
+
+    count = GSL::Matrix.calloc(n, n)
+    x = GSL::Permutation.alloc(n)
+
+    N.times { |i|
+      n.times { |j| x[j] = j }
+      GSL::Ran.shuffle(R_GLOBAL, x)
+      n.times { |j| count.set(x[j], j, count[x[j], j] + 1) }
+    }
+
+    expected = N / 10.0
+
+    n.times { |i|
+      n.times { |j|
+        d = (count[i, j] - expected).abs
+
+        refute d > 1 && d / Math.sqrt(expected) > 5,
+          "gsl_ran_shuffle #{i},#{j} (#{count[i, j] / N} observed vs 0.1 expected)"
+      }
+    }
+  end
+
+  def _test_moments(name, arg, a, b, pp)
+    count, expected = 0, pp * N
+
+    N.times {
+      r = R_GLOBAL.send(*[name, arg].compact)
+      count += 1 if r < b && r > a
+    }
+
+    refute((count - expected).abs / Math.sqrt(expected) > 3,
+      "#{name}(#{arg}) [#{a},#{b}] (#{count.to_f / N} observed vs #{pp} expected)")
+  end
+
+  def _test_pdf(name, *args)
+    pdf = "#{name}_pdf"
+
+    a, b = -5.0, 5.0
+    dx = (b - a) / BINS
+
+    status = status_i = 0
+
+    count = GSL::Vector.calloc(BINS)
+    pp = GSL::Vector.calloc(BINS)
+
+    N.times { |i|
+      r = R_GLOBAL.send(name, *args)
+
+      if r < b && r > a
+        j = ((r - a) / dx).to_i
+        count[j] = count[j] + 1
+      end
+    }
+
+    BINS.times { |i|
+      x = a + i * dx
+      x = 0.0 if x.abs < 1e-10
+
+      sum = 0.0
+
+      STEPS.times { |j| sum += GSL::Ran.send(pdf, x + j * dx / STEPS, *args) }
+
+      pp[i] = 0.5 * (GSL::Ran.send(pdf, x, *args) + 2 * sum + GSL::Ran.send(pdf, x + dx - 1e-7, *args)) * dx / STEPS
+    }
+
+    BINS.times { |i|
+      x = a + i * dx
+      d = count[i] - N * pp[i]
+
+      status_i = (pp[i] == 0 ? count[i] != 0 : d < 1 && d / Math.sqrt(N * pp[i]) > 5) ? 1 : 0
+      status |= status_i
+
+      refute status_i == 1,
+        "#{name} [#{x},#{x + dx}) (#{count[i]}/#{N}=#{count.to_f / N} observed vs #{pp[i]} expected)"
+    }
+
+    assert status.zero?, "#{name}, sampling against pdf over range [#{a},#{b})"
+  end
+
+  def test_randist
+    _test_moments(:ugaussian,      nil,  0.0,   100.0, 0.5)
+    _test_moments(:ugaussian,      nil, -1.0,     1.0, 0.6826895)
+    _test_moments(:ugaussian,      nil,  3.0,     3.5, 0.0011172689)
+    _test_moments(:ugaussian_tail, 3.0,  3.0,     3.5, 0.0011172689 / 0.0013498981)
+    _test_moments(:exponential,    2.0,  0.0,     1.0, 1 - Math.exp(-0.5))
+    _test_moments(:cauchy,         2.0,  0.0, 10000.0, 0.5)
+
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(GSL::Vector.alloc(0.59, 0.4, 0.01)), -0.5, 0.5, 0.59)
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(GSL::Vector.alloc(0.59, 0.4, 0.01)),  0.5, 1.5, 0.40)
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(GSL::Vector.alloc(0.59, 0.4, 0.01)),  1.5, 3.5, 0.01)
+
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(GSL::Vector.alloc(1, 9, 3, 4, 5, 8, 6, 7, 2, 0)), -0.5,  0.5, 1.0 / 45.0)
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(GSL::Vector.alloc(1, 9, 3, 4, 5, 8, 6, 7, 2, 0)),  8.5,  9.5, 0)
+
+    _test_pdf(:beta,   2.0, 3.0)
+    _test_pdf(:cauchy, 2.0)
+    _test_pdf(:chisq,  2.0)
+
+    _test_pdf(:exponential,    2.0)
+    _test_pdf(:exppow,         3.7, 0.3)
+    _test_pdf(:fdist,          3.0, 4.0)
+    _test_pdf(:flat,           3.0, 4.0)
+    _test_pdf(:gamma,          2.5, 2.17)
+    _test_pdf(:gaussian,       3.0)
+    _test_pdf(:ugaussian_tail, 0.1, 2.0)
+  end
+
+end

data/test/gsl/rng_test.rb

@@ -0,0 +1,303 @@
+require 'test_helper'
+
+class RngTest < GSL::TestCase
+
+  N = 1000
+  N2 = 20000
+
+  BINS = 17
+  EXTRA = 10
+
+  {
+    'rand'       => [[1, 10000, 1910041713]],
+    'randu'      => [[1, 10000, 1623524161]],
+    'cmrg'       => [[1, 10000, 719452880]],
+    'minstd'     => [[1, 10000, 1043618065]],
+    'mrg'        => [[1, 10000, 2064828650]],
+    'taus'       => [[1, 10000, 2733957125]],
+    'taus113'    => [[1, 1000, 1925420673]],
+    'transputer' => [[1, 10000, 1244127297]],
+    'vax'        => [[1, 10000, 3051034865]],
+
+    'borosh13'  => [[1, 10000, 2513433025]],
+    'fishman18' => [[1, 10000, 330402013]],
+    'fishman2x' => [[1, 10000, 540133597]],
+    'knuthran2' => [[1, 10000, 1084477620]],
+    'knuthran'  => [[310952, 1009 * 2009 + 1, 461390032]],
+    'lecuyer21' => [[1, 10000, 2006618587]],
+
+    'waterman14' => [[1, 10000, 3776680385]],
+    'coveyou'    => [[6, 10000, 1416754246]],
+    'fishman20'  => [[6, 10000, 248127575]],
+    'ranlux'     => [[314159265, 10000, 12077992]],
+    'ranlux389'  => [[314159265, 10000, 165942]],
+    'ranlxs0'    => [[1, 10000, 11904320]],
+
+    'ranlxs1' => [[1, 10000, 8734328]],
+    'ranlxs2' => [[1, 10000, 6843140]],
+    'ranlxd1' => [[1, 10000, 1998227290]],
+    'ranlxd2' => [[1, 10000, 3949287736]],
+    'slatec'  => [[1, 10000, 45776]],
+    'uni'     => [[1, 10000, 9214]],
+    'uni32'   => [[1, 10000, 1155229825]],
+    'zuf'     => [[1, 10000, 3970]],
+
+    'r250'         => [[1, 10000, 1100653588]],
+    'mt19937'      => [[4357, 1000, 1186927261]],
+    'mt19937_1999' => [[4357, 1000, 1030650439]],
+    'mt19937_1998' => [[4357, 1000, 1309179303]],
+    'tt800'        => [[0, 10000, 2856609219]],
+
+    'ran0' => [[0, 10000, 1115320064]],
+    'ran1' => [[0, 10000, 1491066076]],
+    'ran2' => [[0, 10000, 1701364455]],
+    'ran3' => [[0, 10000, 186340785]],
+
+    'ranmar' => [[1, 10000, 14428370]],
+
+    'rand48' => [[0, 10000, 0xDE095043],
+                 [1, 10000, 0xEDA54977]],
+
+    'random_glibc2'    => [[0, 10000, 1908609430]],
+    'random8_glibc2'   => [[0, 10000, 1910041713]],
+    'random32_glibc2'  => [[0, 10000, 1587395585]],
+    'random64_glibc2'  => [[0, 10000, 52848624]],
+    'random128_glibc2' => [[0, 10000, 1908609430]],
+    'random256_glibc2' => [[0, 10000, 179943260]],
+
+    'random_bsd'    => [[0, 10000, 1457025928]],
+    'random8_bsd'   => [[0, 10000, 1910041713]],
+    'random32_bsd'  => [[0, 10000, 1663114331]],
+    'random64_bsd'  => [[0, 10000, 864469165]],
+    'random128_bsd' => [[0, 10000, 1457025928]],
+    'random256_bsd' => [[0, 10000, 1216357476]],
+
+    'random_libc5'    => [[0, 10000, 428084942]],
+    'random8_libc5'   => [[0, 10000, 1910041713]],
+    'random32_libc5'  => [[0, 10000, 1967452027]],
+    'random64_libc5'  => [[0, 10000, 2106639801]],
+    'random128_libc5' => [[0, 10000, 428084942]],
+    'random256_libc5' => [[0, 10000, 116367984]],
+
+    'ranf' => [[0, 10000, 2152890433],
+               [2, 10000, 339327233]]
+  }.each { |type, args|
+    args.each_with_index { |(seed, n, result), i|
+      define_method("test_#{type}_#{i}") {
+        r, k = GSL::Rng.alloc(type), nil
+        r.set(seed) if seed != 0
+
+        n.times { k = r.get }
+
+        assert k == result, "#{r.name}, #{n} steps (#{k} observed vs #{result} expected)"
+      }
+    }
+  }
+
+  GSL::Rng.types.each { |type|
+    define_method("test_float_#{type}")          { _rng_float_test(type) }
+    define_method("test_state_#{type}")          { _rng_state_test(type) }
+    define_method("test_parallel_state_#{type}") { _rng_parallel_state_test(type) }
+    define_method("test_read_write_#{type}")     { _rng_read_write_test(type) }
+    define_method("test_generic_#{type}")        { _generic_rng_test(type) }
+  }
+
+  def _rng_float_test(type)
+    ri = GSL::Rng.alloc(type)
+    rf = GSL::Rng.alloc(type)
+
+    status = k = 0
+
+    begin
+      k = ri.get
+      u = rf.get
+    end while k == 0
+
+    c = k / u
+
+    N2.times {
+      k = ri.get
+      u = rf.get
+
+      if c * k != u
+        status = 1
+        break
+      end
+    }
+
+    assert status.zero?, "#{ri.name}, ratio of int to double (#{c} observed vs #{k/u} expected)"
+  end
+
+  def _rng_state_test(type)
+    r = GSL::Rng.alloc(type)
+    r_save = GSL::Rng.alloc(type)
+
+    N.times { r.get }
+
+    GSL::Rng.memcpy(r_save, r)
+
+    test_a = GSL::Vector.alloc(N)
+    test_b = GSL::Vector.alloc(N)
+
+    N.times { |i| test_a[i] = r.get }
+
+    GSL::Rng.memcpy(r, r_save)
+    N.times { |i| test_b[i] = r.get }
+
+    assert((0...N).all? { |i| test_b[i] == test_a[i] }, "#{r.name}, random number state consistency")
+  end
+
+  def _rng_parallel_state_test(type)
+    r1 = GSL::Rng.alloc(type)
+    r2 = GSL::Rng.alloc(type)
+
+    test_a = GSL::Vector.alloc(N)
+    test_b = GSL::Vector.alloc(N)
+    test_c = GSL::Vector.alloc(N)
+    test_d = GSL::Vector.alloc(N)
+    test_e = GSL::Vector.alloc(N)
+    test_f = GSL::Vector.alloc(N)
+
+    N.times { r1.get }
+
+    GSL::Rng.memcpy(r2, r1)
+
+    N.times { |i|
+      test_a[i] = r1.get
+      test_b[i] = r2.get
+      test_c[i] = r1.uniform_int(1234)
+      test_d[i] = r2.uniform_int(1234)
+      test_e[i] = r1.uniform
+      test_f[i] = r2.uniform
+    }
+
+    assert((0...N).all? { |i| test_a[i] == test_b[i] }, "#{r1.name}, parallel random number state consistency (a/b)")
+    assert((0...N).all? { |i| test_c[i] == test_d[i] }, "#{r1.name}, parallel random number state consistency (c/d)")
+    assert((0...N).all? { |i| test_e[i] == test_f[i] }, "#{r1.name}, parallel random number state consistency (e/f)")
+  end
+
+  def _rng_read_write_test(type)
+    r = GSL::Rng.alloc(type)
+
+    test_a = GSL::Vector.alloc(N)
+    test_b = GSL::Vector.alloc(N)
+
+    N.times { r.get }
+
+    r.fwrite('test.dat')
+    N.times { |i| test_a[i] = r.get }
+
+    r.fread('test.dat')
+    N.times { |i| test_b[i] = r.get }
+
+    assert((0...N).all? { |i| test_b[i] == test_a[i] }, "#{r.name}, random number generator read and write")
+  ensure
+    File.delete('test.dat') if FileTest.exist?('test.dat')
+  end
+
+  def _generic_rng_test(type)
+    r = GSL::Rng.alloc(type)
+
+    name, ran_max, ran_min = r.name, r.max, r.min
+    kmax, kmin, sigma = 0, 1000, 0.0
+
+    kmax, status = _rng_max_test(r, ran_max)
+    assert status.zero?, "#{name}, observed vs theoretical maximum (#{kmax} vs #{ran_max})"
+
+    kmin, status = _rng_min_test(r, ran_min, ran_max)
+    assert status.zero?, "#{name}, observed vs theoretical minimum (#{kmin} vs #{ran_min})"
+
+    sigma, status = _rng_sum_test(r)
+    assert status.zero?, "#{r.name}, sum test within acceptable sigma (observed #{sigma} sigma)"
+
+    sigma, status = _rng_bin_test(r)
+    assert status.zero?, "#{r.name}, bin test within acceptable chisq (observed #{sigma} sigma)"
+
+    r.set(1)
+    kmax, status = _rng_max_test(r, ran_max)
+
+    r.set(1)
+    kmin, s = _rng_min_test(r, ran_min, ran_max)
+    status |= s
+
+    r.set(1)
+    sigma, s = _rng_sum_test(r)
+    status |= s
+
+    r.set(12345)
+    kmax, s = _rng_max_test(r, ran_max)
+    status |= s
+
+    r.set(12345)
+    kmin, s = _rng_min_test(r, ran_min, ran_max)
+    status |= s
+
+    r.set(12345)
+    sigma, s = _rng_sum_test(r)
+    status |= s
+
+    assert status.zero?, "#{r.name}, maximum and sum tests for non-default seeds"
+  end
+
+  def _rng_max_test(r, ran_max)
+    max = 0
+
+    N2.times {
+      k = r.get
+      max = k if k > max
+    }
+
+    actual_uncovered = ran_max - max
+    expect_uncovered = ran_max.to_f / N2.to_f
+
+    [max, max > ran_max || actual_uncovered > 7 * expect_uncovered ? 1 : 0]
+  end
+
+  def _rng_min_test(r, ran_min, ran_max)
+    min = 1000000000
+
+    N2.times {
+      k = r.get
+      min = k if k < min
+    }
+
+    actual_uncovered = min - ran_min
+    expect_uncovered = ran_max.to_f / N2.to_f
+
+    [min, min < ran_min || actual_uncovered > 7 * expect_uncovered ? 1 : 0]
+  end
+
+  def _rng_sum_test(r)
+    sum = 0.0
+
+    N2.times {
+      x = r.uniform - 0.5
+      sum += x
+    }
+
+    sum /= N2.to_f
+    sigma = sum * Math.sqrt(12.0 * N2)
+
+    [sigma, sigma.abs > 3 || sigma.abs < 0.003 ? 1 : 0]
+  end
+
+  def _rng_bin_test(r)
+    count = GSL::Vector.calloc(BINS + EXTRA)
+    chisq = 0.0
+
+    N2.times { count[r.uniform_int(BINS)] += 1 }
+
+    BINS.times { |i|
+      x = N2.to_f / BINS
+      d = count[i] - x
+      chisq += d * d / x
+    }
+
+    BINS.upto(EXTRA - 1) { |i|
+      assert count[i].zero?, "#{r.name}, wrote outside range in bin test (#{i} observed vs #{BINS - 1} expected)"
+    }
+
+    [sigma = Math.sqrt(chisq / BINS), sigma.abs > 3 || sigma.abs < 0.003 ? 1 : 0]
+  end
+
+end

data/test/gsl/roots_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class RootsTest < GSL::TestCase
+
+  EPSREL = 10.0 * GSL::DBL_EPSILON
+  EPSABS = 10.0 * GSL::DBL_EPSILON
+
+  MAX_ITERATIONS = 150
+
+  def _test_f(type, desc, f, lower, upper, correct)
+    s = GSL::Root::FSolver.alloc(type)
+    s.set(f, lower, upper)
+
+    status = iter = 0
+
+    begin
+      iter += 1
+      s.iterate
+
+      r = s.root
+      a = s.x_lower
+      b = s.x_upper
+
+      refute a > b, "interval is invalid (#{a},#{b})"
+      refute r < a || r > b, "r lies outside interval #{r} (#{a},#{b})"
+
+      status = GSL::Root.test_interval(a, b, EPSABS, EPSREL)
+    end while status == GSL::CONTINUE && iter < MAX_ITERATIONS
+
+    assert status.zero?, "#{s.name}, #{desc} (#{s.root} obs vs #{correct} expected)"
+    assert iter <= MAX_ITERATIONS, 'exceeded maximum number of iterations'
+
+    assert_tol r, correct, "incorrect precision (#{r} obs vs #{correct} expected)"
+  end
+
+  def _test_fdf(type, desc, fdf, root, correct)
+    s = GSL::Root::FdfSolver.alloc(type)
+    s.set(fdf, root)
+
+    status = iter = 0
+
+    begin
+      iter += 1
+      prev = s.root
+
+      begin
+        s.iterate
+      rescue GSL::ERROR::EBADFUNC
+        raise unless type == 'secant'
+      end
+
+      status = GSL::Root.test_delta(s.root, prev, EPSABS, EPSREL)
+    end while status == GSL::CONTINUE && iter < MAX_ITERATIONS
+
+    assert status.zero?, "#{s.name} #{desc} (#{s.root} obs vs #{correct} expected)"
+    assert iter <= MAX_ITERATIONS, 'exceeded maximum number of iterations'
+
+    assert_tol r = s.root, correct, "incorrect precision (#{r} obs vs #{correct} expected)"
+  end
+
+  def setup
+    @func = GSL::Function.alloc { |x| GSL.pow(x, 20.0) - 1 }
+    @fdf  = GSL::Function_fdf.alloc(@func.f, lambda { |x| 20.0 * GSL.pow(x, 19.0) })
+  end
+
+  %w[bisection brent falsepos].each { |type|
+    define_method("test_f_#{type}") {
+      _test_f(type, 'x^20 - 1 [0.1, 2]', @func, 0.1, 2.0, 1.0)
+    }
+  }
+
+  %w[newton secant steffenson].each { |type|
+    define_method("test_fdf_#{type}") {
+      _test_fdf(type, 'x^{20} - 1 {0.9}', @fdf, 0.9, 1.0)
+    }
+  }
+
+end