rb-gsl 1.16.0.5 → 1.16.0.6

data/test/gsl/cheb_test.rb

@@ -1,80 +0,0 @@
-require 'test_helper'
-
-class ChebTest < GSL::TestCase
-
-  def test_cheb
-    tol, pi, order = 100.0 * GSL::DBL_EPSILON, GSL::M_PI, 40
-
-    cs = GSL::Cheb.alloc(order)
-
-    cs.init(GSL::Function.alloc { |x| 1.0 }, -1.0, 1.0)
-    order.times { |i|
-      assert_abs cs.c[i], i == 0 ? 2.0 : 0.0, tol, 'c[%d] for T_0(x)' % i
-    }
-
-    cs.init(GSL::Function.alloc { |x| x }, -1.0, 1.0)
-    order.times { |i|
-      assert_abs cs.c[i], i == 1 ? 1.0 : 0.0, tol, 'c[%d] for T_1(x)' % i
-    }
-
-    cs.init(GSL::Function.alloc { |x| 2.0 * x * x - 1.0 }, -1.0, 1.0)
-    order.times { |i|
-      assert_abs cs.c[i], i == 2 ? 1.0 : 0.0, tol, 'c[%d] for T_2(x)' % i
-    }
-
-    cs.init(GSL::Function.alloc { |x| Math.sin(x) }, -pi, pi)
-    assert_abs cs.c[0], 0.0, tol, 'c[0] for F_sin(x)'
-    assert_abs cs.c[1], 5.69230686359506e-01, tol, 'c[1] for F_sin(x)'
-    assert_abs cs.c[2], 0.0, tol, 'c[2] for F_sin(x)'
-    assert_abs cs.c[3], -6.66916672405979e-01, tol, 'c[3] for F_sin(x)'
-    assert_abs cs.c[4], 0.0, tol, 'c[4] for F_sin(x)'
-    assert_abs cs.c[5], 1.04282368734237e-01, tol, 'c[5] for F_sin(x)'
-
-    x = -pi
-    while x < pi
-      assert_abs cs.eval(x), Math.sin(x), tol, 'GSL::Cheb#eval, sin(%.3g)' % x
-      x += pi / 100.0
-    end
-
-    x = -pi
-    while x < pi
-      r, e = cs.eval_err(x)
-
-      assert_abs r, Math.sin(x), tol, 'GSL::Cheb#eval_err, sin(%.3g)' % x
-      assert_factor((r - Math.sin(x)).abs + GSL::DBL_EPSILON, e, 10.0,
-        'GSL::Cheb#eval_err, error sin(%.3g)' % x)
-
-      x += pi / 100.0
-    end
-
-    x = -pi
-    while x < pi
-      assert_abs cs.eval_n(25, x), Math.sin(x), tol, 'GSL::Cheb#eval_n, sin(%.3g)' % x
-      x += pi / 100.0
-    end
-
-    x = -pi
-    while x < pi
-      r, e = cs.eval_n_err(25, x)
-
-      assert_abs r, Math.sin(x), tol, 'GSL::Cheb#eval_n_err, sin(%.3g)' % x
-      assert_factor((r - Math.sin(x)).abs + GSL::DBL_EPSILON, e, 10.0,
-        'GSL::Cheb#eval_n_err, error sin(%.3g)' % x)
-
-      x += pi / 100.0
-    end
-
-    csd, x = cs.calc_deriv, -pi
-    while x < pi
-      assert_abs csd.eval(x), Math.cos(x), 1600 * tol, 'GSL::Cheb#eval, deriv sin(%.3g)' % x
-      x += pi / 100.0
-    end
-
-    csi, x = cs.calc_integ, -pi
-    while x < pi
-      assert_abs csi.eval(x), -(1 + Math.cos(x)), tol, 'GSL::Cheb#eval, integ sin(%.3g)' % x
-      x += pi / 100.0
-    end
-  end
-
-end

data/test/gsl/combination_test.rb

@@ -1,100 +0,0 @@
-require 'test_helper'
-
-class CombinationTest < GSL::TestCase
-
-  def setup
-    @c63 = GSL::Matrix.alloc(
-      [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5],
-      [0, 2, 3], [0, 2, 4], [0, 2, 5],
-      [0, 3, 4], [0, 3, 5],
-      [0, 4, 5],
-      [1, 2, 3], [1, 2, 4], [1, 2, 5],
-      [1, 3, 4], [1, 3, 5],
-      [1, 4, 5],
-      [2, 3, 4], [2, 3, 5], [2, 4, 5],
-      [3, 4, 5]
-    )
-  end
-
-  def test_6_3
-    c = GSL::Combination.alloc(6, 3)
-    c.init_first
-
-    status, i = false, 0
-
-    begin
-      if i >= 20
-        status = true
-        break
-      end
-
-      3.times { |j| status |= c.data[j] != @c63[i, j] }
-      refute c.valid?, 'GSL::Combination#valid(%u)' % i
-
-      i += 1
-    end while c.next == GSL::SUCCESS
-
-    refute status, 'GSL::Combination#next, 6 choose 3 combination, 20 steps'
-
-    3.times { c.next }
-    3.times { |j| status |= c.data[j] != @c63[19, j] }
-
-    refute status, 'GSL::Combination#prev on the first combination'
-    refute c.valid?, 'GSL::Combination#valid on the last combination'
-
-    d = GSL::Combination.alloc(6, 3)
-    GSL::Combination.memcpy(d, c)
-
-    status = false
-    3.times { |j| status |= d.data[j] != c.data[j] }
-    refute status, 'GSL::Combination.memcpy, 6 choose 3 combination'
-
-    c.init_last
-    i = 20
-
-    begin
-      if i == 0
-        status = true
-        break
-      end
-
-      i -= 1
-
-      3.times { |j| status |= c.data[j] != @c63[i, j] }
-      refute c.valid?, 'GSL::Combination#valid(%u)' % i
-    end while c.prev == GSL::SUCCESS
-
-    refute status, 'GSL::Combination#prev, 6 choose 3 combination, 20 steps'
-
-    3.times { c.prev }
-    3.times { |j| status |= c.data[j] != @c63[0, j] }
-
-    refute status, 'GSL::Combination#prev on the first combination'
-    refute c.valid?, 'GSL::Combination#valid on the first combination'
-
-    d = GSL::Combination.alloc(6, 3)
-    GSL::Combination.memcpy(d, c)
-
-    status = false
-    3.times { |j| status |= d.data[j] != c.data[j] }
-    refute status, 'GSL::Combination.memcpy, 6 choose 3 combination'
-  end
-
-  def test_7_0
-    c, desc = GSL::Combination.calloc(7, 0), 'GSL::Combination 7 choose 0'
-    2.times { assert c.next == GSL::FAILURE, desc }
-    2.times { assert c.prev == GSL::FAILURE, desc }
-  end
-
-  def test_7_7
-    c, desc = GSL::Combination.calloc(7, 7), 'GSL::Combination 7 choose 7'
-
-    3.times {
-      7.times { |j| assert c.get(j) == j, desc }
-      assert c.next == GSL::FAILURE, desc
-    }
-
-    7.times { |j| assert c.get(j) == j, desc }
-  end
-
-end

data/test/gsl/complex_test.rb

@@ -1,20 +0,0 @@
-require 'test_helper'
-
-class ComplexTest < GSL::TestCase
-
-  def test_complex
-    10.times { |i|
-      r = (i - 5.0) * 0.3
-      t = 2.0 * GSL::M_PI * i / 5.0
-
-      z = GSL::Complex.polar(r, t)
-
-      assert_rel z.real, r * Math.cos(t), 10 * GSL::DBL_EPSILON,
-        'gsl_complex_polar real part at (r=%g,t=%g)' % [r, t]
-
-      assert_rel z.imag, r * Math.sin(t), 10 * GSL::DBL_EPSILON,
-        'gsl_complex_polar imag part at (r=%g,t=%g)' % [r, t]
-    }
-  end
-
-end

data/test/gsl/const_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class ConstTest < GSL::TestCase
-
-  def test_speed_of_light
-    c   = GSL::CONST::MKSA::SPEED_OF_LIGHT
-    eps = GSL::CONST::MKSA::VACUUM_PERMITTIVITY
-    mu  = GSL::CONST::MKSA::VACUUM_PERMEABILITY
-
-    assert_rel c, 1.0 / GSL.sqrt(eps * mu), 1e-6, 'speed of light (mks)'
-  end
-
-  def test_light_year
-    ly = GSL::CONST::CGSM::LIGHT_YEAR
-    c  = GSL::CONST::CGSM::SPEED_OF_LIGHT
-    y  = 365.2425 * GSL::CONST::CGSM::DAY
-
-    assert_rel ly, c * y, 1e-6, 'light year (cgs)'
-  end
-
-  def test_kilo
-    micro = GSL::CONST::NUM::MICRO
-    mega  = GSL::CONST::NUM::MEGA
-    kilo  = GSL::CONST::NUM::KILO
-
-    assert_rel mega / kilo, 1 / (micro * kilo), 1e-10, 'kilo (mega/kilo, 1/(micro*kilo))'
-  end
-
-end

data/test/gsl/deriv_test.rb

@@ -1,62 +0,0 @@
-require 'test_helper'
-
-class DerivTest < GSL::TestCase
-
-  def setup
-    @f = [GSL::Function.alloc { |x| Math.exp(x) }]
-    @df = [GSL::Function.alloc { |x| Math.exp(x) }]
-
-    @f << GSL::Function.alloc { |x|
-      x >= 0.0 ? x * Math.sqrt(x) : 0.0
-    }
-    @df << GSL::Function.alloc { |x|
-      x >= 0.0 ? 1.5 * Math.sqrt(x) : 0.0
-    }
-
-    @f << GSL::Function.alloc { |x|
-      x != 0.0 ? Math.sin(1.0 / x) : 0.0
-    }
-    @df << GSL::Function.alloc { |x|
-      x != 0.0 ? -Math.cos(1.0 / x) / (x * x) : 0.0
-    }
-
-    @f << GSL::Function.alloc { |x| Math.exp(-x * x) }
-    @df << GSL::Function.alloc { |x| -2.0 * x * Math.exp(-x * x) }
-
-    @f << GSL::Function.alloc { |x| x * x }
-    @df << GSL::Function.alloc { |x| 2.0 * x }
-
-    @f << GSL::Function.alloc { |x| 1.0 / x }
-    @df << GSL::Function.alloc { |x| -1.0 / (x * x) }
-  end
-
-  {
-    'exp(x)'    => 1.0,
-    'x^(3/2)'   => 0.1,
-    'sin(1/x)'  => 0.45,
-    'exp(-x^2)' => 0.5,
-    'x^2'       => 0.0,
-    '1/x'       => 10.0
-  }.each_with_index { |(f, x), i|
-    %w[central forward backward].each { |deriv|
-      define_method("test_#{deriv}_#{i}") {
-        _test_deriv(deriv, @f[i], @df[i], x, "#{f}, x=#{x}, #{deriv} deriv")
-      }
-    }
-  }
-
-  def _test_deriv(deriv, f, df, x, desc)
-    expected, h = df.eval(x), 1e-4
-
-    result, abserr = f.send("deriv_#{deriv}", x, h)
-    assert_abs result, expected, GSL.MIN(h, expected.abs) + GSL::DBL_EPSILON, desc
-
-    if abserr < (diff = (result - expected).abs)
-      assert_factor abserr, (result - expected).abs, 2, desc + ' error estimate'
-    else
-      zero = result == expected || expected.zero?
-      assert_abs abserr, zero ? 0.0 : diff, zero ? 1e-6 : 1e6 * diff, desc + ' abserr'
-    end
-  end
-
-end

data/test/gsl/dht_test.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-
-class DhtTest < GSL::TestCase
-
-  N = 128
-
-  def test_dht1
-    vin = GSL::Vector.alloc(1, 2, 3)
-    dht = GSL::Dht.alloc(3, 1.0, 1.0)
-
-    vout = dht.apply(vin)
-
-    assert_equal  0.3752546494075203,  vout[0]
-    assert_equal(-0.13350787269556064, vout[1])
-    assert_equal  0.0446799251438404,  vout[2]
-
-    vin2 = dht.apply(vout)
-    vin2.scale!(13.323691936314223 ** 2)
-
-    assert_equal 1.0000119186762644, vin2[0]
-    assert_equal 1.9999790476647084, vin2[1]
-    assert_equal 3.000035803234503,  vin2[2]
-  end
-
-  def test_dht2
-    vin = GSL::Vector.alloc(N)
-    dht = GSL::Dht.alloc(N, 0.0, 100.0)
-
-    N.times { |i|
-      x = dht.x_sample(i)
-      vin[i] = 1.0 / (1.0 + x * x)
-    }
-
-    vout = dht.apply(vin)
-
-    assert_equal 3.999613382195876,   vout[0]
-    assert_equal 1.8387637474026606,  vout[5]
-    assert_equal 1.2677885358829588,  vout[10]
-    assert_equal 0.3521910403797792,  vout[35]
-    assert_equal 0.02373661279695407, vout[100]
-  end
-
-  def test_dht3
-    vin = GSL::Vector.alloc(N)
-    dht = GSL::Dht.alloc(N, 1.0, 20.0)
-
-    N.times { |i|
-      x = dht.x_sample(i)
-      vin[i] = Math.exp(-x)
-    }
-
-    vout = dht.apply(vin)
-
-    assert_equal 0.18148296716239096,   vout[0]
-    assert_equal 0.35680451269699853,   vout[5]
-    assert_equal 0.21101009980456306,   vout[10]
-    assert_equal 0.02892068100516861,   vout[35]
-    assert_equal 0.0022121119664674426, vout[100]
-  end
-
-  def test_dht4
-    vin = GSL::Vector.alloc(N)
-    dht = GSL::Dht.alloc(N, 1.0, 1.0)
-
-    N.times { |i|
-      x = dht.x_sample(i)
-      vin[i] = x * (1.0 - x * x)
-    }
-
-    vout = dht.apply(vin)
-
-    assert_equal  0.05727421417071144,    vout[0]
-    assert_equal(-0.0001908501261051786,  vout[5])
-    assert_equal  2.434180086051901e-05,  vout[10]
-    assert_equal(-4.0392713194195724e-07, vout[35])
-    assert_equal  8.255662619348403e-09,  vout[100]
-  end
-
-end

data/test/gsl/diff_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-class DiffTest < GSL::TestCase
-
-  def setup
-    @f = [GSL::Function.alloc { |x| Math.exp(x) }]
-    @df = [GSL::Function.alloc { |x| Math.exp(x) }]
-
-    @f << GSL::Function.alloc { |x|
-      x >= 0.0 ? x * Math.sqrt(x) : 0.0
-    }
-    @df << GSL::Function.alloc { |x|
-      x >= 0.0 ? 1.5 * Math.sqrt(x) : 0.0
-    }
-
-    @f << GSL::Function.alloc { |x|
-      x != 0.0 ? Math.sin(1.0 / x) : 0.0
-    }
-    @df << GSL::Function.alloc { |x|
-      x != 0.0 ? -Math.cos(1.0 / x) / (x * x) : 0.0
-    }
-
-    @f << GSL::Function.alloc { |x| Math.exp(-x * x) }
-    @df << GSL::Function.alloc { |x| -2.0 * x * Math.exp(-x * x) }
-
-    @f << GSL::Function.alloc { |x| x * x }
-    @df << GSL::Function.alloc { |x| 2.0 * x }
-
-    @f << GSL::Function.alloc { |x| 1.0 / x }
-    @df << GSL::Function.alloc { |x| -1.0 / (x * x) }
-  end
-
-  {
-    'exp(x)'    => 1.0,
-    'x^(3/2)'   => 0.1,
-    'sin(1/x)'  => 0.45,
-    'exp(-x^2)' => 0.5,
-    'x^2'       => 0.0,
-    '1/x'       => 10.0
-  }.each_with_index { |(f, x), i|
-    %w[central forward backward].each { |diff|
-      define_method("test_#{diff}_#{i}") {
-        expected = @df[i].eval(x)
-
-        result, abserr = @f[i].send("diff_#{diff}", x)
-        assert_abs result, expected, abserr, desc = "#{f}, x=#{x}, #{diff} diff"
-
-        refute((result - expected).abs > abserr, '%s, valid error estimate' % desc)
-      }
-    }
-  }
-
-end

data/test/gsl/eigen_test.rb

@@ -1,563 +0,0 @@
-require 'test_helper'
-
-class EigenTest < GSL::TestCase
-
-  def _create_random_symm_matrix(size1, size2, rng, lower, upper)
-    m = GSL::Matrix.alloc(size1, size2)
-
-    size1.times { |i|
-      size2.times { |j|
-        x = rng.uniform * (upper - lower) + lower
-        m[i, j] = x
-        m[j, i] = x
-      }
-    }
-
-    m
-  end
-
-  def _create_random_herm_matrix(size1, size2, rng, lower, upper)
-    m = GSL::Matrix::Complex.alloc(size1, size2)
-
-    size1.times { |i|
-      size2.times { |j|
-        z = GSL::Complex.alloc(rng.uniform * (upper - lower) + lower,
-          i == j ? 0.0 : rng.uniform * (upper - lower) + lower)
-
-        m[i, j] = z
-        m[j, i] = z.conjugate
-      }
-    }
-
-    m
-  end
-
-  def _create_random_posdef_matrix(size1, size2, rng)
-    m = GSL::Matrix.alloc(size1, size2)
-    x = rng.uniform
-
-    size1.times { |i|
-      i.upto(size2 - 1) { |j|
-        a = GSL.pow(x, (j - i).to_f)
-        m[i, j] = a
-        m[j, i] = a
-      }
-    }
-
-    m
-  end
-
-  def _create_random_complex_posdef_matrix(size1, size2, rng)
-    m = GSL::Matrix::Complex.calloc(size1, size2)
-    n = size1
-
-    n.times { |i| m[i, i] = GSL::Complex.alloc(rng.uniform, 0.0) }
-
-    work = GSL::Vector::Complex.alloc(n)
-
-    n.times { |i|
-      tau = GSL::Linalg::Complex.householder_transform(work)
-      GSL::Linalg::Complex.householder_hm(tau, work, m)
-      GSL::Linalg::Complex.householder_mh(tau.conjugate, work, m)
-    }
-
-    m
-  end
-
-  def _create_random_nonsymm_matrix(size1, size2, rng, lower, upper)
-    m = GSL::Matrix.alloc(size1, size2)
-
-    size1.times { |i|
-      size2.times { |j|
-        m[i, j] = rng.uniform * (upper - lower) + lower
-      }
-    }
-
-    m
-  end
-
-  def _test_eigen_results(n, m, e_val, e_vec, desc, desc2)
-    x = GSL::Vector.alloc(n)
-    y = GSL::Vector.alloc(n)
-
-    n.times { |i|
-      ei = e_val[i]
-
-      GSL::Vector.memcpy(x, e_vec.col(i))
-      y = GSL::Blas.dgemv(GSL::Blas::NoTrans, 1.0, m, x, 0.0, y)
-
-      n.times { |j|
-        assert_rel y[j], ei * x[j], 1e8 * GSL::DBL_EPSILON,
-          '%s, eigenvalue(%d,%d), %s' % [desc, i, j, desc2]
-      }
-    }
-
-    n.times { |i|
-      assert_rel GSL::Blas.dnrm2(e_vec.col(i)), 1.0, n * GSL::DBL_EPSILON,
-        '%s, normalized(%d), %s' % [desc, i, desc2]
-    }
-
-    n.times { |i|
-      vi = e_vec.col(i)
-
-      (i + 1).upto(n - 1) { |j|
-        assert_abs GSL::Blas.ddot(vi, e_vec.col(j)), 0.0, n * GSL::DBL_EPSILON,
-          '%s, orthogonal(%d,%d), %s' % [desc, i, j, desc2]
-      }
-    }
-  end
-
-  def _test_eigen_complex_results(n, m, e_val, e_vec, desc, desc2)
-    x = GSL::Vector::Complex.alloc(n)
-    y = GSL::Vector::Complex.alloc(n)
-
-    n.times { |i|
-      ei = e_val[i]
-      GSL::Vector::Complex.memcpy(x, e_vec.col(i))
-
-      c1 = GSL::Complex.alloc(1.0, 0.0)
-      c0 = GSL::Complex.alloc(0.0, 0.0)
-      y = GSL::Blas.zgemv(GSL::Blas::NoTrans, c1, m, x, c0, y)
-
-      n.times { |j|
-        xj = x[j]
-        yj = y[j]
-
-        assert_rel yj.re, ei * xj.re, 1e8 * GSL::DBL_EPSILON,
-          '%s, eigenvalue(%d,%d), real, %s' % [desc, i, j, desc2]
-        assert_rel yj.im, ei * xj.im, 1e8 * GSL::DBL_EPSILON,
-          '%s, eigenvalue(%d,%d), imag, %s' % [desc, i, j, desc2]
-      }
-    }
-
-    n.times { |i|
-      assert_rel GSL::Blas.dznrm2(e_vec.col(i)), 1.0, n * GSL::DBL_EPSILON,
-        '%s, normalized(%d), %s' % [desc, i, desc2]
-    }
-
-    n.times { |i|
-      vi = e_vec.col(i)
-
-      (i + 1).upto(n - 1) { |j|
-        assert_abs GSL::Blas.zdotc(vi, e_vec.col(j)).abs, 0.0, n * GSL::DBL_EPSILON,
-          '%s, orthogonal(%d,%d), %s' % [desc, i, j, desc2]
-      }
-    }
-  end
-
-  def _test_eigenvalues(n, e_val, e_val2, desc, desc2)
-    n.times { |i|
-      assert_rel e_val[i], e_val2[i], GSL::DBL_EPSILON,
-        '%s, direct eigenvalue(%d), %s' % [desc, i, desc2]
-    }
-  end
-
-  def _test_eigenvalues_real(e_val, e_val2, desc, desc2)
-    n, emax = e_val.size, 0
-
-    n.times { |i|
-      e = e_val[i].abs
-      emax = e if e > emax
-    }
-
-    n.times { |i|
-      e2i = e_val2[i]
-      assert_abs e_val[i], e2i.abs < GSL::DBL_MIN ? 0 : e2i, emax * 1e8 * GSL::DBL_EPSILON,
-        "#{desc}, direct eigenvalue(#{i}), #{desc2}"
-    }
-  end
-
-  def _test_eigenvalues_complex(e_val, e_val2, desc, desc2)
-    n = e_val.size
-
-    n.times { |i|
-      assert_rel e_val[i].real, e_val2[i].real, 10 * n * GSL::DBL_EPSILON,
-        "#{desc}, direct eigenvalue(#{i}) real, #{desc2}"
-      assert_rel e_val[i].imag, e_val2[i].imag, 10 * n * GSL::DBL_EPSILON,
-        "#{desc}, direct eigenvalue(#{i}) imag, #{desc2}"
-    }
-  end
-
-  def _test_eigen_schur(a, s, q, z, count, desc, desc2)
-    n = a.size1
-
-    t1 = a * z
-    t2 = q * s
-
-    n.times { |i|
-      n.times { |j|
-        assert_abs t1[i, j], t2[i, j], 1.0e8 * GSL::DBL_EPSILON,
-          "#{desc}(N=#{n},cnt=#{count}), #{desc2}, schur(#{i},#{j})"
-      }
-    }
-  end
-
-  def _test_eigen_genherm_results(a, b, e_val, e_vec, count, desc, desc2)
-    n = a.size1
-
-    n.times { |i|
-      vi = e_vec.column(i)
-
-      assert_rel vi.nrm2, 1.0, n * GSL::DBL_EPSILON,
-        "genherm(N=#{n},cnt=#{count}), #{desc}, normalized(#{i}), #{desc2}"
-
-      y = a * vi
-      x = (b * vi) * e_val[i]
-
-      n.times { |j|
-        assert_rel y[j].real, x[j].real, 1e9 * GSL::DBL_EPSILON,
-          "genherm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), real, #{desc2}"
-        assert_rel y[j].imag, x[j].imag, 1e9 * GSL::DBL_EPSILON,
-          "genherm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), imag, #{desc2}"
-      }
-    }
-  end
-
-  def test_eigen_genherm
-    rng = GSL::Rng.alloc
-
-    1.upto(20) { |n|
-      w = GSL::Eigen::Genherm.alloc(n)
-      wv = GSL::Eigen::Genhermv.alloc(n)
-
-      5.times { |i|
-        a = _create_random_herm_matrix(n, n, rng, -10, 10)
-        b = _create_random_complex_posdef_matrix(n, n, rng)
-
-        e_valv, e_vec = GSL::Eigen.genhermv(a, b, wv)
-        _test_eigen_genherm_results(a, b, e_valv, e_vec, i, 'random', 'unsorted')
-
-        e_val = GSL::Eigen.genherm(a, b, w)
-
-        x = e_val.sort
-        y = e_valv.sort
-
-        _test_eigenvalues_real(y, x, 'genherm, random', 'unsorted')
-
-        GSL::Eigen.genhermv_sort(e_valv, e_vec, GSL::EIGEN_SORT_VAL_ASC)
-        _test_eigen_genherm_results(a, b, e_valv, e_vec, i, 'random', 'val/asc')
-
-        GSL::Eigen.genhermv_sort(e_valv, e_vec, GSL::EIGEN_SORT_VAL_DESC)
-        _test_eigen_genherm_results(a, b, e_valv, e_vec, i, 'random', 'val/desc')
-
-        GSL::Eigen.genhermv_sort(e_valv, e_vec, GSL::EIGEN_SORT_ABS_ASC)
-        _test_eigen_genherm_results(a, b, e_valv, e_vec, i, 'random', 'abs/asc')
-        GSL::Eigen.genhermv_sort(e_valv, e_vec, GSL::EIGEN_SORT_ABS_DESC)
-        _test_eigen_genherm_results(a, b, e_valv, e_vec, i, 'random', 'abs/desc')
-      }
-    }
-  end
-
-  def _test_eigen_gen_results(a, b, alpha, beta, e_vec, count, desc, desc2)
-    n = a.size1
-
-    ma = a.to_complex
-    mb = b.to_complex
-
-    n.times { |i|
-      vi = e_vec.column(i)
-
-      x = (mb * vi) * alpha[i]
-      y = (ma * vi) * beta[i]
-
-      n.times { |j|
-        assert_abs y[j].real, x[j].real, 1e8 * GSL::DBL_EPSILON,
-          "gen(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), real, #{desc2}"
-        assert_abs y[j].imag, x[j].imag, 1e8 * GSL::DBL_EPSILON,
-          "gen(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), imag, #{desc2}"
-      }
-    }
-  end
-
-  def _test_eigen_gen_pencil(a, b, count, desc, test_schur, w, wv)
-    n = a.size1
-
-    aa = a.clone
-    bb = b.clone
-
-    if test_schur == 1
-      alphav, betav, e_vec, q, z = GSL::Eigen.genv_QZ(aa, bb, wv)
-      _test_eigen_schur(a, aa, q, z, count, 'genv/A', desc)
-      _test_eigen_schur(b, bb, q, z, count, 'genv/B', desc)
-    else
-      alphav, betav, e_vec = GSL::Eigen.genv(aa, bb, wv)
-    end
-
-    _test_eigen_gen_results(a, b, alphav, betav, e_vec, count, desc, 'unsorted')
-
-    aa = a.clone
-    bb = b.clone
-
-    if test_schur == 1
-      GSL::Eigen.gen_params(1, 1, 0, w)
-
-      alpha, beta, q, z = GSL::Eigen.gen_QZ(aa, bb, w)
-      _test_eigen_schur(a, aa, q, z, count, 'gen/A', desc)
-      _test_eigen_schur(b, bb, q, z, count, 'gen/B', desc)
-    else
-      GSL::Eigen.gen_params(0, 0, 0, w)
-      alpha, beta = GSL::Eigen.gen(aa, bb, w)
-    end
-
-    e_val = GSL::Vector::Complex.alloc(n)
-    e_valv = GSL::Vector::Complex.alloc(n)
-
-    n.times { |i|
-      ai = alpha[i]
-      bi = beta[i]
-      e_val[i] = GSL::Complex.alloc(ai.real / bi, ai.imag / bi)
-
-      ai = alphav[i]
-      bi = betav[i]
-      e_valv[i] = GSL::Complex.alloc(ai.real / bi, ai.imag / bi)
-    }
-
-    GSL::Eigen.nonsymmv_sort(e_val, nil, GSL::EIGEN_SORT_ABS_ASC)
-    GSL::Eigen.nonsymmv_sort(e_valv, nil, GSL::EIGEN_SORT_ABS_ASC)
-    _test_eigenvalues_complex(e_valv, e_val, 'gen', desc)
-
-    GSL::Eigen.genv_sort(alphav, betav, e_vec, GSL::EIGEN_SORT_ABS_ASC)
-    _test_eigen_gen_results(a, b, alphav, betav, e_vec, count, desc, 'abs/asc')
-    GSL::Eigen.genv_sort(alphav, betav, e_vec, GSL::EIGEN_SORT_ABS_DESC)
-    _test_eigen_gen_results(a, b, alphav, betav, e_vec, count, desc, 'abs/desc')
-  end
-
-  def test_eigen_gen
-    rng = GSL::Rng.alloc
-
-    1.upto(20) { |n|
-      w = GSL::Eigen::Gen.alloc(n)
-      wv = GSL::Eigen::Genv.alloc(n)
-
-      5.times { |i|
-        a = _create_random_nonsymm_matrix(n, n, rng, -10, 10)
-        b = _create_random_nonsymm_matrix(n, n, rng, -10, 10)
-        _test_eigen_gen_pencil(a, b, i, 'random', 0, w, wv)
-        _test_eigen_gen_pencil(a, b, i, 'random', 1, w, wv)
-      }
-    }
-
-    ma = GSL::Matrix.alloc([1, 1, 0, 0, 0, -1, 1, 0, 0], 3, 3)
-    mb = GSL::Matrix.alloc([-1, 0, -1, 0, -1, 0, 0, 0, -1], 3, 3)
-
-    w = GSL::Eigen::Gen.alloc(3)
-    wv = GSL::Eigen::Genv.alloc(3)
-
-    _test_eigen_gen_pencil(ma, mb, 0, 'integer', 0, w, wv)
-    _test_eigen_gen_pencil(ma, mb, 0, 'integer', 1, w, wv)
-  end
-
-  def _test_eigen_gensymm_results(a, b, e_val, e_vec, count, desc, desc2)
-    n = a.size1
-
-    n.times { |i|
-      vi = e_vec.column(i)
-
-      assert_rel vi.dnrm2, 1.0, n * GSL::DBL_EPSILON,
-        "gensymm(N=#{n},cnt=#{count}), #{desc}, normalized(#{i}), #{desc2}"
-
-      y = a * vi
-      x = (b * vi) * e_val[i]
-
-      n.times { |j|
-        assert_rel y[j], x[j], 1e9 * GSL::DBL_EPSILON,
-          "gensymm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), #{desc2}"
-      }
-    }
-  end
-
-  def test_eigen_gensymm
-    rng = GSL::Rng.alloc
-
-    1.upto(20) { |n|
-      w  = GSL::Eigen::Gensymm::Workspace.alloc(n)
-      wv = GSL::Eigen::Gensymmv::Workspace.alloc(n)
-
-      5.times { |i|
-        a = _create_random_symm_matrix(n, n, rng, -10, 10)
-        b = _create_random_posdef_matrix(n, n, rng)
-
-        e_valv, e_vec = GSL::Eigen.gensymmv(a.clone, b.clone, wv)
-        _test_eigen_gensymm_results(a, b, e_valv, e_vec, i, 'random', 'unsorted')
-
-        x = GSL::Eigen.gensymm(a.clone, b.clone, w).sort
-        y = e_valv.sort
-
-        _test_eigenvalues_real(y, x, 'gensymm, random', 'unsorted')
-
-        GSL::Eigen::Gensymmv.sort(e_valv, e_vec, GSL::EIGEN_SORT_VAL_ASC)
-        _test_eigen_gensymm_results(a, b, e_valv, e_vec, i, 'random', 'val/asc')
-
-        GSL::Eigen::Gensymmv.sort(e_valv, e_vec, GSL::EIGEN_SORT_VAL_DESC)
-        _test_eigen_gensymm_results(a, b, e_valv, e_vec, i, 'random', 'val/desc')
-
-        GSL::Eigen::Gensymmv.sort(e_valv, e_vec, GSL::EIGEN_SORT_ABS_ASC)
-        _test_eigen_gensymm_results(a, b, e_valv, e_vec, i, 'random', 'abs/asc')
-        GSL::Eigen::Gensymmv.sort(e_valv, e_vec, GSL::EIGEN_SORT_ABS_DESC)
-        _test_eigen_gensymm_results(a, b, e_valv, e_vec, i, 'random', 'abs/desc')
-      }
-    }
-  end
-
-  def test_nonsymm
-    m = GSL::Matrix[[1, 2], [3, 2]]
-    e_val = m.eigen_nonsymm.real.sort
-    assert_abs e_val[0], -1, 0, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[1], 4, 0, 'GSL::Matrix::eigen_nonsymm'
-
-    m = GSL::Matrix[[1, 4, 2, 3], 2, 2]
-    e_val = m.eigen_nonsymm.real.sort
-    assert_abs e_val[0], -1, 0, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[1], 5, 0, 'GSL::Matrix::eigen_nonsymm'
-
-    m = GSL::Matrix[[2, 4], [3, 1]]
-    e_val = m.eigen_nonsymm.real.sort
-    assert_abs e_val[0], -2, 0, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[1], 5, 0, 'GSL::Matrix::eigen_nonsymm'
-
-    m = GSL::Matrix[[5, 6, 3, 2], 2, 2]
-    e_val = m.eigen_nonsymm.real.sort
-    assert_abs e_val[0], -1, 0, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[1], 8, 0, 'GSL::Matrix::eigen_nonsymm'
-
-    m = GSL::Matrix[[4, 1, -1, 2, 5, -2, 1, 1, 2], 3, 3]
-    e_val = m.eigen_nonsymm.real.sort
-    assert_abs e_val[0], 3, 1e-10, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[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
-    #assert_abs e_val[2], 5, 0, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[2], 4.99999999999999911, 0, 'GSL::Matrix::eigen_nonsymm'
-
-    m = GSL::Matrix[[-3, 1, -1], [-7, 5, -1], [-6, 6, -2]]
-    e_val = m.eigen_nonsymm.real.sort
-    assert_abs e_val[0], -2, 1e-6, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[1], -2, 1e-6, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[2], 4, 1e-10, 'GSL::Matrix::eigen_nonsymm'
-
-    m = GSL::Matrix[[11, -8, 4, -8, -1, -2, 4, -2, -4], 3, 3]
-    e_val = m.eigen_nonsymm.real.sort
-    assert_abs e_val[0], -5, 1e-10, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[1], -5, 1e-10, 'GSL::Matrix::eigen_nonsymm'
-    assert_abs e_val[2], 16, 1e-10, 'GSL::Matrix::eigen_nonsymm'
-  end
-
-  def _test_nonsymmv2(m, eps)
-    m2 = m.clone
-
-    e_val, e_vec = m2.eigen_nonsymmv
-    e_valre = e_val.real
-    e_vecre = e_vec.real
-
-    a = e_vecre.inv * m * e_vecre
-
-    assert_abs a[0, 0], e_valre[0], eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[1, 1], e_valre[1], eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[0, 1], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[1, 0], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-  end
-
-  def _test_nonsymmv3(m, eps)
-    m2 = m.clone
-
-    e_val, e_vec = m2.eigen_nonsymmv
-    e_valre = e_val.real
-    e_vecre = e_vec.real
-
-    a = e_vecre.inv * m * e_vecre
-
-    assert_abs a[0, 0], e_valre[0], eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[1, 1], e_valre[1], eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[2, 2], e_valre[2], eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[0, 1], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[0, 2], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[1, 0], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[1, 2], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[2, 0], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-    assert_abs a[2, 1], 0, eps, 'GSL::Matrix::eigen_nonsymmv'
-  end
-
-  def test_nonsymmv
-    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)
-  end
-
-  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)
-    e_val, e_vec = a.eigen_symmv(w2)
-    _test_eigen_results(n, m, e_val, e_vec, desc, 'unsorted')
-
-    GSL::Matrix.memcpy(a, m)
-    e_val2 = a.eigen_symm(w1)
-    _test_eigenvalues(n, e_val, e_val2, desc, 'unsorted')
-
-    GSL::Eigen::Symmv.sort(e_val, e_vec, GSL::Eigen::SORT_VAL_ASC)
-    _test_eigen_results(n, m, e_val, e_vec, desc, 'val/asc')
-    GSL::Eigen::Symmv.sort(e_val, e_vec, GSL::Eigen::SORT_VAL_DESC)
-    _test_eigen_results(n, m, e_val, e_vec, desc, 'val/desc')
-    GSL::Eigen::Symmv.sort(e_val, e_vec, GSL::Eigen::SORT_ABS_ASC)
-    _test_eigen_results(n, m, e_val, e_vec, desc, 'abs/asc')
-    GSL::Eigen::Symmv.sort(e_val, e_vec, GSL::Eigen::SORT_ABS_DESC)
-    _test_eigen_results(n, m, e_val, e_vec, 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)
-    e_val, e_vec = a.eigen_hermv(w2)
-    _test_eigen_complex_results(n, m, e_val, e_vec, desc, 'unsorted')
-
-    GSL::Matrix::Complex.memcpy(a, m)
-    e_val2 = a.eigen_herm(w1)
-    _test_eigenvalues(n, e_val, e_val2, desc, 'unsorted')
-
-    GSL::Eigen::Hermv.sort(e_val, e_vec, GSL::Eigen::SORT_VAL_ASC)
-    _test_eigen_complex_results(n, m, e_val, e_vec, desc, 'val/asc')
-    GSL::Eigen::Hermv.sort(e_val, e_vec, GSL::Eigen::SORT_VAL_DESC)
-    _test_eigen_complex_results(n, m, e_val, e_vec, desc, 'val/desc')
-    GSL::Eigen::Hermv.sort(e_val, e_vec, GSL::Eigen::SORT_ABS_ASC)
-    _test_eigen_complex_results(n, m, e_val, e_vec, desc, 'abs/asc')
-    GSL::Eigen::Hermv.sort(e_val, e_vec, GSL::Eigen::SORT_ABS_DESC)
-    _test_eigen_complex_results(n, m, e_val, e_vec, desc, 'abs/desc')
-  end
-
-  def test_symm_herm
-    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)
-    _test_eigen_herm('herm(4)', r.to_complex)
-
-    r = GSL::Matrix.alloc(4, 4)
-    r.set_diagonal([1, 2, 3, 4])
-    _test_eigen_symm('symm(4) diag', r)
-    _test_eigen_herm('herm(4) diag', r.to_complex)
-  end
-
-end