carray 1.5.1 → 1.5.2

data/test/test_attribute.rb

@@ -1,281 +0,0 @@
-$:.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

@@ -1,17 +0,0 @@
-$:.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

@@ -1,99 +0,0 @@
-$:.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

@@ -1,33 +0,0 @@
-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

@@ -1,85 +0,0 @@
-$:.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