carray 1.1.4 → 1.1.5

data/test/test_attribute.rb

@@ -0,0 +1,281 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCArrayAttribute < Test::Unit::TestCase
+
+  def test_attribute_basic_features
+    a = CArray.new(CA_INT32, [4, 3, 2, 1])
+    assert_instance_of(CArray, a)
+    assert_equal(CA_OBJ_ARRAY, a.obj_type)
+    assert_equal(CA_INT32, a.data_type)
+    assert_equal(4, a.rank)
+    assert_equal(CArray.sizeof(CA_INT32), a.bytes)
+    assert_equal(24, a.elements)
+    assert_equal([4, 3, 2, 1], a.dim)
+    assert_equal(4, a.dim0)
+    assert_equal(3, a.dim1)
+    assert_equal(2, a.dim2)
+    assert_equal(1, a.dim3)
+  end
+
+  def test_fixlen?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).fixlen?, true)
+    assert_equal(CArray.boolean(1).fixlen?,     false)
+    assert_equal(CArray.int8(1).fixlen?,     false)
+    assert_equal(CArray.uint8(1).fixlen?,    false)
+    assert_equal(CArray.int16(1).fixlen?,    false)
+    assert_equal(CArray.uint16(1).fixlen?,   false)
+    assert_equal(CArray.int32(1).fixlen?,    false)
+    assert_equal(CArray.uint32(1).fixlen?,   false)
+    assert_equal(CArray.int64(1).fixlen?,    false)
+    assert_equal(CArray.uint64(1).fixlen?,   false)
+    assert_equal(CArray.float32(1).fixlen?,  false)
+    assert_equal(CArray.float64(1).fixlen?,  false)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).fixlen?, false)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).fixlen?,  false)
+      assert_equal(CArray.cmplx128(1).fixlen?, false)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).fixlen?, false)
+      end
+    end
+    assert_equal(CArray.object(1).fixlen?,   false)
+  end
+
+  def test_boolean?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).boolean?, false)
+    assert_equal(CArray.boolean(1).boolean?,     true)
+    assert_equal(CArray.int8(1).boolean?,     false)
+    assert_equal(CArray.uint8(1).boolean?,    false)
+    assert_equal(CArray.int16(1).boolean?,    false)
+    assert_equal(CArray.uint16(1).boolean?,   false)
+    assert_equal(CArray.int32(1).boolean?,    false)
+    assert_equal(CArray.uint32(1).boolean?,   false)
+    assert_equal(CArray.int64(1).boolean?,    false)
+    assert_equal(CArray.uint64(1).boolean?,   false)
+    assert_equal(CArray.float32(1).boolean?,  false)
+    assert_equal(CArray.float64(1).boolean?,  false)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).boolean?, false)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).boolean?,  false)
+      assert_equal(CArray.cmplx128(1).boolean?, false)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).boolean?, false)
+      end
+    end
+    assert_equal(CArray.object(1).boolean?,   false)
+  end
+
+  def test_numeric?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).integer?, false)
+    assert_equal(CArray.boolean(1).integer?,     false)
+    assert_equal(CArray.int8(1).integer?,     true)
+    assert_equal(CArray.uint8(1).integer?,    true)
+    assert_equal(CArray.int16(1).integer?,    true)
+    assert_equal(CArray.uint16(1).integer?,   true)
+    assert_equal(CArray.int32(1).integer?,    true)
+    assert_equal(CArray.uint32(1).integer?,   true)
+    assert_equal(CArray.int64(1).integer?,    true)
+    assert_equal(CArray.uint64(1).integer?,   true)
+    assert_equal(CArray.float32(1).integer?,  false)
+    assert_equal(CArray.float64(1).integer?,  false)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).integer?, false)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).integer?,  false)
+      assert_equal(CArray.cmplx128(1).integer?, false)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).integer?, false)
+      end
+    end
+    assert_equal(CArray.object(1).integer?,   false)
+  end
+
+  def test_integer?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).integer?, false)
+    assert_equal(CArray.boolean(1).integer?,     false)
+    assert_equal(CArray.int8(1).integer?,     true)
+    assert_equal(CArray.uint8(1).integer?,    true)
+    assert_equal(CArray.int16(1).integer?,    true)
+    assert_equal(CArray.uint16(1).integer?,   true)
+    assert_equal(CArray.int32(1).integer?,    true)
+    assert_equal(CArray.uint32(1).integer?,   true)
+    assert_equal(CArray.int64(1).integer?,    true)
+    assert_equal(CArray.uint64(1).integer?,   true)
+    assert_equal(CArray.float32(1).integer?,  false)
+    assert_equal(CArray.float64(1).integer?,  false)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).integer?, false)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).integer?,  false)
+      assert_equal(CArray.cmplx128(1).integer?, false)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).integer?, false)
+      end
+    end
+    assert_equal(CArray.object(1).integer?,   false)
+  end
+
+  def test_unsigned?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).unsigned?, false)
+    assert_equal(CArray.boolean(1).unsigned?,  false)
+    assert_equal(CArray.int8(1).unsigned?,     false)
+    assert_equal(CArray.uint8(1).unsigned?,    true)
+    assert_equal(CArray.int16(1).unsigned?,    false)
+    assert_equal(CArray.uint16(1).unsigned?,   true)
+    assert_equal(CArray.int32(1).unsigned?,    false)
+    assert_equal(CArray.uint32(1).unsigned?,   true)
+    assert_equal(CArray.int64(1).unsigned?,    false)
+    assert_equal(CArray.uint64(1).unsigned?,   true)
+    assert_equal(CArray.float32(1).unsigned?,  false)
+    assert_equal(CArray.float64(1).unsigned?,  false)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).unsigned?, false)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).unsigned?,  false)
+      assert_equal(CArray.cmplx128(1).unsigned?, false)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).unsigned?, false)
+      end
+    end
+    assert_equal(CArray.object(1).unsigned?,   false)
+  end
+
+  def test_float?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).float?, false)
+    assert_equal(CArray.boolean(1).float?,  false)
+    assert_equal(CArray.int8(1).float?,     false)
+    assert_equal(CArray.uint8(1).float?,    false)
+    assert_equal(CArray.int16(1).float?,    false)
+    assert_equal(CArray.uint16(1).float?,   false)
+    assert_equal(CArray.int32(1).float?,    false)
+    assert_equal(CArray.uint32(1).float?,   false)
+    assert_equal(CArray.int64(1).float?,    false)
+    assert_equal(CArray.uint64(1).float?,   false)
+    assert_equal(CArray.float32(1).float?,  true)
+    assert_equal(CArray.float64(1).float?,  true)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).float?, true)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).float?,  false)
+      assert_equal(CArray.cmplx128(1).float?, false)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).float?, false)
+      end
+    end
+    assert_equal(CArray.object(1).float?,   false)
+  end
+
+  def test_complex?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).complex?, false)
+    assert_equal(CArray.boolean(1).complex?,  false)
+    assert_equal(CArray.int8(1).complex?,     false)
+    assert_equal(CArray.uint8(1).complex?,    false)
+    assert_equal(CArray.int16(1).complex?,    false)
+    assert_equal(CArray.uint16(1).complex?,   false)
+    assert_equal(CArray.int32(1).complex?,    false)
+    assert_equal(CArray.uint32(1).complex?,   false)
+    assert_equal(CArray.int64(1).complex?,    false)
+    assert_equal(CArray.uint64(1).complex?,   false)
+    assert_equal(CArray.float32(1).complex?,  false)
+    assert_equal(CArray.float64(1).complex?,  false)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).complex?, false)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).complex?,  true)
+      assert_equal(CArray.cmplx128(1).complex?, true)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).complex?, true)
+      end
+    end
+    assert_equal(CArray.object(1).complex?,   false)
+  end
+
+  def test_object?
+    assert_equal(CArray.new(CA_FIXLEN, [1], :bytes=>1).object?, false)
+    assert_equal(CArray.boolean(1).object?,  false)
+    assert_equal(CArray.int8(1).object?,     false)
+    assert_equal(CArray.uint8(1).object?,    false)
+    assert_equal(CArray.int16(1).object?,    false)
+    assert_equal(CArray.uint16(1).object?,   false)
+    assert_equal(CArray.int32(1).object?,    false)
+    assert_equal(CArray.uint32(1).object?,   false)
+    assert_equal(CArray.int64(1).object?,    false)
+    assert_equal(CArray.uint64(1).object?,   false)
+    assert_equal(CArray.float32(1).object?,  false)
+    assert_equal(CArray.float64(1).object?,  false)
+    if CArray.data_type?(:float128)
+      assert_equal(CArray.float128(1).object?, false)
+    end
+    if CArray::HAVE_COMPLEX
+      assert_equal(CArray.cmplx64(1).object?,  false)
+      assert_equal(CArray.cmplx128(1).object?, false)
+      if CArray.data_type?(:cmplx256)
+        assert_equal(CArray.cmplx256(1).object?, false)
+      end
+    end
+    assert_equal(CArray.object(1).object?,   true)
+  end
+
+  def test_entity?
+    a = CArray.int32(3)
+    assert_equal(a.entity?, true)
+    assert_equal(a[].entity?, false)
+    assert_equal(a[0..1].entity?, false)
+    assert_equal(a[a>0].entity?, false)
+
+    b = CScalar.int32()
+    assert_equal(b.entity?, true)
+    assert_equal(b[].entity?, false)
+  end
+
+  def test_virtual?
+    a = CArray.int32(3)
+    assert_equal(a.virtual?, false)
+    assert_equal(a[].virtual?, true)
+    assert_equal(a[0..1].virtual?, true)
+    assert_equal(a[a>0].virtual?, true)
+
+    b = CScalar.int32()
+    assert_equal(b.virtual?, false)
+    assert_equal(b[].virtual?, true)
+  end
+
+  def test_valid_index?
+    a = CArray.int32(3,3)
+    assert_equal(true, a.valid_index?(2,2))
+    assert_equal(true, a.valid_index?(1,1))
+    assert_equal(true, a.valid_index?(-1,-1))
+    assert_equal(true, a.valid_index?(-3,-3))   
+
+    assert_equal(true, a.valid_addr?(8))
+    assert_equal(true, a.valid_addr?(4))
+    assert_equal(true, a.valid_addr?(-4))
+    assert_equal(true, a.valid_addr?(-8)) 
+      
+    assert_equal(false, a.valid_index?(1,3))
+    assert_equal(false, a.valid_index?(-4,1))
+
+    assert_equal(false, a.valid_addr?(9))   
+    assert_equal(false, a.valid_addr?(-10))   
+  end
+
+  def test_same_shape?
+    a = CArray.int32(4,3,2,1)
+    b = CArray.int8(1,2,3,4)
+    assert_equal(false, a.same_shape?(b))
+    assert_equal(true, a.transposed.same_shape?(b))
+  end
+
+end

data/test/test_block_iterator.rb

@@ -0,0 +1,17 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCArrayBlockIterator < Test::Unit::TestCase
+
+  def test_block_asignment
+    a = CArray.object(4,4)
+    b = a.blocks(0..1,0..1).each_with_addr{|x,i| x[] = i * 2 }
+    c = CArray.object(2,2).seq!(0,2)[:%,:%,2,2].transposed(0,2,1,3).reshape(4,4)
+    assert_equal(c, a)
+  end
+
+end
+
+

data/test/test_boolean.rb

@@ -0,0 +1,99 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestBooleanType < Test::Unit::TestCase
+
+  def test_boolean_bit_operations
+    a = CArray.int(3,3).seq!
+    e0 = a < 4
+    e1 = a >= 4
+
+    # ---
+    assert_equal(e0, e0 & 1)
+    assert_equal(e0, e0 & true)
+    assert_equal(a.false, e0 & false)
+
+    assert_equal(a.true, e0 | 1)
+    assert_equal(a.true, e0 | true)
+    assert_equal(e0, e0 | false)
+
+    assert_equal(e1, e0 ^ 1)
+    assert_equal(e1, e0 ^ true)
+    assert_equal(e0, e0 ^ false)
+
+    # ---
+    assert_equal(e0, 1 & e0)
+    assert_equal(e0, true & e0)
+    assert_equal(a.false, false & e0)
+
+    assert_equal(a.true, 1 | e0)
+    assert_equal(a.true, true | e0)
+    assert_equal(e0, false | e0)
+
+    assert_equal(e1, 1 ^ e0)
+    assert_equal(e1, true ^ e0)
+    assert_equal(e0, false ^ e0)
+
+  end
+
+  def test_boolean_bit_operations2
+    a = CArray.int(3,3).seq!
+    e0 = a < 4
+    e1 = a >= 4
+
+    one  = a.one
+    zero = a.zero
+    tt   = a.true
+    ff   = a.false
+
+    # ---
+    assert_equal(e0, e0 & one)
+    assert_equal(e0, e0 & tt)
+    assert_equal(ff, e0 & ff)
+
+    assert_equal(tt, e0 | one)
+    assert_equal(tt, e0 | tt)
+    assert_equal(e0, e0 | ff)
+
+    assert_equal(e1, e0 ^ one)
+    assert_equal(e1, e0 ^ tt)
+    assert_equal(e0, e0 ^ ff)
+
+    # ---
+    assert_equal(e0, one & e0)
+    assert_equal(e0, tt & e0)
+    assert_equal(ff, ff & e0)
+
+    assert_equal(tt, one | e0)
+    assert_equal(tt, tt | e0)
+    assert_equal(e0, ff | e0)
+
+    assert_equal(e1, one ^ e0)
+    assert_equal(e1, tt ^ e0)
+    assert_equal(e0, ff ^ e0)
+
+  end
+
+  def test_boolean_bit_operation_with_non_boolean_type
+
+    a = CArray.int(3,3).seq!
+    b = CArray.int(3,3).seq! + 1
+    e0 = a < 4
+    e1 = a >= 4
+
+    # ---
+    assert_raise(RuntimeError) { e0 & b }
+    assert_raise(RuntimeError) { e0 | b }
+    assert_raise(RuntimeError) { e0 ^ b }
+
+    # ---
+    assert_raise(RuntimeError) { b & e0 }
+    assert_raise(RuntimeError) { b | e0 }
+    assert_raise(RuntimeError) { b ^ e0 }
+
+  end
+
+
+end

data/test/test_cast.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require 'carray'
+
+class TestCast < Test::Unit::TestCase
+
+  def test_obj_to_numeric
+    # ---
+    a = CA_OBJECT([1,2,3])
+    b = CA_INT32([1,2,3])
+    c = CA_FLOAT64([1,2,3])
+    assert_equal(b, a.int32)
+    assert_equal(c, a.float64)
+
+    # ---
+    a = CA_OBJECT(["1","2","3"])
+    b = CA_INT32([1,2,3])
+    c = CA_FLOAT64([1,2,3])
+    assert_equal(b, a.int32)
+    assert_equal(c, a.float64)
+
+    # ---
+    a = CA_OBJECT([nil, nil, nil])
+    assert_raise(TypeError) { a.int32 }
+#    assert_raise(TypeError) { a.float32 }
+
+    # ---
+    a = CA_OBJECT(["a", "b", "c"])
+    assert_raise(ArgumentError) { a.int32 }
+    assert_raise(ArgumentError) { a.float32 }
+  end
+
+
+end

data/test/test_class.rb

@@ -0,0 +1,85 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCArrayClass < Test::Unit::TestCase
+
+  # CA_BIG_ENDIAN : 1
+  # CA_LITTLE_ENDIAN : 0
+
+  def test_endian
+    if [1].pack("s") == [1].pack("n")
+      endian = CA_BIG_ENDIAN
+    else
+      endian = CA_LITTLE_ENDIAN
+    end
+    assert_equal(CArray.endian, endian)
+    case endian
+    when CA_BIG_ENDIAN
+      assert_equal(CArray.big_endian?, true)
+      assert_equal(CArray.little_endian?, false)
+    when CA_LITTLE_ENDIAN
+      assert_equal(CArray.big_endian?, false)
+      assert_equal(CArray.little_endian?, true)
+    end
+  end
+
+  def test_sizeof
+    assert_equal(CArray.sizeof(CA_INT8), 1)
+    assert_equal(CArray.sizeof(CA_UINT8), 1)
+    assert_equal(CArray.sizeof(CA_INT16), 2)
+    assert_equal(CArray.sizeof(CA_UINT16), 2)
+    assert_equal(CArray.sizeof(CA_INT32), 4)
+    assert_equal(CArray.sizeof(CA_UINT32), 4)
+    # assert_equal(CArray.sizeof(CA_INT64), 8)
+    # assert_equal(CArray.sizeof(CA_UINT64), 8)
+    assert_equal(CArray.sizeof(CA_FLOAT32), 4)
+    assert_equal(CArray.sizeof(CA_FLOAT64), 8)
+    # assert_equal(CArray.sizeof(CA_FLOAT128), 16)
+    # assert_equal(CArray.sizeof(CA_CMPLX64), 8)
+    # assert_equal(CArray.sizeof(CA_CMPLX128), 16)
+    # assert_equal(CArray.sizeof(CA_CMPLX256), 32)
+    assert_equal(CArray.sizeof(CA_FIXLEN), 0)
+    # assert_equal(CArray.sizeof(CA_OBJECT), 0)
+  end
+
+  def test_valid_type?
+    # can't test this method
+    assert_raise(ArgumentError) { CArray.data_type?(-1) }
+    assert_equal(CArray.data_type?(CA_FIXLEN), true)
+    assert_equal(CArray.data_type?(CA_INT8), true)
+    assert_equal(CArray.data_type?(CA_INT32), true)
+    assert_equal(CArray.data_type?(CA_FLOAT32), true)
+    assert_equal(CArray.data_type?(CA_OBJECT), true)
+    assert_raise(ArgumentError) { CArray.data_type?(CA_OBJECT+1) }
+  end
+
+  def test_type_name
+    [
+     [CA_INT8, "int8"],
+     [CA_UINT8, "uint8"],
+     [CA_INT16, "int16"],
+     [CA_UINT16, "uint16"],
+     [CA_INT32, "int32"],
+     [CA_UINT32, "uint32"],
+     [CA_INT64, "int64"],
+     [CA_UINT64, "uint64"],
+     [CA_FLOAT32, "float32"],
+     [CA_FLOAT64, "float64"],
+     [CA_FLOAT128, "float128"],
+     [CA_CMPLX64, "cmplx64"],
+     [CA_CMPLX128, "cmplx128"],
+     [CA_CMPLX256, "cmplx256"],
+     [CA_FIXLEN, "fixlen"],
+     [CA_OBJECT, "object"],
+    ].each do |type, name|
+      if CArray.data_type?(type)
+        assert_equal(CArray.data_type_name(type), name)
+      else
+        assert_raise(RuntimeError) { CArray.data_type_name(type) }
+      end
+    end
+  end
+
+end