rb-gsl 1.15.3.1

data/tests/linalg/bidiag.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test2.rb")
+require("./linalg.rb")
+include GSL::Test
+
+
+def test_bidiag_decomp_dim(m, eps)
+  s = 0
+  mm = m.size1
+  nn = m.size2
+  
+  a = m.duplicate
+  b = GSL::Matrix.calloc(nn, nn)
+  aa, tau1, tau2 = GSL::Linalg::Bidiag::decomp(a)
+  u, v, d, sd = GSL::Linalg::Bidiag::unpack(aa, tau1, tau2)
+  
+  b.set_diagonal(d)
+  for i in 0...(nn-1) do
+    b[i,i+1] = sd[i]
+  end
+  
+  a = u*b*v.trans  
+  
+  for i in 0...mm do
+    for j in 0...nn do
+      aij = a[i,j]
+      mij = m[i,j]
+      foo = check(aij, mij, eps);
+      if foo > 0
+        printf("(%3lu,%3lu)[%lu,%lu]: %22.18g   %22.18g\n", M, N, i,j, aij, mij);
+      end
+      s += foo;
+    end
+  end
+  return s
+end
+
+def test_bidiag_decomp()
+  s = 0
+  
+  m53 = create_general_matrix(5,3)
+  m97 = create_general_matrix(9,7)
+  
+  f = test_bidiag_decomp_dim(m53, 2 * 64.0 * GSL::DBL_EPSILON);
+  GSL::test(f, "  bidiag_decomp m(5,3)");
+  s += f;
+  
+  f = test_bidiag_decomp_dim(m97, 2 * 64.0 * GSL::DBL_EPSILON);
+  GSL::test(f, "  bidiag_decomp m(9,7)");
+  s += f;
+  
+  f = test_bidiag_decomp_dim(Hilb2, 2 * 8.0 * GSL::DBL_EPSILON);
+  GSL::test(f, "  bidiag_decomp hilbert(2)");
+  s += f;
+  
+  f = test_bidiag_decomp_dim(Hilb3, 2 * 64.0 * GSL::DBL_EPSILON);
+  GSL::test(f, "  bidiag_decomp hilbert(3)");
+  s += f;
+
+  f = test_bidiag_decomp_dim(Hilb4, 2 * 1024.0 * GSL::DBL_EPSILON);
+  GSL::test(f, "  bidiag_decomp hilbert(4)");
+  s += f;
+
+  f = test_bidiag_decomp_dim(Hilb12, 2 * 1024.0 * GSL::DBL_EPSILON);
+  GSL::test(f, "  bidiag_decomp hilbert(12)");
+  s += f;
+
+  return s;
+end
+
+test_bidiag_decomp()
+

data/tests/linalg/cholesky.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test2.rb")
+include GSL::Test
+include Linalg
+
+m = GSL::Matrix.pascal(6)
+
+p m
+c_exp = GSL::Matrix[[1, 0, 0, 0, 0, 0],
+               [1, 1, 0, 0, 0, 0],
+               [1, 2, 1, 0, 0, 0],
+               [1, 3, 3, 1, 0, 0],
+               [1, 4, 6, 4, 1, 0],
+               [1, 5, 10, 10, 5, 1]]
+
+c = m.cholesky_decomp
+a = c.lower
+test2(a == c_exp, "#{m.class}#cholesky_decomp") 
+test2((a*a.trans) == m, "#{m.class}#cholesky_decomp")

data/tests/linalg/linalg.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("../gsl_test2.rb")
+include GSL::Test
+
+def check(x, actual, eps)
+  if x == actual
+    return 0
+  elsif actual.zero?
+    return x.abs > eps ? 1 : 0
+  else
+    return ((x - actual).abs/actual.abs > eps) ? 1 : 0
+  end
+end
+
+def create_hilbert_matrix(size)
+  m = GSL::Matrix.alloc(size, size)
+  for i in 0...size
+    for j in 0...size
+      m.set(i, j, 1.0/(i+j+1.0))
+    end
+  end
+  return m
+end
+
+def create_general_matrix(size1, size2)
+  m = GSL::Matrix.alloc(size1, size2)
+  for i in 0...size1
+    for j in 0...size2
+      m.set(i, j, 1.0/(i+j+1.0))
+    end
+  end
+  return m
+end
+
+def create_singular_matrix(size1, size2)
+  m = create_general_matrix(size1, size2)
+  for j in 0...m.size2
+    m.set(0, j, 0.0)
+  end
+  return m
+end
+
+def create_vandermonde_matrix(size)
+  m = GSL::Matrix.alloc(size, size)
+  for i in 0...size
+    for j in 0...size
+      m.set(i, j, pow(i + 1.0, size - j - 1.0))
+    end
+  end
+  return m
+end
+
+def create_moler_matrix(size)
+  m = GSL::Matrix.alloc(size, size)
+  for i in 0...size
+    for j in 0...size
+      m.set(i, j, GSL::MIN(i+1, j+1) - 2.0)
+    end
+  end
+  return m
+end
+
+def create_complex_matrix(size)
+  m = GSL::Matrix::Complex.alloc(size, size)
+  for i in 0...size
+    for j in 0...size
+      z = GSL::Complex.alloc(1.0/(i+j+1.0), 1/(i*i+j*j+0.5))
+      m.set(i, j, z)
+    end
+  end
+  return m
+end
+
+def create_row_matrix(size1, size2)
+  m = GSL::Matrix.alloc(size1, size2)
+  for i in 0...size1
+    m.set(i, 0, 1.0/(i + 1.0))
+  end
+  return m
+end
+
+def create_2x2_matrix(a11, a12, a21, a22)
+  return GSL::Matrix.alloc(a11, a12, a21, a22)
+end
+
+def create_diagonal_matrix(a, size)
+  m = GSL::Matrix.alloc(size, size)
+  for i in 0...size
+    m.set(i, i, a[i])
+  end
+  return m
+end
+
+Hilb2 = create_hilbert_matrix(2)
+Hilb3 = create_hilbert_matrix(3)
+Hilb4 = create_hilbert_matrix(4)
+Hilb12 = create_hilbert_matrix(12)
+Vander2  = create_vandermonde_matrix(2)
+Vander3  = create_vandermonde_matrix(3)
+Vander4  = create_vandermonde_matrix(4)
+Vander12  = create_vandermonde_matrix(12)
+
+inf5_data = GSL::Vector.alloc(1.0, 0.0, -3.0, 0.0, -5.0)
+m53_lssolution = GSL::Vector.alloc(52.5992295702070, -337.7263113752073, 351.8823436427604)
+Hilb2_solution = GSL::Vector.alloc(-8.0, 18.0)
+Hilb3_solution = GSL::Vector.alloc(27.0, -192.0, 210.0)
+Hilb4_solution = GSL::Vector.alloc(-64.0, 900.0, -2520.0, 1820.0)
+Hilb12_solution = GSL::Vector.alloc(-1728.0, 245388.0, -8528520.0, 
+                             127026900.0, -1009008000.0, 4768571808.0, 
+                             -14202796608.0, 27336497760.0, -33921201600.0,
+                             26189163000.0, -11437874448.0, 2157916488.0)
+
+c7_solution = GSL::Vector.alloc(2.40717272023734e+01, -9.84612797621247e+00,
+                         -2.69338853034031e+02, 8.75455232472528e+01,
+                         2.96661356736296e+03, -1.02624473923993e+03,
+                         -1.82073812124749e+04, 5.67384473042410e+03,
+                         5.57693879019068e+04, -1.61540963210502e+04,
+                         -7.88941207561151e+04, 1.95053812987858e+04,
+                         3.95548551241728e+04, -7.76593696255317e+03)
+
+Vander2_solution = GSL::Vector.alloc(1.0, 0.0) 
+Vander3_solution = GSL::Vector.alloc(0.0, 1.0, 0.0) 
+Vander4_solution = GSL::Vector.alloc(0.0, 0.0, 1.0, 0.0) 
+Vander12_solution = GSL::Vector.alloc(0.0, 0.0, 0.0, 0.0,
+                            0.0, 0.0, 0.0, 0.0, 
+                            0.0, 0.0, 1.0, 0.0) 
+
+def test_matmult()
+  s = 0
+  a = GSL::Matrix.alloc([10.0, 5.0, 1.0, 20.0], 2, 2)
+  b = GSL::Matrix.alloc([10.0, 5.0, 2.0, 1.0, 3.0, 2.0], 2, 3)
+  c = a**b
+  s += ((c[0,0] - 105.0).abs > GSL::DBL_EPSILON) ? 1 : 0
+  s += ((c[0,1] -  65.0).abs > GSL::DBL_EPSILON) ? 1 : 0
+  s += ((c[0,2] -  30.0).abs > GSL::DBL_EPSILON) ? 1 : 0
+  s += ((c[1,0] -  30.0).abs > GSL::DBL_EPSILON) ? 1 : 0
+  s += ((c[1,1] -  65.0).abs > GSL::DBL_EPSILON) ? 1 : 0
+  s += ((c[1,2] -  42.0).abs > GSL::DBL_EPSILON) ? 1 : 0
+  return s
+end
+
+def test_matmult_mod()
+  s = 0
+  a = GSL::Matrix[[10.0, 5.0, 1.0], [1.0, 20.0, 5.0], [1.0, 3.0, 7.0]]
+  b = GSL::Matrix[[10.0, 5.0, 2.0], [1, 3, 2], [1, 3, 2]]
+  d = GSL::Matrix[[10, 5, 1], [1, 20, 5]]
+  
+end
+
+def test_LU_solve_dim(m, actual, eps)
+  dim = m.size1
+  s = 0
+  perm = Permutation.alloc(dim)
+  rhs = GSL::Vector[1..dim]
+  lu = m.clone
+
+end

data/tests/matrix/matrix_complex_test.rb

@@ -0,0 +1,36 @@
+require 'minitest/autorun'
+require 'minitest/unit'
+
+require 'gsl'
+
+class MatrixComplex < MiniTest::Unit::TestCase
+
+  def test_eye
+    z = GSL::Complex[1,0]
+    m = GSL::Matrix::Complex.eye(2, z)
+    assert_equal(z, m[0,0])
+    assert_equal(GSL::Complex[0,0], m[0,1])
+    assert_equal(GSL::Complex[0,0], m[1,0])
+    assert_equal(z, m[1,1])
+  end
+
+  def test_set_row
+    z0 = GSL::Complex[1,0]
+    z1 = GSL::Complex[2,0]
+    m = GSL::Matrix::Complex[2,2]
+    m.set_row(0,z0,z1)
+    assert_equal(z0, m[0,0])
+    assert_equal(z1, m[0,1])
+  end
+
+  def test_set_col
+    z0 = GSL::Complex[1,0]
+    z1 = GSL::Complex[2,0]
+    m = GSL::Matrix::Complex[2,2]
+    m.set_col(0,z0,z1)
+    assert_equal(z0, m[0,0])
+    assert_equal(z1, m[1,0])
+  end
+
+end
+

data/tests/matrix/matrix_nmf_test.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+# Written by Roman Shterenzon
+#
+#$:.unshift(*['lib','ext'].collect{|d| File.join(File.dirname(__FILE__),'..','..',d)})
+require 'rubygems'
+require 'test/unit'
+require 'gsl'
+
+class MatrixNmfTest < Test::Unit::TestCase
+
+  def setup
+    @m1 = GSL::Matrix.alloc([6, 7, 8], [2, 3, 4], [3, 4, 5])
+    @m2 = GSL::Matrix.alloc([6, 7, 8], [2, 3, 4], [3, 4, 7])
+  end
+
+  def test_difcost
+    assert_equal(0, GSL::Matrix::NMF.difcost(@m1, @m1))
+    assert_equal(4, GSL::Matrix::NMF.difcost(@m1, @m2))
+  end
+
+  def test_nmf
+    [2, 3, 4, 5].each do |cols|
+      res = GSL::Matrix::NMF.nmf(@m1, cols)
+      assert_equal([3,cols], res[0].size)
+      assert_equal([cols,3], res[1].size)
+      cost = GSL::Matrix::NMF.difcost(@m1, res[0]*res[1])
+      assert(cost <= 0.000001, "Cols: #{cols}, Delta: #{cost}")
+    end
+  end
+  def test_matrix_nmf
+    [2, 3, 4, 5].each do |cols|
+      res = @m1.nmf(cols)
+      assert_equal([3,cols], res[0].size)
+      assert_equal([cols,3], res[1].size)
+      cost = GSL::Matrix::NMF.difcost(@m1, res[0]*res[1])
+      assert(cost <= 0.000001, "Cols: #{cols}, Delta: #{cost}")
+    end
+  end
+end

data/tests/matrix/matrix_test.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/enm ruby
+
+require("gsl")
+require("test/unit")
+
+class MatrixTest < Test::Unit::TestCase
+
+	def test_matrix_ispos_neg
+		m = GSL::Matrix::Int.alloc([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+		assert_equal(m.ispos, 0)
+		assert_equal(m.ispos?, false)		
+		assert_equal(m.isneg, 0)
+		assert_equal(m.isneg?, false)
+		
+		m += 1
+		assert_equal(m.ispos, 1)
+		assert_equal(m.ispos?, true)		
+		assert_equal(m.isneg, 0)
+		assert_equal(m.isneg?, false)		
+		
+		m -= 100
+		assert_equal(m.ispos, 0)
+		assert_equal(m.ispos?, false)		
+		assert_equal(m.isneg, 1)
+		assert_equal(m.isneg?, true)				
+	end
+		
+	def test_matrix_isnonneg
+		m = GSL::Matrix::Int.alloc([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 3)
+		assert_equal(m.isnonneg, 1)
+		assert_equal(m.isnonneg?, true)		
+		assert_equal(m.isneg, 0)
+		assert_equal(m.isneg?, false)
+		
+		m -= 100
+		assert_equal(m.isnonneg, 0)
+		assert_equal(m.isnonneg?, false)		
+		assert_equal(m.isneg, 1)
+		assert_equal(m.isneg?, true)		
+		
+		m += 200
+		assert_equal(m.isnonneg, 1)
+		assert_equal(m.isnonneg?, true)		
+		assert_equal(m.ispos, 1)
+		assert_equal(m.ispos?, true)				
+	end
+end
+

data/tests/min.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# Ruby/GSL implementation of GSL "min/test.c"
+require("gsl")
+require("./gsl_test2.rb")
+include GSL::Test
+include Math
+
+GSL::IEEE::env_setup()
+
+EPSABS = 0.001
+EPSREL = 0.001
+MAX_ITERATIONS = 100
+
+def within_tol(a, b, epsrel, epsabs)
+  (a - b).abs < (epsrel*GSL::MIN(a.abs, b.abs) + epsabs)
+end
+
+def test_f(type, desc, f, lower, mid, upper, min)
+  x_lower = lower
+  x_upper = upper
+  s = GSL::Min::FMinimizer.alloc(type)
+  s.set(f, mid, x_lower, x_upper)
+  iterations = 0
+  begin
+    iterations += 1
+    status = s.iterate
+    m = s.x_minimum
+    a = s.x_lower
+    b = s.x_upper
+    if a > b
+      desc2 = sprintf("interval is invalid (%g,%g)", a, b)
+      GSL::Test::test(GSL::FAILURE, desc2)
+    end
+    if m < a or m > b
+      desc2 = sprintf("m lies outside interval %g (%g,%g)", m, a, b)
+      GSL::Test::test(GSL::FAILURE, desc2)
+    end
+    if status == 1; break; end
+    status = GSL::Min.test_interval(a, b, EPSABS, EPSREL)
+  end while status == GSL::CONTINUE and iterations < MAX_ITERATIONS
+  desc2 = sprintf("%s, %s (%g obs vs %g expected) ", s.name, desc, s.x_minimum, min)
+  GSL::Test::test(status, desc2)
+  if !within_tol(m, min, EPSREL, EPSABS)
+    desc2 = sprintf("incorrect precision (%g obs vs %g expected)", m, min)
+   GSL::Test::test(GSL::FAILURE, desc2)
+  end
+end
+
+def test_f_e(type, desc, f, lower, mid, upper, min)
+  x_lower = lower
+  x_upper = upper
+  s = GSL::Min::FMinimizer.alloc(type)
+  status = nil
+  begin
+    status = s.set(f, mid, x_lower, x_upper)
+  rescue
+  end
+  if status != GSL::SUCCESS
+    desc2 = sprintf("%s, %s", s.name, desc)
+    GSL::Test::test(status == GSL::SUCCESS ? 1 : 0, desc2)
+  end
+  iterations = 0
+  begin
+    iterations += 1
+    status = s.iterate
+    m = s.x_minimum
+    a = s.x_lower
+    b = s.x_upper
+    status = GSL::Min.test_interval(a, b, EPSABS, EPSREL)
+  rescue
+  end while status == GSL::CONTINUE and iterations < MAX_ITERATIONS
+#  desc2 = sprintf("%s, %s", s.name, desc)
+#  GSL::Test::test(status == 0 ? 0 : 1, desc2)
+end
+
+F_cos = GSL::Function.alloc { |x| cos(x) }
+Func1 = GSL::Function.alloc { |x| pow(x, 4.0) - 1 }
+Func2 = GSL::Function.alloc { |x| sqrt(x.abs) }
+Func3 = GSL::Function.alloc { |x| 
+  if x < 1.0
+    1
+  else
+    -exp(-x)
+  end
+}
+Func4 = GSL::Function.alloc { |x| x - 30.0/(1.0 + 1e5*pow(x - 0.8, 2.0)) }
+
+types = ["goldensection", "brent", "quad_golden"]
+types.each do |t|
+  test_f(t, "cos(x) [0 (3) 6]", F_cos, 0.0, 3.0, 6.0, M_PI)
+  test_f(t, "x^4 - 1 [-3 (-1) 17]", Func1, -3.0, -1.0, 17.0, 0.0);
+  test_f(t, "sqrt(|x|) [-2 (-1) 1.5]", Func2, -2.0, -1.0, 1.5, 0.0);
+  test_f(t, "func3(x) [-2 (3) 4]", Func3, -2.0, 3.0, 4.0, 1.0);
+  test_f(t, "func4(x) [0 (0.782) 1]", Func4, 0, 0.782, 1.0, 0.8);
+  
+  test_f_e(t, "invalid range check [4, 0]", F_cos, 4.0, 3.0, 0.0, M_PI);
+  test_f_e(t, "invalid range check [1, 1]", F_cos, 1.0, 1.0, 1.0, M_PI);
+  test_f_e(t, "invalid range check [-1, 1]", F_cos, -1.0, 0.0, 1.0, M_PI)
+end