carray 1.3.7 → 1.5.4

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

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