rb-gsl 1.15.3.1 → 1.15.3.2

data/tests/tensor.rb

@@ -1,419 +0,0 @@
-#!/usr/bin/env ruby
-# NOTE: gsl_tensor is not included in GSL:
-#       It is distributed separately as an add-on package for GSL.
-#       See http://sources.redhat.com/ml/gsl-discuss/2004-q4/msg00053.html.
-#
-require("gsl")
-require("./gsl_test2.rb")
-include GSL::Test
-
-exit unless GSL.const_defined?("Tensor")
-
-RANK = 3
-DIMENSION = 5
-
-t = GSL::Tensor.alloc(RANK, DIMENSION)
-
-Test::test2(t.rank == RANK, "#{t.class}.alloc returns valid rank")
-Test::test2(t.dimension == DIMENSION, "#{t.class}_alloc returns valid dimension")
-
-counter = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      counter += 1
-      t.set(i, j, k, counter)
-#      t[i, j, k] = counter 
-    end
-  end
-end
-
-status = 0
-counter = 0
-data = t.data    # GSL::Vector::View
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      counter += 1
-      if data[DIMENSION*DIMENSION*i + DIMENSION*j + k] != counter
-        status += 1
-      end
-    end
-  end
-end
-
-Test::test(status, "#{t.class}#set writes into array")
-
-status = 0
-counter = 0
-data = t.data
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      counter += 1
-#      if t.get(i, j, k) != counter
-      if t[i, j, k] != counter
-        status += 1
-      end
-    end
-  end
-end
-
-Test::test(status, "#{t.class}#get reads from array")
-
-t = Tensor.calloc(RANK, DIMENSION)
-
-counter = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      counter += 1
-      t.set(i, j, k, counter)
-    end
-  end
-end
-
-exp_max = t[0, 0, 0]
-exp_min = t[0, 0, 0]
-exp_imax = exp_jmax = exp_kmax = 0
-exp_imin = exp_jmin = exp_kmin = 0
-
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      value = t[i, j, k]
-      if value > exp_max
-        exp_max = value
-        exp_imax = i; exp_jmax = j; exp_kmax = k
-      end
-      if value < exp_min
-        exp_min = t[i, j, k]
-        exp_imin = i; exp_jmin = j; exp_kmin = k
-      end
-    end
-  end
-end
-
-max = t.max
-Test::test2(max == exp_max, "#{t.class}#max returns correct maximum value")
-min = t.min
-Test::test2(min == exp_min, "#{t.class}#min returns correct minimum value")
-
-min, max = t.minmax
-Test::test2(max == exp_max, "#{t.class}#minmax returns correct maximum value")
-Test::test2(min == exp_min, "#{t.class}#minmax returns correct minimum value")
-
-imax = t.max_index
-status = 0
-if imax[0] != exp_imax; status += 1; end
-if imax[1] != exp_jmax; status += 1; end
-if imax[2] != exp_kmax; status += 1; end
-Test::test(status, "#{t.class}#max_index returns correct maximum indices")
-
-imin = t.min_index
-status = 0
-if imin[0] != exp_imin; status += 1; end
-if imin[1] != exp_jmin; status += 1; end
-if imin[2] != exp_kmin; status += 1; end
-Test::test(status, "#{t.class}#min_index returns correct minimum indices")
-
-
-imin, imax = t.minmax_index
-status = 0
-if imin[0] != exp_imin; status += 1; end
-if imin[1] != exp_jmin; status += 1; end
-if imin[2] != exp_kmin; status += 1; end
-if imax[0] != exp_imax; status += 1; end
-if imax[1] != exp_jmax; status += 1; end
-if imax[2] != exp_kmax; status += 1; end
-Test::test(status, "#{t.class}#minmax_index returns correct indices")
-
-##### Operations
-a = Tensor.new(RANK, DIMENSION)
-b = Tensor.new(RANK, DIMENSION)
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      a[i, j, k] = 3 + i + 5 * j + 2 * k
-      b[i, j, k] = 3 + 2 * i + 4 * j + k
-    end
-  end
-end
-
-# Addition
-c = a + b   
-#c = a.add(b)
-status = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      r = c[i, j, k]
-      x = a[i, j, k]
-      y = b[i, j, k]
-      z = x + y
-      status += 1 if r != z
-    end
-  end
-end
-Test::test(status, "#{t.class}#add tensor addition")
-
-# Subtraction
-c = a - b  
-# c = a.sub(b)
-status = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      r = c[i, j, k]
-      x = a[i, j, k]
-      y = b[i, j, k]
-      z = x - y
-      status += 1 if r != z
-    end
-  end
-end
-Test::test(status, "#{t.class}#sub tensor subtraction")
-
-# Element multiplication
- c = a.mul_elements(b)
-status = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      r = c[i, j, k]
-      x = a[i, j, k]
-      y = b[i, j, k]
-      z = x * y
-      status += 1 if r != z
-    end
-  end
-end
-Test::test(status, "#{t.class}#mul_elements element multiplication")
-
-# Element division
-c = a.div_elements(b)
-status = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      r = c[i, j, k]
-      x = a[i, j, k]
-      y = b[i, j, k]
-      z = x / y
-      if (r-z).abs > 2*GSL::FLT_EPSILON*z.abs; status += 1; end
-    end
-  end
-end
-Test::test(status, "#{t.class}#div_elements element division")
-
-### Tensor product
-c = a*b
-status = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      for l in 0...DIMENSION do
-        for m in 0...DIMENSION do
-          for n in 0...DIMENSION do
-            r = c[i, j, k, l, m, n]
-            x = a[i, j, k]
-            y = b[l, m, n]
-            z = x*y
-            if r != z; status += 1; end
-          end
-        end
-      end
-    end
-  end
-end
-Test::test(status, "#{t.class}#product tensorial product")
-
-### Index contraction
-tt = a.contract(0, 1)
-Test::test2(tt.rank == RANK-2, "#{t.class}.contract returns valid rank")
-Test::test2(tt.dimension == DIMENSION, "#{t.class}_contract returns valid dimension")
-
-### Swap indices
-a_102 = a.swap_indices(0, 1)
-a_210 = a.swap_indices(0, 2)
-a_021 = a.swap_indices(1, 2)
-status = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      x = a[i, j, k]
-      x_102 = a_102[j, i, k]
-      x_210 = a_210[k, j, i]
-      x_021 = a_021[i, k, j]
-      if x != x_102 or x != x_210 or x != x_021; status += 1; end
-    end
-  end
-end
-Test::test(status, "#{t.class}#swap_indices swap indices")
-
-### Test text IO
-file = "tensor_test.txt"
-
-t = Tensor.alloc(RANK, DIMENSION)
-counter = 0
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      counter += 1
-      t[i, j, k] = counter 
-    end
-  end
-end
-
-t.fprintf(file, "%g")
-tt = Tensor.alloc(RANK, DIMENSION)
-status = 0
-tt.fscanf(file)
-counter = 0
-data = tt.data
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      counter += 1
-      if data[DIMENSION*DIMENSION*i + DIMENSION*j + k] != counter
-        status += 1
-      end
-    end
-  end
-end
-Test::test(status, "#{t.class}#fprintf and fscanf")
-File.delete(file)
-
-### Test binary IO
-file = "tensor_test.dat"
-t.fwrite(file)
-tt = Tensor.alloc(RANK, DIMENSION)
-status = 0
-tt.fread(file)
-counter = 0
-data = tt.data
-for i in 0...DIMENSION do
-  for j in 0...DIMENSION do
-    for k in 0...DIMENSION do
-      counter += 1
-      if data[DIMENSION*DIMENSION*i + DIMENSION*j + k] != counter
-        status += 1
-      end
-    end
-  end
-end
-Test::test(status, "#{t.class}#fwrite and fread")
-File.delete(file)
-
-### Trap
-i = j = k = 0
-t = Tensor.calloc(RANK, DIMENSION)
-begin
-  t[DIMENSION+1, 0, 0] = 1.2
-rescue
-  # if an exception occurred
-  puts("PASS: #{t.class}#set traps 1st index above upper bound")
-end
-begin
-  t[0, DIMENSION+1, 0] = 1.2
-rescue
-  puts("PASS: #{t.class}#set traps 2nd index above upper bound")
-end
-
-begin
-  t[0, 0, DIMENSION+1] = 1.2
-rescue
-  puts("PASS: #{t.class}#set traps 3rd index above upper bound")
-end
-
-begin
-  t[0, DIMENSION, 0] = 1.2
-rescue
-  puts("PASS: #{t.class}#set traps 2nd index at upper bound")
-end
-
-begin
-  t[0, i-1, 0] = 1.2
-rescue
-  puts("PASS: #{t.class}#set traps 2nd index below lower bound")
-end
-
-begin
-  x = t[DIMENSION+1, 0, 0]
-rescue
-  puts("PASS: #{t.class}#get traps 1st index above upper bound")
-end
-
-begin
-  x = t[0, DIMENSION+1, 0]
-rescue
-  puts("PASS: #{t.class}#get traps 2nd index above upper bound")
-end
-
-begin
-  x = t[0, 0, DIMENSION+1]
-rescue
-  puts("PASS: #{t.class}#get traps 3rd index above upper bound")
-end
-
-begin
-  x = t[0, DIMENSION, 0]
-rescue
-  puts("PASS: #{t.class}#get traps 2nd index at upper bound")
-end
-
-begin
-  x = t[0, i-1, 0]
-rescue
-  puts("PASS: #{t.class}#get traps 2nd index below lower bound")
-end
-
-#####
-# Vector and Tensor, subtensors
-#v = GSL::Vector.new(0...125)
-v = GSL::Vector.indgen(125)
-t = v.to_tensor(3, 5)
-Test::test2(t.rank == RANK, "#{v.class}.to_tensor(#{RANK}, #{DIMENSION}) returns valid rank")
-Test::test2(t.dimension == DIMENSION, "#{v.class}.to_tensor(#{RANK}, #{DIMENSION}) returns valid dimension")
-
-m0_exp = Matrix[0...25, 5, 5]
-m1_exp = Matrix[25...50, 5, 5]
-m2_exp = Matrix[50...75, 5, 5]
-m3_exp = Matrix[75...100, 5, 5]
-m4_exp = Matrix[100...125, 5, 5]
-
-# Create tensors of rank 2
-t0 = t.subtensor(0)
-t1 = t[1]
-t2 = t.subtensor(2)
-t3 = t[3]
-t4 = t.subtensor(4)
-
-# 2-tensors can be compared directly with matrices
-Test::test2(t0 == m0_exp, "#{t.class}#subtensor(0) returns valid tensor")
-Test::test2(t1 == m1_exp, "#{t.class}#subtensor(1) returns valid tensor")
-Test::test2(t2 == m2_exp, "#{t.class}#subtensor(2) returns valid tensor")
-Test::test2(t3 == m3_exp, "#{t.class}#subtensor(3) returns valid tensor")
-Test::test2(t4 == m4_exp, "#{t.class}#subtensor(4) returns valid tensor")
-
-v0_exp = Vector[100...105]
-v1_exp = Vector[105...110]
-v2_exp = Vector[110...115]
-v3_exp = Vector[115...120]
-v4_exp = Vector[120...125]
-
-# Create tensors of rank1
-v0 = t[4, 0]
-v1 = t[4][1]
-v2 = t.subtensor(4, 2)
-v3 = t4[3]
-v4 = t4.subtensor(4)
-
-# 1-tensors can be compared directly with vectors
-Test::test2(v0 == v0_exp, "#{t.class}#subtensor(4,0) returns valid tensor")
-Test::test2(v1 == v1_exp, "#{t.class}#subtensor(4,1) returns valid tensor")
-Test::test2(v2 == v2_exp, "#{t.class}#subtensor(4,2) returns valid tensor")
-Test::test2(v3 == v3_exp, "#{t.class}#subtensor(4,3) returns valid tensor")
-Test::test2(v4 == v4_exp, "#{t.class}#subtensor(4,4) returns valid tensor")
-
-

data/tests/vector/vector_complex_test.rb

@@ -1,101 +0,0 @@
-#!/usr/bin/env ruby
-
-require("gsl")
-require("test/unit")
-
-class VectorComplexTest < Test::Unit::TestCase
-	def test_vector_complex_get
-		v = GSL::Vector::Complex.indgen(5)
-		assert_equal(GSL::Vector::Complex[[3,0],[1,0],[2,0]], v.get([3, 1, 2]))
-	end
-	
-	def test_vector_complex_addsub
-		a = GSL::Vector::Complex[[-2,  5], [ 4, -1]]
-		b = GSL::Vector::Complex[[10, 30], [20, 40]]
-		c = GSL::Vector::Complex[[ 8, 35], [24, 39]]
-		d = GSL::Vector::Complex[[12, 25], [16, 41]]
-		assert_equal(c, a+b)
-		assert_equal(d, b-a)		
-	end
-	
-	def test_vector_complex_collect
-		v = GSL::Vector::Complex.indgen(5)
-		u = GSL::Vector::Complex[[0,0], [1,0], [4,0], [9,0], [16,0]]
-		w = v.collect { |val| val*val }
-		assert_equal(u, w)
-	end
-
-  def test_vector_complex_subvector
-    v = GSL::Vector::Complex.indgen(12)
-
-    # args = []
-    vv = v.subvector
-    assert_not_equal(v.object_id, vv.object_id)
-    assert_equal(v.subvector, v)
-
-    # args = [Fixnum]
-    vv = v.subvector(3)
-    assert_equal([0, 0, 1, 0, 2, 0], vv.to_a)
-    assert_nothing_raised("subvector(-1)") {v.subvector(-1)}
-    vv = v.subvector(-1)
-    assert_equal([11, 0], vv.to_a)
-    vv = v.subvector(-2)
-    assert_equal([10, 0, 11, 0], vv.to_a)
-    assert_raise(RangeError) {v.subvector(-13)}
-
-    # args = [Fixnum, Fixnum]
-    vv = v.subvector(2, 3)
-    assert_equal([2, 0, 3, 0, 4, 0], vv.to_a)
-
-    vv = v.subvector(-4, 3)
-    assert_equal([8, 0, 9, 0, 10, 0], vv.to_a)
-    assert_nothing_raised("subvector(-4, -3)") {v.subvector(-4, -3)}
-    vv = v.subvector(-4, -3)
-    assert_equal([8, 0, 7, 0, 6, 0], vv.to_a)
-    assert_raise(GSL::ERROR::EINVAL) {v.subvector(-11, -3)}
-
-    # args = [Fixnum, Fixnum, Fixnum]
-    vv = v.subvector(1, 3, 4)
-    assert_equal([1, 0, 4, 0, 7, 0, 10, 0], vv.to_a)
-
-    # args = [Range]
-    tests = {
-    # ( range ) => [0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0]
-      ( 1..  3) => [      1, 0, 2, 0, 3, 0                                                  ],                                   
-      ( 1... 3) => [      1, 0, 2, 0,                                                       ],
-      ( 3..  1) => [      3, 0, 2, 0, 1, 0                                                  ],
-      ( 3... 1) => [            3, 0, 2, 0                                                  ],
-      (-7..  9) => [                              5, 0, 6, 0, 7, 0, 8, 0, 9, 0              ],
-      (-7... 9) => [                              5, 0, 6, 0, 7, 0, 8, 0                    ],
-      ( 4.. -3) => [                        4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0              ],
-      ( 4...-3) => [                        4, 0, 5, 0, 6, 0, 7, 0, 8, 0                    ],
-      ( 2.. -2) => [            2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0       ],
-      ( 2...-2) => [            2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0              ],
-      (-2..  2) => [           10, 0, 9, 0, 8, 0, 7, 0, 6, 0, 5, 0, 4, 0, 3, 0,  2, 0       ],
-      (-2... 2) => [           10, 0, 9, 0, 8, 0, 7, 0, 6, 0, 5, 0, 4, 0, 3, 0              ],
-      (-3.. -1) => [                                                      9, 0, 10, 0, 11, 0],
-      (-3...-1) => [                                                      9, 0, 10, 0       ],
-      (-1.. -3) => [                                                     11, 0, 10, 0,  9, 0],
-      (-1...-3) => [                                                     11, 0, 10, 0       ],
-      # Add more test cases here...
-    }
-    tests.each do |r, x|
-      assert_nothing_raised("subvector(#{r})") {v.subvector(r)}
-      assert_equal(x, v.subvector(r).to_a, "subvector(#{r})")
-    end
-
-    # args = [Range, Fixnum]
-    tests = {
-    # [( range ), s] => [0, 0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, 11, 0]
-      [( 1..  6), 2] => [      1, 0,       3, 0,       5, 0                                      ],
-      [( 1... 6), 2] => [      1, 0,       3, 0,       5, 0                                      ],
-      [( 0..  6), 3] => [0, 0,             3, 0,             6, 0                                ],
-      [( 0... 6), 3] => [0, 0,             3, 0                                                  ],
-      # Add more test cases here...
-    }
-    tests.each do |(r,s), x|
-      assert_nothing_raised("subvector(#{r},#{s})") {v.subvector(r)}
-      assert_equal(x, v.subvector(r,s).to_a, "subvector(#{r},#{s})")
-    end
-  end
-end