carray 1.3.5 → 1.5.2

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

data/test/test_complex.rb

@@ -1,43 +0,0 @@
-$:.unshift("../lib", "..")
-
-require 'test/unit'
-require 'carray'
-
-class TestComplex < Test::Unit::TestCase
-
-  def test_complex
-    a = CArray.complex(3,3) { 1 + 2*CI }
-    assert_equal(a.real, CArray.float(3,3) { 1 })
-    assert_equal(a.imag, CArray.float(3,3) { 2 })
-    a.real[] = -1
-    a.imag[] = -2
-    assert_equal(a.real, CArray.float(3,3) { -1 })
-    assert_equal(a.imag, CArray.float(3,3) { -2 })
-  end
-
-  def test_dcomplex
-    a = CArray.dcomplex(3,3) { 1 + 2*CI }
-    assert_equal(a.real, CArray.double(3,3) { 1 })
-    assert_equal(a.imag, CArray.double(3,3) { 2 })
-    a.real = -1
-    a.imag = -2
-    assert_equal(a.real, CArray.double(3,3) { -1 })
-    assert_equal(a.imag, CArray.double(3,3) { -2 })
-  end
-
-  def test_conj
-    a = CArray.complex(3,3) { 1 + 2*CI }
-    a.conj!
-    assert_equal(a.real, CArray.float(3,3) { 1 })
-    assert_equal(a.imag, CArray.float(3,3) { -2 })
-  end
-
-  def test_arg
-    a = CArray.complex(3,3) { 1 + 2*CI }
-    a.conj!
-    assert_equal(a.real, CArray.float(3,3) { 1 })
-    assert_equal(a.imag, CArray.float(3,3) { -2 })
-  end
-
-
-end

data/test/test_convert.rb

@@ -1,79 +0,0 @@
-#$:.unshift("../lib", "..")
-
-require 'test/unit'
-require 'carray'
-
-class TestCArray < Test::Unit::TestCase
-
-  def test_conversion
-    assert_equal(CA_INT32(1), CScalar.int32{1})
-    assert_equal(CA_INT32([1]), CArray.int32(1){[1]})
-    assert_equal(CA_INT32([[0,1],[2,3]]), CArray.int32(2,2).seq!)
-    assert_raise(TypeError) { CA_INT32([1,[1,2]]) }
-  end
-
-  def test_s_span
-    a = CArray.span(CA_FLOAT32, 0..2, 0.5)
-    assert_equal(a, CA_FLOAT32([0,0.5,1,1.5,2]))
-    a = CArray.span(CA_FLOAT32, 0...2, 0.5)
-    assert_equal(a, CA_FLOAT32([0,0.5,1,1.5]))
-  end
-
-  def test_wrap_readonly
-    a = CArray.wrap_readonly([[1,2,3],[4,5,6],[7,8,9]], CA_INT32)
-    assert_equal(CA_INT32([[1,2,3],[4,5,6],[7,8,9]]), a)
-  end
-
-  def test_compact
-    a = CArray.int(4,1,3,1,2,1).seq!
-    b = CArray.int(4,3,2).seq!
-    
-    assert_equal(b, a.compacted)
-    assert_equal(CARefer, a.compacted.class)
-    assert_equal(b, a.compact)
-    assert_equal(CArray, a.compact.class)
-  end
-
-  def test_to_a
-    # ---
-    a = CArray.int(3).seq!
-    assert_equal([ 0,1,2 ], a.to_a)
-
-    # ---
-    a = CArray.int(3,3).seq!
-    assert_equal([ [0,1,2], [3,4,5], [6,7,8] ], a.to_a)
-  end
-
-  def test_convert
-    # ---
-    a = CArray.int(3).seq!
-    if RUBY_VERSION >= "1.9.0"
-      b = a.convert(CA_OBJECT) {|x| (x+"a".ord).chr }
-    else  
-      b = a.convert(CA_OBJECT) {|x| (x+?a).chr }
-    end 
-    assert_equal(CA_OBJECT(["a","b","c"]), b)
-  end 
-
-  def test_map
-    # ---
-    a = CArray.int(3).seq!
-    if RUBY_VERSION >="1.9.0"
-      b = a.map {|x| (x+"a".ord).chr }
-    else
-      b = a.map {|x| (x+?a).chr }
-    end
-    assert_equal([ "a","b","c" ], b)
-
-    # ---
-    a = CArray.int(3,3).seq!
-    if RUBY_VERSION >= "1.9.0"
-      b = a.map {|x| (x+"a".ord).chr }
-    else
-      b = a.map {|x| (x+?a).chr }
-    end
-    assert_equal([ ["a","b","c"], ["d","e","f"], ["g","h","i"] ], b)
-  end
-
-  
-end

data/test/test_copy.rb

@@ -1,141 +0,0 @@
-require "test/unit"
-
-require "carray"
-
-class TestCArrayCopy < Test::Unit::TestCase
-
-  def test_to_ca
-    #
-    a = CArray.int32(3,3).seq
-    b = a.to_ca
-    assert_equal(CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, 4, 5 ],
-                            [ 6, 7, 8 ] ]), a)
-    assert_equal(a, b)
-
-    # mask does not be templated
-    a = CArray.int32(3,3).seq
-    a[1,1] = UNDEF
-    b = a.to_ca
-    assert_equal(CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, UNDEF, 5 ],
-                            [ 6, 7, 8 ] ]), a)
-    assert_equal(a, b)
-  end
-
-  def test_template
-    #
-    a = CArray.int32(3,3).seq
-    b = a.template {1}
-    assert_equal(CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, 4, 5 ],
-                            [ 6, 7, 8 ] ]), a)
-    assert_equal(CA_INT32([ [ 1, 1, 1 ],
-                            [ 1, 1, 1 ],
-                            [ 1, 1, 1 ] ]), b)
-
-    # mask does not be templated
-    a = CArray.int32(3,3).seq
-    a[1,1] = UNDEF
-    b = a.template {1}
-    assert_equal(CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, UNDEF, 5 ],
-                            [ 6, 7, 8 ] ]), a)
-    assert_equal(CA_INT32([ [ 1, 1, 1 ],
-                            [ 1, 1, 1 ],
-                            [ 1, 1, 1 ] ]), b)
-  end
-
-  def test_to_type
-    #
-    a = CArray.int8(3,3).seq
-    b = a.int32
-    assert_equal(CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, 4, 5 ],
-                           [ 6, 7, 8 ] ]), a)
-    assert_equal(CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, 4, 5 ],
-                            [ 6, 7, 8 ] ]), b)
-
-
-    #
-    a = CArray.int8(3,3).seq
-    a[1,1] = UNDEF
-    b = a.int32
-    assert_equal(CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, UNDEF, 5 ],
-                           [ 6, 7, 8 ] ]), a)
-    assert_equal(CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, UNDEF, 5 ],
-                            [ 6, 7, 8 ] ]), b)
-  end
-
-  def test_convert
-    #
-    a = CArray.int8(3,3).seq
-    b = a.convert(CA_INT32) {|x| 2*x}
-    assert_equal(CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, 4, 5 ],
-                           [ 6, 7, 8 ] ]), a)
-    assert_equal(CA_INT32([ [ 0, 2, 4 ],
-                            [ 6, 8, 10 ],
-                            [ 12, 14, 16 ] ]), b)
-
-    #
-    a = CArray.int8(3,3).seq
-    a[1,1] = UNDEF
-    b = a.convert(CA_INT32) {|x| 2 * x }
-    assert_equal(CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, UNDEF, 5 ],
-                           [ 6, 7, 8 ] ]), a)
-    assert_equal(CA_INT32([ [ 0, 2, 4 ],
-                            [ 6, UNDEF, 10 ],
-                            [ 12, 14, 16 ] ]), b)
-  end
-
-  def test_transform
-    #
-    a = CArray.uint8(2,4) { 0xff }
-    b = a.refer(CA_UINT16, [2,2]).to_ca
-    assert_equal(CA_UINT8([ [ 255, 255, 255, 255 ],
-                            [ 255, 255, 255, 255 ] ]), a)
-    assert_equal(CA_UINT16([ [ 65535, 65535 ],
-                             [ 65535, 65535 ] ]), b)
-  end
-
-  def test_to_a
-    #
-    a = CArray.int32(3,3).seq
-    b = a.to_a
-    assert_equal([ [ 0, 1, 2 ],
-                   [ 3, 4, 5 ],
-                   [ 6, 7, 8 ] ], b)
-
-    # mask does not be templated
-    a = CArray.int32(3,3).seq
-    a[1,1] = UNDEF
-    b = a.to_a
-    assert_equal([ [ 0, 1, 2 ],
-                   [ 3, UNDEF, 5 ],
-                   [ 6, 7, 8 ] ], b)
-  end
-
-  def test_map
-    #
-    a = CArray.int32(3,3).seq
-    b = a.map{|x| x.to_s }
-    b.to_a
-    assert_equal([ [ "0", "1", "2" ],
-                   [ "3", "4", "5" ],
-                   [ "6", "7", "8" ] ], b)
-
-    # mask does not be templated
-    a = CArray.int32(3,3).seq
-    a[1,1] = UNDEF
-    b = a.map{|x| x.to_s }
-    assert_equal([ [ "0", "1", "2" ],
-                   [ "3", UNDEF, "5" ],
-                   [ "6", "7", "8" ] ], b)
-  end
-
-end

data/test/test_creation.rb

@@ -1,85 +0,0 @@
-$:.unshift("../lib", "..")
-
-require 'test/unit'
-require 'carray'
-
-class TestCArrayCreation < Test::Unit::TestCase
-
-  def test_s_new_uint8
-    # ---
-    ca = CArray.new(CA_UINT8, [3, 2, 1]) 
-    assert_instance_of(CArray, ca)
-    assert_equal(CA_UINT8, ca.data_type)
-    assert_equal([3,2,1], ca.dim)
-
-    # ---
-    ca = CArray.new(:uint8, [3, 2, 1]) 
-    assert_instance_of(CArray, ca)
-    assert_equal(CA_UINT8, ca.data_type)
-    assert_equal([3,2,1], ca.dim)
-
-    # ---
-    ca = CArray.uint8(3, 2, 1) 
-    assert_instance_of(CArray, ca)
-    assert_equal(CA_UINT8, ca.data_type)
-    assert_equal([3,2,1], ca.dim)
-  end
-
-  def test_s_new_fixlen
-    # ---
-    ca = CArray.new(CA_FIXLEN, [3, 2, 1], :bytes=>10) 
-    assert_instance_of(CArray, ca)
-    assert_equal(CA_FIXLEN, ca.data_type)
-    assert_equal(10, ca.bytes)    
-    assert_equal([3,2,1], ca.dim)
-
-    # ---
-    ca = CArray.new(:fixlen, [3, 2, 1], :bytes=>10) 
-    assert_instance_of(CArray, ca)
-    assert_equal(CA_FIXLEN, ca.data_type)
-    assert_equal(10, ca.bytes)    
-    assert_equal([3,2,1], ca.dim)
-
-    # ---
-    ca = CArray.fixlen(3, 2, 1, :bytes=>10) 
-    assert_instance_of(CArray, ca)
-    assert_equal(CA_FIXLEN, ca.data_type)
-    assert_equal(10, ca.bytes)    
-    assert_equal([3,2,1], ca.dim)
-  end
-
-  def test_s_new_various_types
-    # ---
-    data_type_list = [
-      CA_BOOLEAN,
-      CA_UINT8, CA_INT8,
-      CA_UINT16, CA_INT16,
-      CA_UINT32, CA_INT32,
-      CA_FLOAT32, CA_FLOAT64,
-      CA_OBJECT
-    ]
-    data_type_list.each do |type|
-      ca = CArray.new(type, [3, 2, 1]) 
-      assert_instance_of(CArray, ca)
-      assert_equal(type, ca.data_type)
-    end    
-
-    # ---
-    data_type_name_list = [
-      "boolean",
-      "uint8", "int8",
-      "uint16", "int16",
-      "uint32", "int32",
-      "float32", "float64",
-      "object"
-    ]
-    data_type_name_list.each do |type|
-      ca = CArray.send(type, 3, 2, 1) 
-      assert_instance_of(CArray, ca)
-      assert_equal(type, ca.data_type_name)
-    end
-
-  end
-
-
-end