carray 1.1.4 → 1.1.5

data/spec/spec_all.rb

@@ -0,0 +1,11 @@
+dirname = File.dirname(__FILE__)
+$:.unshift(File.join(dirname, "..", "lib"))
+
+
+require "carray"
+  
+Dir.chdir(File.dirname(__FILE__)) {
+  Dir["**/*_spec.rb"].sort.each do |file|
+    load(file)
+  end
+}

data/test/test_ALL.rb

@@ -0,0 +1,50 @@
+$:.unshift(File.dirname(__FILE__))
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+load 'test_CComplex.rb' if CArray::HAVE_COMPLEX
+#
+load 'test_CABitfield.rb'
+load 'test_CABlock.rb'
+load 'test_CAField.rb'
+load 'test_CAGrid.rb'
+load 'test_CAMapping.rb'
+load 'test_CAMmap.rb'
+load 'test_CARefer.rb'
+load 'test_CARepeat.rb'
+load 'test_CASelect.rb'
+load 'test_CAShift.rb'
+load 'test_CATranspose.rb'
+load 'test_CAWindow.rb'
+load 'test_CAWrap.rb'
+load 'test_CAVirtual.rb'
+load 'test_CArray.rb'
+load 'test_CScalar.rb'
+#
+load 'test_attribute.rb'
+load 'test_block_iterator.rb'
+load 'test_boolean.rb'
+load 'test_cast.rb'
+load 'test_class.rb'
+load 'test_complex.rb' if CArray::HAVE_COMPLEX
+load 'test_composite.rb'
+load 'test_convert.rb'
+load 'test_copy.rb'
+load 'test_element.rb'
+load 'test_extream.rb'
+load 'test_generate.rb'
+load 'test_index.rb'
+load 'test_mask.rb'
+#load 'test_math.rb'
+load 'test_narray.rb' if defined?(CArray::HAVE_NARRAY)
+load 'test_order.rb'
+load 'test_random.rb'
+load 'test_ref_store.rb'
+load 'test_stat.rb'
+load 'test_struct.rb'
+load 'test_virtual.rb'
+#
+load 'test_creation.rb'
+#

data/test/test_CABitfield.rb

@@ -0,0 +1,59 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCArrayCABitfield < Test::Unit::TestCase
+
+  def test_virtual_array
+    a = CArray.int(3,3) { 1 }
+    b = a.bitfield(0)
+    r = b.parent
+    assert_instance_of(CABitfield, b)
+    assert_equal(true, b.virtual?)
+    assert_equal(a, r)
+  end
+
+  def test_basic_features
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(0)
+    b[] = 1
+    assert_equal(a.template{1}, a)
+    assert_equal(b.template{1}, b)
+    b[] = 0
+    assert_equal(a.template{0}, a)    
+    assert_equal(b.template{0}, b)    
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(0..1)
+    b[] = 3
+    assert_equal(a.template{3}, a)
+    assert_equal(b.template{3}, b)
+    
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(5..6)
+    b[] = 3
+    assert_equal(a.template{3 << 5}, a)
+    assert_equal(b.template{3}, b)
+    
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(27..28)
+    b[] = 3
+    assert_equal(a.template{3 << 27}, a)
+    assert_equal(b.template{3}, b)
+  end
+  
+  def test_out_of_index
+    # ---
+    a = CArray.int8(3)
+    assert_raise(IndexError) { a.bitfield(-1..0) }
+    assert_raise(IndexError) { a.bitfield(0..16) }
+    assert_raise(IndexError) { a.bitfield([nil,2]) }
+    assert_nothing_raised    { a.bitfield([nil,1]) }
+  end
+
+  
+end

data/test/test_CABlock.rb

@@ -0,0 +1,208 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCABlock < Test::Unit::TestCase
+
+  def test_virtual_array
+    a = CArray.int(3,3)
+    b = a[0..1,0..1]
+    r = b.parent
+    t = b.root_array
+    assert_instance_of(CABlock, b)
+    assert_instance_of(CArray, r)
+    assert_equal(a, r)
+    assert_equal(a, t)
+  end
+
+  def test_block
+    a = CArray.int32(3, 3) { 1 }
+    b = CArray.int32(3) { 1 }
+
+    assert_equal(a[nil, 1], b)
+    assert_equal(a[1, nil], b)
+
+    a[nil, 1].seq!
+    b.seq!
+    assert_equal(a[nil, 1], b)
+
+    a[1, nil].seq!
+    b.seq!
+    assert_equal(a[1, nil], b)
+  end
+
+  def test_CABlock
+    a = CArray.int32(4, 4)
+
+    a.seq!
+    b = a[1..2, 1..2]
+
+    assert_instance_of(CABlock, b)
+    assert_equal(b.rank, a.rank)
+    assert_equal(b.dim, [2,2])
+    assert_equal(b.elements, 4)
+
+    c = CArray.int32(2, 2){ [[5,6],[9,10]] }
+    assert_equal(b, c)
+
+    d = a.clone
+    d[1..2, 1..2] = 1
+    b[] = 1
+    assert_equal(a, d)
+
+    a.seq!
+    assert_equal(b, c)
+  end
+
+
+  def test_s_new
+    a = CArray.int32(4, 4) { 1 }
+    b = a[0..2, 0..2]
+    assert_equal(b.data_type, CA_INT32)
+    assert_equal(b.rank, 2)
+    assert_equal(b.bytes, CArray.sizeof(CA_INT32))
+    assert_equal(b.size0, [4, 4])
+    assert_equal(b.dim, [3, 3])
+    assert_equal(b.start, [0, 0])
+    assert_equal(b.step, [1, 1])
+    assert_equal(b.count, [3, 3])
+    assert_equal(b.elements, 9)
+    assert_equal(b, CArray.int32(3,3){1})
+  end
+
+  def test_block_of_block
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    c = b[0..1, 0..1]
+
+    assert_equal(b, CArray.int32(3, 3) {
+       [
+         [0, 1, 2],
+         [4, 5, 6],
+         [8, 9, 10],
+       ]
+     })
+
+    assert_equal(c, CArray.int32(2, 2) {
+       [
+         [0, 1],
+         [4, 5],
+       ]
+     })
+  end
+
+  def test_block_of_block_set_value
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    c = b[0..1, 0..1]
+
+    a[0..1, 0..1] = 1
+
+    assert_equal(b, CArray.int32(3, 3) {
+       [
+         [1, 1, 2],
+         [1, 1, 6],
+         [8, 9, 10],
+       ]
+     })
+
+    assert_equal(c, CArray.int32(2, 2) {
+       [
+         [1, 1],
+         [1, 1],
+       ]
+     })
+
+    c[] = 2
+
+    assert_equal(b, CArray.int32(3, 3) {
+       [
+         [2, 2, 2],
+         [2, 2, 6],
+         [8, 9, 10],
+       ]
+     })
+
+    assert_equal(a[0..1, 0..1], CArray.int32(2, 2) {
+       [
+         [2, 2],
+         [2, 2],
+       ]
+     })
+  end
+
+  def test_block_of_block_downrank
+    a = CArray.new(CA_INT32, [4, 4, 4]) { 0 }
+    b = a[0..2, 0..2, 1]
+    c = b[0..1, 1]
+
+    b.seq!
+
+    assert_equal(b, a[0..2, 0..2, 1])
+    assert_equal(c, CArray.int32(2) { [1, 4] })
+
+    c[] = 1
+
+    assert_equal(a[0..1, 1, 1], CArray.int(2) {1})
+  end
+
+  def test_block_of_block_ref_address
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    c = b[1..0, 0..1]
+
+    assert_equal(c[2], 0)
+    assert_equal(c[[2]], CArray.int32(1) { [0] })
+    assert_equal(c[nil], CArray.int32(4) { [4, 5, 0, 1] })
+    assert_equal(c[1..2], CArray.int32(2) { [5, 0] })
+    assert_equal(c[[nil,2]], CArray.int32(2) { [4, 0] })
+    assert_equal(c[[1..-1,2]], CArray.int32(2) { [5, 1] })
+
+    c[nil] = 1
+    assert_equal(a[0..1,0..1], CArray.int32(2,2) { 1 })
+  end
+
+  def test_refer_of_block
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[nil, 0..2]
+    c = b.reshape(2, 6)
+#    assert_equal(b.to_a.flatten, c.to_a.flatten)
+
+    c[0, 0] = 3
+    assert_equal(b[0, 0], 3)
+    assert_equal(a[0, 0], 3)
+  end
+
+  def test_refer_of_block_cast
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[nil, 0..2]
+    c = b.reshape(2, 6)
+    assert_equal(c.float32[0, 1], 1.0)
+    assert_equal(c.float64[0, 1], 1.0)
+  end
+
+  def test_block_of_block_self_asign
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    b[0..1, 0..1] = a[0..1, 0..1]
+  end
+
+  def test_block_move
+    a = CArray.int(10, 10).seq!
+    b = a[0..2, 0..2]
+
+    assert_equal(b, CArray.int(3, 3){[[0,1,2],[10,11,12],[20,21,22]]})
+
+    b.move(1,1)
+    assert_equal(b, CArray.int(3, 3){[[11,12,13],[21,22,23],[31,32,33]]})
+
+    b.move(7,7)
+    assert_equal(b, CArray.int(3, 3){[[77,78,79],[87,88,89],[97,98,99]]})
+
+    assert_raise(ArgumentError) {
+      b.move(8,8)
+    }
+  end
+  
+end

data/test/test_CAField.rb

@@ -0,0 +1,40 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCArrayCAField < Test::Unit::TestCase
+
+  def test_virtual_array
+    a = CArray.int(3,3)
+    b = a.field(0,CA_INT8)
+    r = b.parent
+    assert_instance_of(CAField, b)
+    assert_equal(true, b.virtual?)
+    assert_equal(a, r)
+  end
+
+  def test_attributes
+    #
+    a = CArray.int16(3,3) { 0x1122 }
+    b = a.field(0, CA_INT8)
+    assert_equal(CA_INT8, b.data_type)
+    assert_equal([3,3], b.dim)
+  end
+
+  def test_endian
+    #
+    a = CArray.int16(3,3) { 0x1122 }
+    b = CArray.int8(3,3) { 0x11 }
+    c = CArray.int8(3,3) { 0x22 }
+    if CArray.big_endian?
+      assert_equal(b, a.field(0, CA_INT8))
+      assert_equal(c, a.field(1, CA_INT8))
+    else
+      assert_equal(b, a.field(1, CA_INT8))
+      assert_equal(c, a.field(0, CA_INT8))
+    end
+  end
+
+
+end

data/test/test_CAGrid.rb

@@ -0,0 +1,76 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCArrayCAGrid < Test::Unit::TestCase
+
+  def test_virtual_array
+    a = CArray.int(3,3)
+    i = CArray.int(3).seq
+    b = a[i, 0..1]
+    r = b.parent
+    assert_instance_of(CAGrid, b)
+    assert_equal(true, b.virtual?)
+    assert_equal(a, r)
+  end
+
+  def test_basic_features
+    # ---
+    a = CArray.int(3,3).seq
+    i = CA_INT([1,2,0])
+    assert_equal(CA_INT([[3,4,5],
+                         [6,7,8],
+                         [0,1,2]]), a[i,nil])
+    assert_equal(CA_INT([[1,2,0],
+                         [4,5,3],
+                         [7,8,6]]), a[nil,i])
+    assert_equal(CA_INT([[4,5,3],
+                         [7,8,6],
+                         [1,2,0]]), a[i,i])
+    # ---
+    a = CArray.int(3,3).seq
+    i = CA_INT([-1,-2,-3])
+    assert_equal(CA_INT([[6,7,8],
+                         [3,4,5],
+                         [0,1,2]]), a[i,nil])
+    assert_equal(CA_INT([[2,1,0],
+                         [5,4,3],
+                         [8,7,6]]), a[nil,i])
+    assert_equal(CA_INT([[8,7,6],
+                         [5,4,3],
+                         [2,1,0]]), a[i,i])
+  end
+
+  def test_invalid_args
+    # ---
+    a = CArray.int(3,3).seq
+    i = CA_INT([0,1,2])
+    assert_raise(ArgumentError) { a.grid(i) }
+
+    # ---
+    a = CArray.int(3,3).seq
+    i = CA_INT([0,1,2])
+    i[0] = UNDEF
+    assert_equal(CA_INT([[3,4,5],[6,7,8]]), a.grid(i, nil))
+
+    # ---
+    a = CArray.int(3,3).seq
+    i = CA_INT([])
+    assert_equal(CArray.int(0,3), a.grid(i, nil))
+    assert_equal(CArray.int(3,0), a.grid(nil, i))
+  end
+
+  def test_out_of_index
+    # ---
+    a = CArray.int(3,3).seq
+    i1 = CA_INT([1,2,3])
+    i2 = CA_INT([-4,-3,-2])
+    assert_raise(IndexError) { a[i1,nil] }
+    assert_raise(IndexError) { a[nil,i1] }
+    assert_raise(IndexError) { a[i2,nil] }
+    assert_raise(IndexError) { a[nil,i2] }
+  end
+
+
+end