rb-gsl 1.15.3.1

data/tests/diff.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "diff/test.c"
+require("gsl")
+require("./gsl_test.rb")
+include GSL::Test
+
+include Math
+
+f1 = GSL::Function.alloc { |x| exp(x) }
+df1 = GSL::Function.alloc { |x| exp(x) }
+
+f2 = GSL::Function.alloc { |x| 
+  if x >= 0.0; x*sqrt(x);
+  else; 0.0; end
+}
+df2 = GSL::Function.alloc { |x| 
+  if x >= 0.0; 1.5*sqrt(x);
+  else; 0.0; end
+}
+
+f3 = GSL::Function.alloc { |x| 
+  if x != 0.0; sin(1.0/x);
+  else; 0.0; end
+}
+df3 = GSL::Function.alloc { |x| 
+  if x != 0.0; -cos(1.0/x)/(x*x);
+  else; 0.0; end
+}
+
+f4 = GSL::Function.alloc { |x| exp(-x*x) }
+df4 = GSL::Function.alloc { |x| -2.0*x*exp(-x*x) }
+
+f5 = GSL::Function.alloc { |x| x*x }
+df5 = GSL::Function.alloc { |x| 2.0*x }
+
+f6 = GSL::Function.alloc { |x| 1.0/x }
+df6 = GSL::Function.alloc { |x| -1.0/(x*x) }
+
+def test_diff(diff, f, df, x, desc)
+  expected = df.eval(x)
+  case diff
+  when "central"
+    result, abserr = f.diff_central(x)
+  when "forward"
+    result, abserr = f.diff_forward(x)
+  when "backward"
+    result, abserr = f.diff_backward(x)
+  else
+    raise("undefined operation")
+  end
+  GSL::Test::test_abs(result, expected, abserr, desc)
+  desc2 = sprintf("%s, valid error estimate", desc)
+  GSL::Test::test((result - expected).abs > abserr, desc2)
+end
+
+test_diff("central", f1, df1, 1.0, "exp(x), x=1, central diff")
+test_diff("forward", f1, df1, 1.0, "exp(x), x=1, forward diff")
+test_diff("backward", f1, df1, 1.0, "exp(x), x=1, backward diff")
+
+test_diff("central", f2, df2, 0.1, "x^(3/2), x=0.1, central diff")
+test_diff("forward", f2, df2, 0.1, "x^(3/2), x=0.1, forward diff")
+test_diff("backward", f2, df2, 0.1, "x^(3/2), x=0.1, backward diff")
+
+test_diff("central", f3, df3, 0.45, "sin(1/x), x=0.45, central diff")
+test_diff("forward", f3, df3, 0.45, "sin(1/x), x=0.45, forward diff")
+test_diff("backward", f3, df3, 0.45, "sin(1/x), x=0.45, backward diff")
+
+test_diff("central", f4, df4, 0.5, "exp(-x^2), x=0.5, central diff")
+test_diff("forward", f4, df4, 0.5, "exp(-x^2), x=0.5, forward diff")
+test_diff("backward", f4, df4, 0.5, "exp(-x^2), x=0.5, backward diff")
+
+test_diff("central", f5, df5, 0.0, "x^2, x=0, central diff")
+test_diff("forward", f5, df5, 0.0, "x^2, x=0, forward diff")
+test_diff("backward", f5, df5, 0.0, "x^2, x=0, backward diff")
+
+test_diff("central", f6, df6, 10.0, "1/x, x=10, central diff")
+test_diff("forward", f6, df6, 10.0, "1/x, x=10, forward diff")
+test_diff("backward", f6, df6, 10.0, "1/x, x=10, backward diff")

data/tests/eigen/eigen.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "eigen/test.c"
+require("gsl")
+require("../gsl_test.rb")
+include GSL::Test
+
+def create_random_symm_matrix(size1, size2, rng, lower, upper)
+  m = GSL::Matrix.alloc(size1, size2)
+  for i in 0...size1 do
+    for j in i...size2 do
+      x = rng.uniform()*(upper-lower) + lower
+      m[i,j] = x
+      m[j,i] = x
+    end
+  end
+  m
+end
+
+def create_random_herm_matrix(size1, size2, rng, lower, upper)
+  m = GSL::Matrix::Complex.alloc(size1, size2)
+  for i in 0...size1 do
+    for j in i...size2 do
+      re = rng.uniform()* (upper - lower) + lower
+      if i == j
+      	im = 0.0
+      else
+        im = rng.uniform()* (upper - lower) + lower
+      end
+      z = GSL::Complex.alloc(re, im)
+      m[i,j] = z
+      m[j,i] = z.conjugate
+    end
+  end
+  m
+end
+
+def create_random_posdef_matrix(size1, size2, rng)
+  m = GSL::Matrix.alloc(size1, size2)
+  x = rng.uniform()
+  for i in 0...size1 do
+    for j in i...size2 do
+      a = pow(x, (j - i).to_f)
+      m[i,j] = a
+      m[j,i] = a
+    end
+  end
+  m
+end
+
+def create_random_complex_posdef_matrix(size1, size2, rng)
+  m = GSL::Matrix::Complex.calloc(size1, size2)
+  n = size1
+  
+  for i in 0...n do
+    x = rng.uniform()
+    z = GSL::Complex.alloc(x, 0.0)
+    m[i,i] = z
+  end
+  
+  work = GSL::Vector::Complex.alloc(n)
+  for i in 0...n do
+    for j in 0...n do
+      x = 2.0*rng.uniform() - 1.0
+      y = 2.0*rng.uniform() - 1.0			
+      z = GSL::Complex.alloc(x, y)
+      work[j] 
+    end
+    tau = GSL::Linalg::Complex::householder_transform(work)
+    GSL::Linalg::Complex::householder_hm(tau, work, m)
+    GSL::Linalg::Complex::householder_mh(tau.conjugate, work, m)		
+  end
+  m
+end
+
+def create_random_nonsymm_matrix(size1, size2, rng, lower, upper)
+  m = GSL::Matrix.alloc(size1, size2)
+  for i in 0...size1 do
+    for j in 0...size2 do
+      m[i,j] = rng.uniform()*(upper - lower) + lower
+    end
+  end
+  m
+end
+
+def test_eigen_results(n, m, eval, evec, desc, desc2)
+  x = GSL::Vector.alloc(n)
+  y = GSL::Vector.alloc(n)
+  
+  # check eigenvalues
+  for i in 0...n
+    ei = eval[i]
+    vi = evec.col(i)
+    GSL::Vector.memcpy(x, vi)
+    y = GSL::Blas.dgemv(GSL::Blas::NoTrans, 1.0, m, x, 0.0, y)
+#    y = GSL::Blas.dgemv(GSL::Blas::NoTrans, 1.0, m, x)
+    for j in 0...n
+      xj = x[j]
+      yj = y[j]
+      desc3 = sprintf("%s, eigenvalue(%d,%d), %s", desc, i, j, desc2)
+      GSL::Test::test_rel(yj, ei*xj, 1e8*DBL_EPSILON, desc3)
+    end
+  end
+# check eigenvectors are orthonormal
+  for i in 0...n
+    vi = evec.col(i)
+    nrm_v = GSL::Blas.dnrm2(vi)
+    desc3 = sprintf("%s, normalized(%d), %s", desc, i, desc2)
+    GSL::Test::test_rel(nrm_v, 1.0, n*DBL_EPSILON, desc3)
+  end
+
+  for i in 0...n
+    vi = evec.col(i)
+    for j in (i+1)...n
+      vj = evec.col(j)
+      vivj = GSL::Blas.ddot(vi, vj)
+      desc3 = sprintf("%s, orthogonal(%d,%d), %s", desc, i, j, desc2)
+      GSL::Test::test_abs(vivj, 0.0, n*DBL_EPSILON, desc3)
+    end
+  end
+end
+
+def test_eigen_complex_results(n, m, eval, evec, desc, desc2)
+  x = GSL::Vector::Complex.alloc(n)
+  y = GSL::Vector::Complex.alloc(n)
+
+# check eigenvalues
+  for i in 0...n
+    ei = eval[i]
+    vi = evec.col(i)
+    GSL::Vector::Complex.memcpy(x, vi)
+    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)
+    for j in 0...n
+      xj = x[j]
+      yj = y[j]
+      desc3 = sprintf("%s, eigenvalue(%d,%d), real, %s", desc, i, j, desc2)
+      GSL::Test::test_rel(yj.re, ei*xj.re, 1e8*DBL_EPSILON, desc3)
+      desc3 = sprintf("%s, eigenvalue(%d,%d), imag, %s", desc, i, j, desc2)
+      GSL::Test::test_rel(yj.im, ei*xj.im, 1e8*DBL_EPSILON, desc3)
+    end
+  end
+# check eigenvectors are orthonormal
+  for i in 0...n
+    vi = evec.col(i)
+    nrm_v = GSL::Blas.dznrm2(vi)
+    desc3 = sprintf("%s, normalized(%d), %s", desc, i, desc2)
+    GSL::Test::test_rel(nrm_v, 1.0, n*DBL_EPSILON, desc3)
+  end
+
+  for i in 0...n
+    vi = evec.col(i)
+    for j in (i+1)...n
+      vj = evec.col(j)
+      vivj = GSL::Blas.zdotc(vi, vj)
+      desc3 = sprintf("%s, orthogonal(%d,%d), %s", desc, i, j, desc2)
+      GSL::Test::test_abs(vivj.abs, 0.0, n*DBL_EPSILON, desc3)
+    end
+  end
+end
+
+def test_eigenvalues(n, eval, eval2, desc, desc2)
+  for i in 0...n
+    ei = eval[i]
+    e2i = eval2[i]
+    desc3 = sprintf("%s, direct eigenvalue(%d), %s", desc, i, desc2)
+    GSL::Test::test_rel(ei, e2i, GSL::DBL_EPSILON, desc3)
+  end
+end
+
+def chop_subnormals(x)
+  # Chop any subnormal values */
+  return x.abs < GSL::DBL_MIN ? 0 : x
+end
+
+def test_eigenvalues_real(eval, eval2, desc, desc2)
+  n = eval.size
+  emax = 0
+  # check eigenvalues 
+  for i in 0...n do
+    ei = eval[i]
+    if ei.abs > emax
+      emax = ei.abs
+    end
+  end
+  
+  for i in 0...n do
+    ei = eval[i]
+    e2i = chop_subnormals(eval2[i])
+    GSL::Test::test_abs(ei, e2i, emax * 1e8 * GSL::DBL_EPSILON,  "#{desc}, direct eigenvalue(#{i}), #{desc2}")
+  end
+end
+
+def test_eigenvalues_complex(eval, eval2, desc, desc2)
+  n = eval.size
+  for i in 0...n do
+    ei = eval[i]
+    e2i = eval2[i]
+    GSL::Test::test_rel(ei.real, e2i.real, 10*n*GSL::DBL_EPSILON, 
+                        "#{desc}, direct eigenvalue(#{i}) real, #{desc2}")
+    
+    GSL::Test::test_rel(ei.imag, e2i.imag, 10*n*GSL::DBL_EPSILON, 
+                        "#{desc}, direct eigenvalue(#{i}) imag, #{desc2}")		
+  end
+end
+
+def test_eigen_schur(a, s, q, z, count, desc, desc2)
+  n = a.size1
+  
+  t1 = a*z
+  t2 = q*s
+  for i in 0...n do
+    for j in 0...n do
+      x = t1[i,j]
+      y = t2[i,j]
+      GSL::test_abs(x, y, 1.0e8 * GSL::DBL_EPSILON,
+                    "#{desc}(N=#{n},cnt=#{count}), #{desc2}, schur(#{i},#{j})")
+    end
+  end
+end

data/tests/eigen/gen.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test.rb")
+require("eigen.rb")
+include GSL::Test
+
+def test_eigen_gen_results(a, b, alpha, beta, evec, count, desc, desc2)
+  n = a.size1
+  ma = a.to_complex
+  mb = b.to_complex
+  
+  for i in 0...n do
+    vi = evec.column(i)
+    ai = alpha[i]
+    bi = beta[i]
+    
+    x = mb*vi
+    x *= ai
+    
+    y = ma*vi
+    y *= bi
+    
+    for j in 0...n do
+      GSL::Test::test_abs(y[j].real, x[j].real, 1e8*GSL::DBL_EPSILON, 
+                          "gen(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), real, #{desc2}")
+      GSL::Test::test_abs(y[j].imag, x[j].imag, 1e8*GSL::DBL_EPSILON, 
+                          "gen(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), imag, #{desc2}")
+    end
+  end
+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, evec, 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, evec = GSL::Eigen::genv(aa, bb, wv)
+  end
+  
+  test_eigen_gen_results(a, b, alphav, betav, evec, 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
+  
+  eval = GSL::Vector::Complex.alloc(n)
+  evalv = GSL::Vector::Complex.alloc(n)	
+  for i in 0...n do
+    ai = alpha[i]
+    bi = beta[i]
+    z = GSL::Complex.alloc(ai.real/bi, ai.imag/bi)
+    eval[i] = z
+    
+    ai = alphav[i]
+    bi = betav[i]
+    z = GSL::Complex.alloc(ai.real/bi, ai.imag/bi)
+    evalv[i] = z
+  end
+  
+  GSL::Eigen::nonsymmv_sort(eval, nil, GSL::EIGEN_SORT_ABS_ASC)
+  GSL::Eigen::nonsymmv_sort(evalv, nil, GSL::EIGEN_SORT_ABS_ASC)
+  test_eigenvalues_complex(evalv, eval, "gen", desc)
+  
+  GSL::Eigen::genv_sort(alphav, betav, evec, GSL::EIGEN_SORT_ABS_ASC)
+  test_eigen_gen_results(a, b, alphav, betav, evec, count, desc, "abs/asc")
+  GSL::Eigen::genv_sort(alphav, betav, evec, GSL::EIGEN_SORT_ABS_DESC)
+  test_eigen_gen_results(a, b, alphav, betav, evec, count, desc, "abs/desc")
+end
+
+def test_eigen_gen()
+  n_max = 20
+  rng = GSL::Rng.alloc()
+  for n in 1..n_max do
+    w = GSL::Eigen::Gen.alloc(n)
+    wv = GSL::Eigen::Genv.alloc(n)		
+    for i in 0...5 do
+      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);
+    end
+  end
+  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
+
+test_eigen_gen()

data/tests/eigen/genherm.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test.rb")
+require("eigen.rb")
+include GSL::Test
+
+def test_eigen_genherm_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.nrm2
+    # check that eigenvector is normalized 
+    GSL::Test::test_rel(norm, 1.0, n * GSL::DBL_EPSILON,
+                   "genherm(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].real, x[j].real, 1e9 * GSL::DBL_EPSILON, 
+                       "genherm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), real, #{desc2}")
+	    GSL::Test::test_rel(y[j].imag, x[j].imag, 1e9 * GSL::DBL_EPSILON, 
+                       "genherm(N=#{n},cnt=#{count}), #{desc}, eigenvalue(#{i},#{j}), imag, #{desc2}")                       
+		end
+  end
+end
+
+def test_eigen_genherm()
+  n_max = 20
+	rng = GSL::Rng.alloc()
+	for n in 1..n_max do
+		w = GSL::Eigen::Genherm.alloc(n)
+		wv = GSL::Eigen::Genhermv.alloc(n)		
+		for i in 0...5 do
+			a = create_random_herm_matrix(n, n, rng, -10, 10)
+      b = create_random_complex_posdef_matrix(n, n, rng)
+
+			evalv, evec = GSL::Eigen::genhermv(a, b, wv)
+			test_eigen_genherm_results(a, b, evalv, evec, i, "random", "unsorted")
+	
+			eval = GSL::Eigen::genherm(a, b, w)
+
+			x = eval.sort
+			y = evalv.sort
+
+      test_eigenvalues_real(y, x, "genherm, random", "unsorted")
+			
+      GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_VAL_ASC);
+      test_eigen_genherm_results(a, b, evalv, evec, i, "random", "val/asc");
+
+      GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_VAL_DESC);
+      test_eigen_genherm_results(a, b, evalv, evec, i, "random", "val/desc");
+
+      GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_ABS_ASC);
+      test_eigen_genherm_results(a, b, evalv, evec, i, "random", "abs/asc");
+      GSL::Eigen::genhermv_sort(evalv, evec, GSL::EIGEN_SORT_ABS_DESC);
+      test_eigen_genherm_results(a, b, evalv, evec, i, "random", "abs/desc");
+		end
+	end
+end
+
+test_eigen_genherm()