rb-gsl 1.15.3.1

data/tests/eigen/gensymm.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test.rb")
+require("eigen.rb")
+include GSL::Test
+
+def test_eigen_gensymm_results(a, b, eval, evec, count, desc, desc2)
+  n = a.size1
+  # check A v = lambda B v 
+
+  for i in 0...n do
+    ei = eval[i]
+    vi = evec.column(i)
+    norm = vi.dnrm2
+    # check that eigenvector is normalized 
+    GSL::Test::test_rel(norm, 1.0, n * GSL::DBL_EPSILON,
+                        "gensymm(N=#{n},cnt=#{count}), #{desc}, normalized(#{i}), #{desc2}")
+    
+    y = a*vi
+    x = b*vi
+    x *= ei
+    
+    for j in 0...n do
+      GSL::Test::test_rel(y[j], x[j], 1e9 * GSL::DBL_EPSILON, 
+                          "gensymm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), #{desc2}")
+    end
+  end
+end
+
+def test_eigen_gensymm()
+  n_max = 20
+  rng = GSL::Rng.alloc()
+  for n in 1..n_max do
+    w  = GSL::Eigen::Gensymm::Workspace.alloc(n)
+    wv = GSL::Eigen::Gensymmv::Workspace.alloc(n)		
+    for i in 0...5 do
+      a = create_random_symm_matrix(n, n, rng, -10, 10)
+      b = create_random_posdef_matrix(n, n, rng)
+      
+      aa = a.clone
+      bb = b.clone
+      evalv, evec = GSL::Eigen::gensymmv(aa, bb, wv)
+      test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "unsorted")
+      
+      aa = a.clone
+      bb = b.clone
+      eval = GSL::Eigen::gensymm(aa, bb, w)
+      
+      x = eval.sort
+      y = evalv.sort
+      
+      test_eigenvalues_real(y, x, "gensymm, random", "unsorted");
+      
+      GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_VAL_ASC);
+      test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "val/asc");
+      
+      GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_VAL_DESC);
+      test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "val/desc");
+      
+      GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_ABS_ASC);
+      test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "abs/asc");
+      GSL::Eigen::Gensymmv::sort(evalv, evec, GSL::EIGEN_SORT_ABS_DESC);
+      test_eigen_gensymm_results(a, b, evalv, evec, i, "random", "abs/desc");
+    end
+  end
+end
+
+test_eigen_gensymm()

data/tests/eigen/nonsymm.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test.rb")
+include GSL::Test
+
+m = GSL::Matrix[[1, 2], [3, 2]]
+p m
+eval = m.eigen_nonsymm.real.sort
+GSL::Test::test_abs(eval[0], -1, 0, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[1], 4, 0, "GSL::Matrix::eigen_nonsymm")
+
+m = GSL::Matrix[[1, 4, 2, 3], 2, 2]
+p m
+eval = m.eigen_nonsymm.real.sort
+GSL::Test::test_abs(eval[0], -1, 0, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[1], 5, 0, "GSL::Matrix::eigen_nonsymm")
+
+m = GSL::Matrix[[2, 4], [3, 1]]
+p m
+eval = m.eigen_nonsymm.real.sort
+GSL::Test::test_abs(eval[0], -2, 0, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[1], 5, 0, "GSL::Matrix::eigen_nonsymm")
+
+m = GSL::Matrix[[5, 6, 3, 2], 2, 2]
+p m
+eval = m.eigen_nonsymm.real.sort
+GSL::Test::test_abs(eval[0], -1, 0, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[1], 8, 0, "GSL::Matrix::eigen_nonsymm")
+
+m = GSL::Matrix[[4, 1, -1, 2, 5, -2, 1, 1, 2], 3, 3]
+p m
+eval = m.eigen_nonsymm.real.sort
+GSL::Test::test_abs(eval[0], 3, 1e-10, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[1], 3, 0, "GSL::Matrix::eigen_nonsymm")
+# 2008/Oct/17 YT
+# This test fails in Darwin9.5.0-gcc4.0.1
+#   expected: 5
+#   obtained: 4.99999999999999911
+GSL::Test::test_abs(eval[2], 5, 0, "GSL::Matrix::eigen_nonsymm")
+
+m = GSL::Matrix[[-3, 1, -1], [-7, 5, -1], [-6, 6, -2]]
+p m
+eval = m.eigen_nonsymm.real.sort
+GSL::Test::test_abs(eval[0], -2, 1e-6, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[1], -2, 1e-6, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[2], 4, 1e-10, "GSL::Matrix::eigen_nonsymm")
+
+m = GSL::Matrix[[11, -8, 4, -8, -1, -2, 4, -2, -4], 3, 3]
+p m
+eval = m.eigen_nonsymm.real.sort
+GSL::Test::test_abs(eval[0], -5, 1e-10, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[1], -5, 1e-10, "GSL::Matrix::eigen_nonsymm")
+GSL::Test::test_abs(eval[2], 16, 1e-10, "GSL::Matrix::eigen_nonsymm")

data/tests/eigen/nonsymmv.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test.rb")
+include GSL::Test
+
+def test_nonsymmv2(m, eps)
+  p m
+  m2 = m.clone
+  eval, evec = m2.eigen_nonsymmv
+  evalre = eval.real
+  evecre = evec.real
+  a = evecre.inv*m*evecre
+  GSL::Test::test_abs(a[0,0], evalre[0], eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[1,1], evalre[1], eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[0,1], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[1,0], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+end
+
+def test_nonsymmv3(m, eps)
+  p m
+  m2 = m.clone
+  eval, evec = m2.eigen_nonsymmv
+  evalre = eval.real
+  evecre = evec.real
+  a = evecre.inv*m*evecre
+  GSL::Test::test_abs(a[0,0], evalre[0], eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[1,1], evalre[1], eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[2,2], evalre[2], eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[0,1], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[0,2], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[1,0], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[1,2], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[2,0], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+  GSL::Test::test_abs(a[2,1], 0, eps, "GSL::Matrix::eigen_nonsymmv")
+end
+
+m = GSL::Matrix[[1, 2], [3, 2]]
+test_nonsymmv2(m, 1e-10)
+
+m = GSL::Matrix[[4, 2, 3, -1], 2, 2]
+test_nonsymmv2(m, 1e-10)
+
+m = GSL::Matrix[[2, 2, -5], [3, 7, -15], [1, 2, -4]]
+test_nonsymmv3(m, 1e-10)
+
+m = GSL::Matrix[[4, 1, -1], [2, 5, -2], [1, 1, 2]]
+test_nonsymmv3(m, 1e-10)
+
+m = GSL::Matrix[[-3, 1, -1], [-7, 5, -1], [-6, 6, -2]]
+test_nonsymmv3(m, 1e-6)
+
+m = GSL::Matrix[[11, -8, 4], [-8, -1, -2], [4, -2, -4]]
+test_nonsymmv3(m, 1e-10)

data/tests/eigen/symm-herm.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "eigen/test.c"
+require("gsl")
+require("../gsl_test.rb")
+require("eigen.rb")
+include GSL::Test
+
+def test_eigen_symm(desc, m)
+  n = m.size1
+  a = GSL::Matrix.alloc(n, n)
+
+  w1 = GSL::Eigen::Symm::Workspace.alloc(n)
+  w2 = GSL::Eigen::Symmv::Workspace.alloc(n)
+
+  GSL::Matrix.memcpy(a, m)
+  eval, evec = a.eigen_symmv(w2)
+  test_eigen_results(n, m, eval, evec, desc, "unsorted")
+
+  GSL::Matrix.memcpy(a, m)
+  eval2 = a.eigen_symm(w1)
+  test_eigenvalues(n, eval, eval2, desc, "unsorted")
+
+  GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_VAL_ASC)
+  test_eigen_results(n, m, eval, evec, desc, "val/asc")
+  GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_VAL_DESC)
+  test_eigen_results(n, m, eval, evec, desc, "val/desc")
+  GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_ABS_ASC)
+  test_eigen_results(n, m, eval, evec, desc, "abs/asc")
+  GSL::Eigen::Symmv::sort(eval, evec, GSL::Eigen::SORT_ABS_DESC)
+  test_eigen_results(n, m, eval, evec, desc, "abs/desc")
+end
+
+def test_eigen_herm(desc, m)
+  n = m.size1
+  a = GSL::Matrix::Complex.alloc(n, n)
+
+  w1 = GSL::Eigen::Herm::Workspace.alloc(n)
+  w2 = GSL::Eigen::Hermv::Workspace.alloc(n)
+
+  GSL::Matrix::Complex.memcpy(a, m)
+  eval, evec = a.eigen_hermv(w2)
+  test_eigen_complex_results(n, m, eval, evec, desc, "unsorted")
+
+  GSL::Matrix::Complex.memcpy(a, m)
+  eval2 = a.eigen_herm(w1)
+  test_eigenvalues(n, eval, eval2, desc, "unsorted")
+
+  GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_VAL_ASC)
+  test_eigen_complex_results(n, m, eval, evec, desc, "val/asc")
+  GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_VAL_DESC)
+  test_eigen_complex_results(n, m, eval, evec, desc, "val/desc")
+  GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_ABS_ASC)
+  test_eigen_complex_results(n, m, eval, evec, desc, "abs/asc")
+  GSL::Eigen::Hermv::sort(eval, evec, GSL::Eigen::SORT_ABS_DESC)
+  test_eigen_complex_results(n, m, eval, evec, desc, "abs/desc")
+end
+
+
+
+r = GSL::Matrix.alloc([0, 0, -1, 0], [0, 1, 0, 1], [-1, 0, 0, 0], [0, 1, 0, 0])
+test_eigen_symm("symm(4)", r)
+
+c = r.to_complex
+test_eigen_herm("herm(4)", c)
+
+r = GSL::Matrix.alloc(4, 4)
+r.set_diagonal([1, 2, 3, 4])
+test_eigen_symm("symm(4) diag", r)
+
+c = r.to_complex
+test_eigen_herm("herm(4) diag", c)
+
+
+

data/tests/err.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "sum/test.c"
+require("gsl")
+require("./gsl_test2.rb")
+include GSL::Test
+
+MAX_ERRS = 64
+
+class ErrCode
+  attr_accessor :number
+  attr_accessor :name
+  def initialize(number, name)
+    @number = number
+    @name = name
+  end
+end
+
+errors = ["GSL::SUCCESS", "GSL::FAILURE", "GSL::CONTINUE", "GSL::EDOM", 
+          "GSL::ERANGE", "GSL::EFAULT", "GSL::EINVAL", "GSL::EFAILED", 
+          "GSL::EFACTOR", "GSL::ESANITY", "GSL::ENOMEM", "GSL::EBADFUNC", 
+          "GSL::ERUNAWAY", "GSL::EMAXITER", "GSL::EZERODIV", "GSL::EBADTOL", 
+          "GSL::ETOL", "GSL::EUNDRFLW", "GSL::EOVRFLW", "GSL::ELOSS", 
+          "GSL::EROUND", "GSL::EBADLEN", "GSL::ENOTSQR", "GSL::ESING",
+          "GSL::EDIVERGE", "GSL::EUNSUP", "GSL::EUNIMPL", "GSL::ECACHE",
+          "GSL::ETABLE", "GSL::ENOPROG", "GSL::ENOPROGJ", "GSL::ETOLF", 
+          "GSL::ETOLX", "GSL::ETOLG", "GSL::EOF"]
+
+Errors = Array.new(errors.size)
+
+errors.each_index do |i|
+  Errors[i] = ErrCode.new(eval("#{errors[i]}"), errors[i])
+end
+
+for i in 0...Errors.size
+  printf("%s = %d\n", Errors[i].name, Errors[i].number)
+end
+
+for i in 0...Errors.size
+  status = 0
+  for j in 0...Errors.size
+    if j != i
+      status |= (Errors[i].number == Errors[j].number) ? 1 : 0
+    end
+    GSL::Test::test(status, "#{Errors[i].name} is distinct from other error values")
+  end
+end
+
+for i in 0...Errors.size
+  status = 0
+  e1 = Errors[i].number
+  for j in 0...Errors.size
+    if j != i
+      e2 = Errors[j].number
+      status |= (GSL::strerror(e1) == GSL::strerror(e2)) ? 1 : 0
+    end
+  end
+  GSL::Test::test(status, "#{Errors[i].name} has a distinct error message")
+end

data/tests/fit.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "fit/test.c"
+require("gsl")
+require("./gsl_test.rb")
+include GSL::Test
+include Math
+
+GSL::IEEE::env_setup()
+
+norris_n = 36
+norris_x = GSL::Vector.alloc(0.2, 337.4, 118.2, 884.6, 10.1, 226.5, 666.3, 996.3,
+                      448.6, 777.0, 558.2, 0.4, 0.6, 775.5, 666.9, 338.0, 
+                      447.5, 11.6, 556.0, 228.1, 995.8, 887.6, 120.2, 0.3, 
+                      0.3, 556.8, 339.1, 887.2, 999.0, 779.0, 11.1, 118.3,
+                      229.2, 669.1, 448.9, 0.5)
+norris_y = GSL::Vector.alloc(0.1, 338.8, 118.1, 888.0, 9.2, 228.1, 668.5, 998.5,
+                      449.1, 778.9, 559.2, 0.3, 0.1, 778.1, 668.8, 339.3, 
+                      448.9, 10.8, 557.7, 228.3, 998.0, 888.8, 119.6, 0.3, 
+                      0.6, 557.6, 339.3, 888.0, 998.5, 778.9, 10.2, 117.6,
+                      228.9, 668.4, 449.2, 0.2)
+
+noint1_n = 11
+noint1_x = GSL::Vector.alloc(60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70)
+noint1_y = GSL::Vector.alloc(130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140)
+
+noint2_n = 3
+noint2_x = GSL::Vector.alloc(4, 5, 6)
+noint2_y = GSL::Vector.alloc(3, 4, 4)
+
+x = GSL::Vector.alloc(1000)
+y = GSL::Vector.alloc(1000)
+w = GSL::Vector.alloc(1000)
+
+xstride = 2
+wstride = 3
+ystride = 5
+
+x.stride = xstride
+w.stride = wstride
+y.stride = ystride
+
+for i in 0...norris_n
+  x.set(i, norris_x[i])
+  w.set(i, 1.0)
+  y.set(i, norris_y[i])
+end
+
+expected_c0 = -0.262323073774029
+expected_c1 =  1.00211681802045 
+expected_cov00 = pow(0.232818234301152, 2.0)
+expected_cov01 = -7.74327536339570e-05
+expected_cov11 = pow(0.429796848199937E-03, 2.0)
+expected_sumsq = 26.6173985294224
+
+c0, c1, cov00, cov01, cov11, sumsq = GSL::Fit.linear(x, y, norris_n)
+GSL::Test::test_rel(c0, expected_c0, 1e-10, "norris gsl_fit_linear c0")
+GSL::Test::test_rel(c1, expected_c1, 1e-10, "norris gsl_fit_linear c1")
+GSL::Test::test_rel(cov00, expected_cov00, 1e-10, "norris gsl_fit_linear cov00")
+GSL::Test::test_rel(cov01, expected_cov01, 1e-10, "norris gsl_fit_linear cov01")
+GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "norris gsl_fit_linear cov11")
+GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "norris gsl_fit_linear sumsq")
+
+expected_c0 = -0.262323073774029
+expected_c1 =  1.00211681802045 
+expected_cov00 = 6.92384428759429e-02 
+expected_cov01 = -9.89095016390515e-05
+expected_cov11 = 2.35960747164148e-07 
+expected_sumsq = 26.6173985294224
+
+c0, c1, cov00, cov01, cov11, sumsq = GSL::Fit.wlinear(x, w, y, norris_n)
+GSL::Test::test_rel(c0, expected_c0, 1e-10, "norris gsl_fit_wlinear c0")
+GSL::Test::test_rel(c1, expected_c1, 1e-10, "norris gsl_fit_wlinear c1")
+GSL::Test::test_rel(cov00, expected_cov00, 1e-10, "norris gsl_fit_wlinear cov00")
+GSL::Test::test_rel(cov01, expected_cov01, 1e-10, "norris gsl_fit_wlinear cov01")
+GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "norris gsl_fit_wlinear cov11")
+GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "norris gsl_fit_wlinear sumsq")
+
+for i in 0...noint1_n
+  x.set(i, noint1_x[i])
+  w.set(i, 1.0)
+  y.set(i, noint1_y[i])
+end
+
+expected_c1 = 2.07438016528926 
+expected_cov11 = pow(0.165289256198347E-01, 2.0)  
+expected_sumsq = 127.272727272727
+
+c1, cov11, sumsq = GSL::Fit.mul(x, y, noint1_n)
+GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint1 gsl_fit_mul c1")
+GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint1 gsl_fit_mul cov11")
+GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint1 gsl_fit_mul sumsq")
+
+expected_c1 = 2.07438016528926
+expected_cov11 = 2.14661371686165e-05
+expected_sumsq = 127.272727272727
+
+c1, cov11, sumsq = GSL::Fit.wmul(x, w, y, noint1_n)
+GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint1 gsl_fit_wmul c1")
+GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint1 gsl_fit_wmul cov11")
+GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint1 gsl_fit_wmul sumsq")
+
+for i in 0...noint2_n
+  x.set(i, noint2_x[i])
+  w.set(i, 1.0)
+  y.set(i, noint2_y[i])
+end
+
+expected_c1 = 0.727272727272727 
+expected_cov11 = pow(0.420827318078432E-01, 2.0)
+expected_sumsq = 0.272727272727273
+
+c1, cov11, sumsq = GSL::Fit.mul(x, y, noint2_n)
+GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint2 gsl_fit_mul c1")
+GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint2 gsl_fit_mul cov11")
+GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint2 gsl_fit_mul sumsq")
+
+expected_c1 = 0.727272727272727 
+expected_cov11 = 1.29870129870130e-02
+expected_sumsq = 0.272727272727273
+
+c1, cov11, sumsq = GSL::Fit.wmul(x, w, y, noint2_n)
+GSL::Test::test_rel(c1, expected_c1, 1e-10, "noint2 gsl_fit_wmul c1")
+GSL::Test::test_rel(cov11, expected_cov11, 1e-10, "noint2 gsl_fit_wmul cov11")
+GSL::Test::test_rel(sumsq, expected_sumsq, 1e-10, "noint2 gsl_fit_wmul sumsq")

data/tests/gsl_test.rb

@@ -0,0 +1,118 @@
+#!/usr/bin/env ruby
+require("gsl")
+include GSL
+
+module GSL
+  module Test
+    Verbose = true
+    $tests = 0
+    $passed = 0
+    $failed = 0
+
+    def test(status, desc)
+      $tests += 1
+      if !status
+        $passed += 1
+        printf("PASS: #{desc}\n")
+      else
+        $failed += 1
+        printf("FAIL: #{desc}\n")
+      end
+    end
+
+    def test_factor(result, expected, factor, desc)
+      status = nil
+      if result == expected
+        status = false
+      elsif expected == 0.0
+        status = (result > expected or result < expected)
+      else
+        u = result/expected
+        status = (u > factor or u < 1.0/factor)
+      end
+      $tests += 1
+      if !status
+        $passed += 1
+        printf("PASS: #{desc} (%g observed vs %g expected)\n", result, expected) 
+      else
+        $failed += 1
+        printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) 
+      end
+    end
+
+    def test_factor2(result, expected, factor, desc)
+      status = nil
+      if result == expected
+        status = false
+      elsif expected == 0.0
+        status = (result > expected or result < expected)
+      else
+        u = result/expected
+        status = (u > factor or u < 1.0/factor)
+      end
+      $tests += 1
+      if !status
+        $passed += 1
+        printf("PASS: #{desc} (%.18g observed vs %g expected)\n", result, expected) 
+      else
+        $failed += 1
+        printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) 
+      end
+    end
+    
+    def test_rel(result, expected, relerr, desc)
+      status = nil
+      if isnan?(result) or isnan?(expected)
+        status = isnan?(result) != isnan?(expected)
+      elsif isinf?(result) or isinf?(expected)
+        status = isinf?(result) != isinf?(expected)
+      elsif expected.to_f != 0.0
+        status = (result - expected).abs/expected.abs > relerr
+      else
+        status = result.abs > relerr
+      end
+      $tests += 1
+      if !status
+        $passed += 1
+        printf("PASS: #{desc} (%.18g observed vs %g expected)\n", result, expected) 
+      else
+        $failed += 1
+        printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) 
+      end
+    end
+
+    def test_abs(result, expected, abserr, desc)
+      status = nil
+      if isnan?(result) or isnan?(expected)
+        status = isnan?(result) != isnan?(expected)
+      elsif isinf?(result) or isinf?(expected)
+        status = isinf?(result) != isinf?(expected)
+      else
+        status = (result - expected).abs > abserr
+      end
+      $tests += 1
+      if !status
+        $passed += 1
+#        printf("PASS: #{desc} (%g observed vs %g expected)\n", result, expected) 
+        printf("PASS: #{desc} (%.18g observed vs %g expected)\n", result, expected) 
+      else
+        $failed += 1
+        printf("FAIL: #{desc} (%.18g observed vs %.18g expected)\n", result, expected) 
+      end      
+    end
+
+    def test_int(result, expected, desc)
+      status = (result != expected)
+      $tests += 1
+      if !status
+        $passed += 1
+        printf("PASS: #{desc} (%d observed vs %d expected)\n", result, expected) 
+      else
+        $failed += 1
+        printf("FAIL: #{desc} (%d observed vs %d expected)\n", result, expected) 
+      end
+    end
+
+  end
+end
+