gsl 1.16.0.6 → 2.1.0

data/test/gsl/nmatrix_tests/nmatrix_gsl_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class NMatrixGslTest < GSL::TestCase
+  def setup
+    @gsl_vector = GSL::Vector.alloc(2.354, 4.443, 6.776)
+    @nm_vector  = NMatrix.new([3], [2.354, 4.443, 6.776], dtype: :float64)
+
+    @gsl_int_vector = GSL::Vector::Int[1,2,3,4,5]
+    @nm_int_vector  = NMatrix.new([5], [1,2,3,4,5], dtype: :int32)
+
+    @gsl_complex_vector = GSL::Vector::Complex.alloc([[1,0], [2,0], [3,0]])
+    @nm_complex_vector  = NMatrix.new([3], [1,2,3], dtype: :complex128)
+
+    @gsl_matrix = GSL::Matrix.alloc(
+      [1,2,3],
+      [4,5,6],
+      [7,8,9]
+    )
+    @nm_matrix  = NMatrix.new([3,3], [1,2,3,4,5,6,7,8,9], dtype: :float64)
+
+    @gsl_int_matrix = GSL::Matrix::Int.alloc(
+      [1,2,3],
+      [4,5,6],
+      [7,8,9] 
+    )
+    @nm_int_matrix = NMatrix.new([3,3], [1,2,3,4,5,6,7,8,9], dtype: :int32)
+
+    @gsl_complex_matrix = GSL::Matrix::Complex.alloc(2,2)
+    @gsl_complex_matrix.set(0,0, [1.1,1.1])
+    @gsl_complex_matrix.set(0,1, [2.2,2.2])
+    @gsl_complex_matrix.set(1,0, [3.3,3.3])
+    @gsl_complex_matrix.set(1,1, [4.4,4.4])
+
+    @nm_complex_matrix = NMatrix.new([2,2], 
+      [Complex(1.1,1.1), Complex(2.2,2.2), Complex(3.3,3.3), Complex(4.4,4.4)], dtype: :complex128)
+  end
+
+  # GSL::Vector to 1D NMatrix
+  def test_gsl_vector_to_nmatrix
+    assert_equal @nm_vector        , @gsl_vector.to_nm        , 'floating point GSL::Vector to NMatrix'
+    assert_equal @nm_int_vector    , @gsl_int_vector.to_nm    , 'integer GSL::Vector to NMatrix'
+    assert_equal @nm_complex_vector, @gsl_complex_vector.to_nm, 'complex GSL::Vector to NMatrix'
+  end
+
+  # GSL::Matrix to NMatrix
+  def test_gsl_matrix_to_nmatrix
+    assert_equal @nm_matrix, @gsl_matrix.to_nm, 'floating point GSL::Matrix to 2D NMatrix'
+    assert_equal @nm_int_matrix, @gsl_int_matrix.to_nm, 'GSL::Matrix::Int to 2D NMatrix'
+    assert_equal @nm_complex_matrix, @gsl_complex_matrix.to_nm, 'GSL::Matrix::Complex to 2D NMatrix'
+  end
+
+  # NMatrix to GSL::Vector
+  def test_nmatrix_to_gsl_vector
+    assert_equal @gsl_vector        , @nm_vector.to_gslv        , 'floating point NMatrix to GSL::Vector'
+    assert_equal @gsl_int_vector    , @nm_int_vector.to_gslv    , 'int NMatrix to GSL::Vector::Int'
+    assert_equal @gsl_complex_vector, @nm_complex_vector.to_gslv, 'complex NMatrix to GSL::Vector::Complex'
+  end
+
+  # NMatrix to GSL::Matrix
+  def test_nmatrix_to_gsl_matrix
+    assert_equal @gsl_matrix        , @nm_matrix.to_gslm        , 'floating NMatrix to GSL::Matrix'
+    assert_equal @gsl_int_matrix    , @nm_int_matrix.to_gslm    , 'int NMatrix to GSL::Matrix::Int'
+    assert_equal @gsl_complex_matrix, @nm_complex_matrix.to_gslm, 'complex NMatrix to GSL::Matrix::Complex'
+  end
+end

data/test/gsl/nmatrix_tests/nmatrix_interp_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class NMatrixInterpTest < GSL::TestCase
+  def test_interp_init_eval
+    n = 10
+    x = NMatrix.new([n], dtype: :float64)
+    y = x.clone_structure
+
+    0.upto(n-1) do |i|
+      a = i.to_f
+      x[i] = i + 0.5*Math::sin(a)
+      y[i] = i + Math::cos(a*a)
+    end
+
+    interp = GSL::Interp.alloc("akima", n)
+    interp.init(x, y)
+
+    yi = []
+    xi = x[0]
+    r = []
+    while xi < x[9]
+      r << xi
+      xi += 0.01
+    end
+
+    yi = interp.eval(x,y,NMatrix.new([r.size], r, dtype: :float64))
+
+    assert_rel yi[1] , 1.0066, 0.001, 'yi[1]'
+    assert_rel yi.to_a.last, 9.7618, 0.001, 'yi.last'
+  end
+
+  def test_spline_init_eval
+    n = 10
+    x = NMatrix.new([n], (1..10).to_a, dtype: :float64)
+    y = x.dup
+
+    spline = GSL::Spline.alloc(x, y)
+    
+    xi = NMatrix.new([n], (1..9).map { |a| a += 0.5 }, dtype: :float64)
+    yi = spline.eval(xi)
+
+    assert yi.class == NMatrix
+    assert_rel yi[0], 1.5, 0.0001, 'yi[0]'
+  end
+end

data/test/gsl/nmatrix_tests/nmatrix_linalg_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+class NMatrixLinalgTest < GSL::TestCase
+  def setup
+    @nm = NMatrix.new([4,4], 
+      [
+        0.18, 0.60, 0.57, 0.96, 
+        0.41, 0.24, 0.99, 0.58,
+        0.14, 0.30, 0.97, 0.66, 
+        0.51, 0.13, 0.19, 0.85
+      ], dtype: :float64)
+    @b = NMatrix.new([4], [1,2,3,4], dtype: :float64)
+    @x_exp = NMatrix.new([4], [-4.05205022957397, -12.6056113959069, 1.66091162670884, 8.69376692879523], dtype: :float64)   
+  end
+
+  def test_lu
+    lu, perm, signum = GSL::Linalg::LU.decomp(@nm)
+
+    lu_exp = NMatrix.new([4,4],
+     [0.51,              0.13,              0.19,              0.85,
+      0.352941176470588, 0.554117647058823, 0.502941176470588, 0.66,
+      0.803921568627451, 0.244515215852796, 0.71427813163482, -0.264713375796178,
+      0.274509803921569, 0.476999292285916, 0.949126848480345, 0.363093705877982],
+      dtype: :float64)
+
+    assert_enum_abs lu, lu_exp, 0.0001, "GSL::Linalg::LU.decomp(A) with NMatrix"
+    assert_enum_abs GSL::Linalg::LU.solve(lu, perm, @b), @x_exp, 0.0001, "GSL::Linalg::LU.solve(lu, perm, b) with NMatrix"
+
+    ##########################################################################
+
+    nm = NMatrix.new([2,2], [1,1,14,1], dtype: :float64)
+    lu, perm, sign = GSL::Linalg::LU.decomp(nm)
+    inverted  = NMatrix.new([2,2], 
+      [
+        -0.076923,  0.076923,
+         1.076923, -0.076923
+      ], dtype: :float64)
+
+    assert_enum_abs GSL::Linalg::LU.invert(lu, perm), inverted, 0.001, "GSL::Linalg::LU.invert(lu, perm) with NMatrix"
+    assert GSL::Linalg::LU.det(lu, sign) == -13, "GSL::Linalg::LU.det(lu, sign) with NMatrix"
+  end
+
+  def test_qr
+    qr_answer = NMatrix.new([4,4], 
+      [-0.692965, -0.454136, -1.06961 , -1.35144, 
+       0.469664 ,  0.564146,  0.72597 , 0.726696, 
+       0.160373 , -0.159838, -0.781606, 0.063932, 
+       0.584216 ,  0.593044, -0.332286, 0.239865], dtype: :float64)
+    tau_answer = NMatrix.new([4], [1.25975, 1.45217, 1.80113, 0.0], dtype: :float64)
+    qr, tau = GSL::Linalg::QR.decomp(@nm)
+    
+    assert_enum_abs qr_answer , qr , 0.001, "GSL::Linalg::QR.decomp(nmatrix)"
+    assert_enum_abs tau_answer, tau, 0.001, "GSL::Linalg::QR.decomp(nmatrix)"
+
+    assert_enum_abs GSL::Linalg::QR.solve(qr, tau, @b), @x_exp, 0.001, 
+      "GSL::Linalg::QR.solve(qr, tau, b)"
+  end
+
+  def test_sv
+    u_answer = NMatrix.new([4,4],
+      [-0.545591,-0.312561, 0.709796,-0.317529, 
+       -0.5298  , 0.418583,-0.475268,-0.564111, 
+       -0.524621, 0.436573, 0.112083, 0.722229, 
+       -0.382642,-0.73246 ,-0.507688, 0.243598 ], dtype: :float64)
+    v_answer = NMatrix.new([4,4],
+      [-0.260024,-0.288729 ,-0.732277,-0.559279 , 
+       -0.294582,-0.0751933, 0.659393,-0.687581 , 
+       -0.630928, 0.762631 ,-0.12665 , 0.0654517, 
+       -0.668983,-0.573912 , 0.113712, 0.458427 ], dtype: :float64)
+    s_answer = NMatrix.new([4], [2.24602,0.682566,0.423782,0.112813], dtype: :float64)
+
+    u, v, s = GSL::Linalg::SV.decomp(@nm)
+
+    assert_enum_abs u, u_answer, 0.001, "GSL::Linalg::SV.decomp(nmatrix) -> u"
+    assert_enum_abs v, v_answer, 0.001, "GSL::Linalg::SV.decomp(nmatrix) -> v"
+    assert_enum_abs s, s_answer, 0.001, "GSL::Linalg::SV.decomp(nmatrix) -> s"
+
+    assert_enum_abs GSL::Linalg::SV.solve(u, v, s, @b), @x_exp, 0.001, 
+      "GSL::Linalg::SV.solve(u,v,s,b)"
+  end
+
+  def test_cholesky
+    m = NMatrix.new([2,2], [4.0, 2, 2, 3], dtype: :float64)
+    b = NMatrix.new([2], [1,2], dtype: :float64)
+
+    cholesky = NMatrix.new([2,2], [2.0, 1.0, 1.0, 1.41421], dtype: :float64)
+    x_exp = NMatrix.new([2], [-0.125, 0.75], dtype: :float64)
+
+    c = GSL::Linalg::Cholesky
+    assert_enum_abs c.decomp(m)         , cholesky, 0.001, "GSL::Linalg::Cholesky.decomp"
+    assert_enum_abs c.solve(cholesky, b), x_exp   , 0.001, "GSL::Linalg::Cholesky.solve"
+    assert_enum_abs c.svx(cholesky, b)  , x_exp   , 0.001, "GSL::Linalg::Cholesky.svx"
+  end
+
+  def test_hh
+    hh = GSL::Linalg::HH
+    assert_enum_abs hh.solve(@nm, @b), @x_exp, 0.001, "GSL::Linalg::HH.solve(m, b)"
+    assert_enum_abs hh.svx(@nm, @b)  , @x_exp, 0.001, "GSL::Linalg::HH.svx(m, b)"
+  end
+end

data/test/gsl/nmatrix_tests/nmatrix_stats_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+class NMatrixStatsTest < GSL::TestCase
+  def setup
+    @lew = NMatrix.new([200],
+      [-213, -564,  -35,  -15,  141,  115, -420, -360,  203, -338, -431,  194,
+      -220, -513,  154, -125, -559,   92,  -21, -579,  -52,   99, -543, -175,
+       162, -457, -346,  204, -300, -474,  164, -107, -572,   -8,   83, -541,
+      -224,  180, -420, -374,  201, -236, -531,   83,   27, -564, -112,  131,
+      -507, -254,  199, -311, -495,  143,  -46, -579,  -90,  136, -472, -338,
+       202, -287, -477,  169, -124, -568,   17,   48, -568, -135,  162, -430,
+      -422,  172,  -74, -577,  -13,   92, -534, -243,  194, -355, -465,  156,
+       -81, -578,  -64,  139, -449, -384,  193, -198, -538,  110,  -44, -577,
+        -6,   66, -552, -164,  161, -460, -344,  205, -281, -504,  134,  -28,
+      -576, -118,  156, -437, -381,  200, -220, -540,   83,   11, -568, -160,
+       172, -414, -408,  188, -125, -572,  -32,  139, -492, -321,  205, -262,
+      -504,  142,  -83, -574,    0,   48, -571, -106,  137, -501, -266,  190,
+      -391, -406,  194, -186, -553,   83,  -13, -577,  -49,  103, -515, -280,
+       201,  300, -506,  131,  -45, -578,  -80,  138, -462, -361,  201, -211,
+      -554,   32,   74, -533, -235,  187, -372, -442,  182, -147, -566,   25,
+        68, -535, -244,  194, -351, -463,  174, -125, -570,   15,   72, -550,
+      -190,  172, -424, -385,  198, -218, -536,   96], dtype: :float64
+    )
+
+    @rawa = NMatrix.new([14],
+      [0.0421, 0.0941, 0.1064, 0.0242, 0.1331,
+      0.0773, 0.0243, 0.0815, 0.1186, 0.0356,
+      0.0728, 0.0999, 0.0614, 0.0479], dtype: :float64
+    )
+
+    @rawb = NMatrix.new([14],
+      [0.1081, 0.0986, 0.1566, 0.1961, 0.1125,
+      0.1942, 0.1079, 0.1021, 0.1583, 0.1673,
+      0.1675, 0.1856, 0.1688, 0.1512], dtype: :float64
+    )
+
+    @raww = NMatrix.new([14],
+      [0.0000, 0.0000, 0.0000, 3.000, 0.0000,
+      1.0000, 1.0000, 1.0000, 0.000, 0.5000,
+      7.0000, 5.0000, 4.0000, 0.123], dtype: :float64
+    )
+  end
+
+  def test_stats
+    assert_rel GSL::Stats.mean(@lew), -177.435000000000,    1e-15, 'lew gsl_stats_mean'
+    assert_rel GSL::Stats.sd(@lew),    277.332168044316,    1e-15, 'lew gsl_stats_sd'
+    assert_rel GSL::Stats.lag1_autocorrelation(@lew), -0.307304800605679, 1e-14, 'lew autocorrelation'
+
+    rel = 1e-10
+    rawa_mean = GSL::Stats.mean(@rawa)
+
+    assert_rel GSL::Stats.variance_with_fixed_mean(@rawa, rawa_mean), 0.00113837428571429,
+      rel, 'gsl_stats_variance_with_fixed_mean'
+
+    assert_rel GSL::Stats.sd_with_fixed_mean(@rawa, rawa_mean), 0.0337398026922845,
+      rel, 'gsl_stats_sd_with_fixed_mean'
+
+    assert_rel GSL::Stats.variance(@rawb),         0.00124956615384615,  rel, 'gsl_stats_variance'
+    assert_rel GSL::Stats.sd(@rawa),               0.0350134479659107,   rel, 'gsl_stats_sd'
+    assert_rel GSL::Stats.absdev(@rawa),           0.0287571428571429,   rel, 'gsl_stats_absdev'
+    assert_rel GSL::Stats.skew(@rawa),             0.0954642051479004,   rel, 'gsl_stats_skew'
+    assert_rel GSL::Stats.kurtosis(@rawa),        -1.38583851548909,     rel, 'gsl_stats_kurtosis'
+    assert_rel GSL::Stats.covariance(@rawa,@rawb),-0.000139021538461539, rel, 'gsl_stats_covariance'
+
+    if GSL::GSL_VERSION >= '1.9.90'
+      assert_rel GSL::Stats.correlation(@rawa, @rawb), -0.112322712666074171, rel, 'gsl_stats_correlation'
+      assert_rel GSL::Stats.pvariance(@rawa, @rawb),    0.00123775384615385,  rel, 'gsl_stats_pvariance'
+      assert_rel GSL::Stats.ttest(@rawa, @rawb),       -5.67026326985851,     rel, 'gsl_stats_ttest'
+    end
+
+    assert_rel GSL::Stats.max(@rawa), 0.1331, rel, 'gsl_stats_max'
+    assert_rel GSL::Stats.min(@rawa), 0.0242, rel, 'gsl_stats_min'
+
+    assert GSL::Stats.max_index(@rawa) == 4, 'gsl_stats_max'
+    assert GSL::Stats.min_index(@rawa) == 3, 'gsl_stats_min'
+
+    rawa_sorted = NMatrix.new([@rawa.size], @rawa.sort, dtype: :float64)
+
+    sorted = NMatrix.new([@rawa.size], @rawa.to_a.sort, dtype: :float64)
+    assert_rel GSL::Stats.median_from_sorted_data(sorted), 0.07505,
+      rel, 'gsl_stats_median_from_sorted_data'
+
+    assert_rel GSL::Stats.median_from_sorted_data(sorted[0..(sorted.size - 2)]), 0.0728,
+      rel, 'gsl_stats_median_from_sorted_data'
+
+    #TODO: Expose quantile_from_sorted_data
+  end
+end

data/test/gsl/nmatrix_tests/nmatrix_wavelet_test.rb

@@ -0,0 +1,5 @@
+require 'test_helper.rb'
+
+class NMatrixWaveletTest < GSL::TestCase
+# TODO
+end

data/test/gsl/randist_test.rb

@@ -10,28 +10,34 @@ class RandistTest < GSL::TestCase
 
   R_GLOBAL = GSL::Rng.alloc
 
+  @@use_nmatrix = false
+
   def test_shuffle
     n = 10
 
-    count = GSL::Matrix.calloc(n, n)
-    x = GSL::Permutation.alloc(n)
+    input = [GSL::Matrix.calloc(n, n)]
+    input << NMatrix.new([n,n], 0, dtype: :float64) if @@use_nmatrix
 
-    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) }
-    }
+    input.each do |count|
+      x = GSL::Permutation.alloc(n)
 
-    expected = N / 10.0
+      N.times { |i|
+        n.times { |j| x[j] = j }
+        GSL::Ran.shuffle(R_GLOBAL, x)
+        n.times { |j| count[x[j], j] += 1 }
+      }
+
+      expected = N / 10.0
 
-    n.times { |i|
-      n.times { |j|
-        d = (count[i, j] - expected).abs
+      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)"
+          refute d > 1 && d / Math.sqrt(expected) > 5,
+            "gsl_ran_shuffle #{i},#{j} (#{count[i, j] / N} observed vs 0.1 expected)"
+        }
       }
-    }
+    end
   end
 
   def _test_moments(name, arg, a, b, pp)
@@ -54,8 +60,9 @@ class RandistTest < GSL::TestCase
 
     status = status_i = 0
 
-    count = GSL::Vector.calloc(BINS)
-    pp = GSL::Vector.calloc(BINS)
+    count = @@use_nmatrix ? NMatrix.new([BINS], 0 ,dtype: :float64) : 
+      GSL::Vector.calloc(BINS)
+    pp = @@use_nmatrix ? NMatrix.new([BINS], 0 ,dtype: :float64) : GSL::Vector.calloc(BINS)
 
     N.times { |i|
       r = R_GLOBAL.send(name, *args)
@@ -85,13 +92,13 @@ class RandistTest < GSL::TestCase
       status |= status_i
 
       refute status_i == 1,
-        "#{name} [#{x},#{x + dx}) (#{count[i]}/#{N}=#{count.to_f / N} observed vs #{pp[i]} expected)"
+        "#{name} [#{x},#{x + dx}) (#{count[i]}/#{N}=#{count[i].to_f / N} observed vs #{pp[i]} expected)"
     }
 
     assert status.zero?, "#{name}, sampling against pdf over range [#{a},#{b})"
   end
 
-  def test_randist
+  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)
@@ -99,12 +106,16 @@ class RandistTest < GSL::TestCase
     _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)
+    v = GSL::Vector.alloc(0.59, 0.4, 0.01)
+
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(v), -0.5, 0.5, 0.59)
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(v),  0.5, 1.5, 0.40)
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(v),  1.5, 3.5, 0.01)
+
+    v = GSL::Vector.alloc(1, 9, 3, 4, 5, 8, 6, 7, 2, 0)
 
-    _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_moments(:discrete, GSL::Ran::Discrete.alloc(v), -0.5,  0.5, 1.0 / 45.0)
+    _test_moments(:discrete, GSL::Ran::Discrete.alloc(v),  8.5,  9.5, 0)
 
     _test_pdf(:beta,   2.0, 3.0)
     _test_pdf(:cauchy, 2.0)
@@ -119,4 +130,13 @@ class RandistTest < GSL::TestCase
     _test_pdf(:ugaussian_tail, 0.1, 2.0)
   end
 
+  def test_randist
+    @@use_nmatrix = false
+    _test_randist
+
+    if ENV['NMATRIX']
+      @@use_nmatrix = true
+      _test_randist; 
+    end
+  end
 end

data/test/test_helper.rb

@@ -1,4 +1,13 @@
 require 'test/unit'
+begin
+  require 'narray'
+rescue LoadError => e
+end
+
+begin
+  require 'nmatrix/nmatrix'
+rescue LoadError => e
+end
 require 'gsl'
 
 GSL::IEEE.env_setup
@@ -7,8 +16,9 @@ GSL::Rng.env_setup
 class GSL::TestCase < Test::Unit::TestCase
 
   def assert_factor(result, expected, factor, desc)
-    refute result == expected ? false : expected.zero? ? result != expected :
-      (u = result / expected; u > factor || u < 1.0 / factor),
+    refute result == expected ? false : (
+      expected.zero? ? result != expected :
+      (u = result / expected; u > factor || u < 1.0 / factor)),
       '%s (%.18g observed vs %.18g expected)' % [desc, result, expected]
   end
 
@@ -39,4 +49,22 @@ class GSL::TestCase < Test::Unit::TestCase
     assert((a - b).abs < (self.class::EPSREL * GSL.MIN(a.abs, b.abs) + self.class::EPSABS), msg)
   end
 
+  # Assert each element in an enumerable with absolute error.
+  def assert_enum_abs(result, expected, abserr, desc)
+    assert result.size == expected.size, 'size mismatch.'
+
+    r_enum = result.each
+    e_enum = expected.each
+
+    while true
+      begin
+        res_value = r_enum.next
+        exp_value = e_enum.next
+        assert_abs res_value, exp_value, abserr, "value mismatch. #{res_value} should be #{exp_value}"
+      rescue StopIteration
+        break
+      end
+    end
+  end
+
 end