carray 1.1.4 → 1.1.5

data/test/test_complex.rb

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

@@ -0,0 +1,125 @@
+$:.unshift("../lib", "..")
+
+require 'test/unit'
+require 'carray'
+
+class TestCArrayComposite < Test::Unit::TestCase
+
+  def test_combine
+    a1 = CArray.int32(2,2){1}
+    a2 = CArray.int32(2,2){2}
+    a3 = CArray.int32(2,2){3}
+    a4 = CArray.int32(2,2){4}
+    list = [a1, a2, a3, a4]
+
+    # ---
+    y = CA_INT32([
+                  [1,1],
+                  [1,1],
+                  [2,2],
+                  [2,2],
+                  [3,3],
+                  [3,3],
+                  [4,4],
+                  [4,4],
+                 ])
+    x = CArray.combine(CA_INT32, [4], list, 0)
+    assert_equal(y, x)
+
+    # ---
+    y = CA_INT32([
+                  [1,1,2,2,3,3,4,4],
+                  [1,1,2,2,3,3,4,4]
+                 ])
+    x = CArray.combine(CA_INT32, [4], list, -1)
+    assert_equal(y, x)
+    x = CArray.combine(CA_INT32, [4], list, 1)
+    assert_equal(y, x)
+
+    # ---
+    y = CA_INT32([
+                  [1,1,2,2],
+                  [1,1,2,2],
+                  [3,3,4,4],
+                  [3,3,4,4],
+                 ])
+    x = CArray.combine(CA_INT32, [2,2], list, 0)
+    assert_equal(y, x)
+    x = CArray.combine(CA_INT32, [2,2], list, -1)
+    assert_equal(y, x)
+
+    assert_raise(RuntimeError) {
+      CArray.combine(CA_INT32, [2,2], list, 1)
+    }
+
+  end
+
+  def test_composite
+    a1 = CArray.int32(2,2){1}
+    a2 = CArray.int32(2,2){2}
+    a3 = CArray.int32(2,2){3}
+    a4 = CArray.int32(2,2){4}
+    list = [a1, a2, a3, a4]
+
+    # ---
+    y = CA_INT32([ [ [ 1, 1 ],
+                     [ 1, 1 ] ],
+                   [ [ 2, 2 ],
+                     [ 2, 2 ] ],
+                   [ [ 3, 3 ],
+                     [ 3, 3 ] ],
+                   [ [ 4, 4 ],
+                     [ 4, 4 ] ] ])
+    x = CArray.composite(CA_INT32, [4], list, 0)
+    assert_equal(y, x)
+
+    # ---
+    y = CA_INT32([ [ [ 1, 2, 3, 4 ],
+                     [ 1, 2, 3, 4 ] ],
+                   [ [ 1, 2, 3, 4 ],
+                     [ 1, 2, 3, 4 ] ] ])
+    x = CArray.composite(CA_INT32, [4], list, -1)
+    assert_equal(y, x)
+
+    # ---
+    y = CA_INT32([ [ [ [ 1, 1 ],
+                       [ 1, 1 ] ],
+                     [ [ 2, 2 ],
+                       [ 2, 2 ] ] ],
+                   [ [ [ 3, 3 ],
+                       [ 3, 3 ] ],
+                     [ [ 4, 4 ],
+                       [ 4, 4 ] ] ] ])
+    x = CArray.composite(CA_INT32, [2,2], list, 0)
+    assert_equal(y, x)
+
+    # ---
+    y = CA_INT32([ [ [ [ 1, 1 ],
+                       [ 2, 2 ] ],
+                     [ [ 3, 3 ],
+                       [ 4, 4 ] ] ],
+                   [ [ [ 1, 1 ],
+                       [ 2, 2 ] ],
+                     [ [ 3, 3 ],
+                       [ 4, 4 ] ] ] ])
+    x = CArray.composite(CA_INT32, [2,2], list, 1)
+    assert_equal(y, x)
+
+    # ---
+    y = CA_INT32([ [ [ [ 1, 2 ],
+                       [ 3, 4 ] ],
+                     [ [ 1, 2 ],
+                       [ 3, 4 ] ] ],
+                   [ [ [ 1, 2 ],
+                       [ 3, 4 ] ],
+                     [ [ 1, 2 ],
+                       [ 3, 4 ] ] ] ])
+    x = CArray.composite(CA_INT32, [2,2], list, 2)
+    assert_equal(y, x)
+
+    x = CArray.composite(CA_INT32, [2,2], list, -1)
+    assert_equal(y, x)
+
+  end
+
+end

data/test/test_convert.rb

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

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

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