rb-gsl 1.15.3.1 → 1.15.3.2

data/test/gsl/cheb_test.rb

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,563 @@
+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