gsl 1.15.3 → 1.16.0.6

data/tests/diff.rb

@@ -1,78 +0,0 @@
-#!/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

@@ -1,220 +0,0 @@
-#!/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

@@ -1,105 +0,0 @@
-#!/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

@@ -1,66 +0,0 @@
-#!/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()