carray 1.5.1 → 1.5.6

data/spec/Classes/CAObject_attribute_spec.rb

@@ -0,0 +1,33 @@
+
+require "carray"
+require "rspec-power_assert"
+
+describe "CArray#elements" do
+
+  example "should return element number of array" do
+    ca = CArray.int32(2,3,4)
+    is_asserted_by { ca.elements == 2*3*4 }
+    is_asserted_by { ca.length == 2*3*4 }
+    is_asserted_by { ca.size == 2*3*4 }
+  end
+
+end
+
+describe "CArray#data_type" do
+  
+  example "should return data type of array" do
+    ca = CArray.int32(2,3,4)
+    is_asserted_by { ca.data_type == CA_INT32 }
+  end
+
+end
+
+describe "CArray#dim" do
+
+  example "should return a array contains the shape of array" do
+    ca = CArray.int32(2,3,4)
+    is_asserted_by { ca.dim == [2,3,4] }
+  end
+
+end
+

data/spec/Classes/CAObject_spec.rb

@@ -0,0 +1,33 @@
+
+require "carray"
+require "rspec-power_assert"
+
+
+describe "CArray.new" do
+
+  example "should return a CA_INT type carray if CA_INT is specified as data_type" do
+    ca = CArray.new(CA_INT, [2,3,4])
+    is_asserted_by { ca.class == CArray }
+    is_asserted_by { ca.data_type == CA_INT }
+  end
+
+  example "should return a CA_FIXLEN type carray if CA_FIXLEN is specified as data_type" do
+    ca = CArray.new(CA_FIXLEN, [2,3,4], :bytes=>3)
+    is_asserted_by { ca.class == CArray }
+    is_asserted_by { ca.data_type == CA_FIXLEN }
+    is_asserted_by { ca.bytes == 3 }
+  end
+
+  example "should return a carray filled by 0 when data_type == CA_INT" do
+    ca = CArray.new(CA_INT, [2,3,4])
+    is_asserted_by { ca[0] == 0 }
+    is_asserted_by { ca.all_equal?(0) == true }
+  end
+
+  example "should return a carray filled by string filled by 0 when data_type == CA_FIXLEN" do
+    ca = CArray.new(CA_FIXLEN, [2,3,4], :bytes=>3)
+    is_asserted_by { ca[0] == "\0\0\0" }
+    is_asserted_by { ca.all_equal?("\0\0\0") == true }
+  end
+
+end

data/spec/Classes/CARefer_spec.rb

@@ -0,0 +1,93 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCARefer " do
+
+  example "virtual_array" do
+    a = CArray.int(3,3)
+    b = a.refer(CA_INT,[9])
+    r = b.parent
+    is_asserted_by { b.class == CARefer }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { a == r }
+  end
+
+  example "basic_features" do
+    # ---
+    a = CArray.int(3,2).seq!
+    r = a.reshape(2,3)
+    is_asserted_by { a.data_type == r.data_type }
+    is_asserted_by { [2, 3] == r.dim }
+    is_asserted_by { CA_INT([[0,1,2],
+                         [3,4,5]]) == r }
+
+    # ---
+    # less data number
+    a = CArray.int(3,2).seq!
+    r = a.reshape(2,2)
+    is_asserted_by { CA_INT([[0,1],
+                         [2,3]]) == r }
+
+    # ---
+    # data type change (int -> float)
+    a = CArray.int(3,2).seq!
+    r = a.refer(CA_FLOAT32, [2,3])
+    rr = r.refer(CA_INT32, [3,2])
+    is_asserted_by { CA_FLOAT == r.data_type }
+    is_asserted_by { a == rr }
+  end
+
+  example "refer_to_virtual_array" do
+    # ---
+    a = CArray.int(3,3).seq!
+    b = a[1..2,1..2]
+    r = b.reshape(4)
+    is_asserted_by { CA_INT([4, 5, 7, 8]) == r }
+
+    # ---
+    a = CArray.int(3).seq!
+    b = a[:%,3]
+    r = b.reshape(9)
+    is_asserted_by { CA_INT([0, 0, 0, 1, 1, 1, 2, 2, 2]) == r }
+
+  end
+
+  example "invalid_args" do
+    # ---
+    a = CArray.int8(3,3).seq!
+    expect { a.reshape(10) }.to raise_error(RuntimeError) ### too large data num
+    expect { a.refer(CA_INT,[9]) }.to raise_error(RuntimeError)
+                                                   ### larger data type bytes
+
+  end
+
+  example "flatten" do
+    a = CArray.int(3,3).seq!
+    b = CArray.int(9).seq!
+
+    # ---
+    is_asserted_by { b == a.flatten }
+    is_asserted_by { b == a.flattened }
+
+    # ---
+    c = a.reverse
+    a.flattened.reverse!
+    is_asserted_by { c == a }
+  end
+
+  example "refer_variant" do
+    a = CArray.fixlen(4, :bytes=>4) {"abcd"}
+    b = CA_FIXLEN([["ab", "cd"],
+                   ["ab", "cd"],
+                   ["ab", "cd"],
+                   ["ab", "cd"]], :bytes=>2)
+    c = CA_FIXLEN(["abcdabcd", "abcdabcd"], :bytes=>8)
+
+    # ---
+    is_asserted_by { b == a.refer(CA_FIXLEN, [4, 2], bytes: 2) }
+    is_asserted_by { c == a.refer(CA_FIXLEN, [2], bytes: 8) }
+
+  end
+
+end

data/spec/Classes/CARepeat_spec.rb

@@ -0,0 +1,65 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCARepeat " do
+
+  example "virtual_array" do
+    a = CArray.int(3)
+    b = a[:%,3]
+    r = b.parent
+    is_asserted_by { b.class == CARepeat }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { true == b.read_only? }
+    is_asserted_by { false == b.attached? }
+    is_asserted_by { a == r }
+  end
+
+  example "basic_feature" do
+    # ---
+    a = CArray.int(3).seq!
+    r1 = a[3,:%]
+    r2 = a[:%,3]
+    is_asserted_by { CA_INT([[0,1,2],
+                         [0,1,2],
+                         [0,1,2]]) == r1 }
+    is_asserted_by { CA_INT([[0,0,0],
+                         [1,1,1],
+                         [2,2,2]]) == r2 }
+    # ---
+    b = CArray.int(2,2).seq!
+    is_asserted_by { CA_INT([[[ 0, 1 ],
+                          [ 0, 1 ]],
+                         [[ 2, 3 ],
+                          [ 2, 3 ]]]) == b[:%,2,:%] }
+  end
+
+  example "store" do
+    a = CArray.int(3).seq!
+    r1 = a[3,:%]
+    expect { r1[1,1] = 1 }.to raise_error(RuntimeError)
+    expect { r1.seq! }.to raise_error(RuntimeError)    
+    r2 = a[:%,3]
+    expect { r1[1,1] = 1 }.to raise_error(RuntimeError)
+    expect { r1.seq! }.to raise_error(RuntimeError)    
+  end
+
+  example "mask_repeat" do
+    a = CArray.int(3).seq!
+    a[1] = UNDEF
+    r1 = a[3,:%]
+    x1 = r1.to_ca
+    is_asserted_by { 3 == r1.count_masked }
+    is_asserted_by { 3 == r1[nil, 1].count_masked }
+    is_asserted_by { 3 == x1.count_masked }
+    is_asserted_by { 3 == x1[nil, 1].count_masked }
+    
+    r2 = a[:%,3]
+    x2 = r2.to_ca
+    is_asserted_by { 3 == r2.count_masked }
+    is_asserted_by { 3 == r2[1, nil].count_masked }
+    is_asserted_by { 3 == x2.count_masked }
+    is_asserted_by { 3 == x2[1, nil].count_masked }
+  end
+
+end

data/spec/Classes/CASelect_spec.rb

@@ -0,0 +1,22 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCASelect " do
+
+  example "virtual_array" do
+    a = CArray.int(3,3) { 0 }
+    b = a[a.eq(0)]
+    r = b.parent
+    is_asserted_by { b.class == CASelect }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { a == r }
+  end
+
+  example "select_to_a" do
+    a = CArray.int(3,3).seq!
+    s = a[a >= 4]
+    is_asserted_by { [4, 5, 6, 7, 8] == a[s].to_a }
+  end
+
+end

data/spec/Classes/CAShift_spec.rb

@@ -0,0 +1,16 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCAShift " do
+
+  example "virtual_array" do
+    a = CArray.int(3,3)
+    b = a.shifted(1,1)
+    r = b.parent
+    is_asserted_by { b.class == CAShift }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { a == r }
+  end
+
+end

data/spec/Classes/CAStruct_spec.rb

@@ -0,0 +1,71 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayStruct " do
+
+  example "struct" do
+    st = CA.struct(:pack=>1) { uint16 :mem_i; char_p :mem_f, :bytes => 3 }
+    a = CArray.new(st, [3])
+    b = CArray.new(:fixlen, [3], :bytes=>3)
+    is_asserted_by {  true == a.has_data_class? }
+    is_asserted_by {  st == a.data_class }
+    is_asserted_by {  true == a.to_ca.has_data_class? }
+    is_asserted_by {  st == a.to_ca.data_class }
+    is_asserted_by {  true == a.template.has_data_class? }
+    is_asserted_by {  st == a.template.data_class }
+    is_asserted_by {  true == a[].has_data_class? }
+    is_asserted_by {  st == a[].data_class }
+    is_asserted_by {  false == b.has_data_class? }
+  end
+
+  example "struct_to_type" do
+    st = CA.struct(:pack=>1) { uint16 :mem_i; char_p :mem_f, :bytes => 3 }
+    is_asserted_by {  5 == st.size }
+    a = CArray.new(:fixlen, [3], :bytes=>5)
+    b = a.to_type(st)
+    is_asserted_by {  false == a.has_data_class? }
+    is_asserted_by {  true == b.has_data_class? }
+    is_asserted_by {  st == b.data_class }
+  end
+
+  example "struct_refer" do
+    st = CA.struct(:pack=>1) { uint16 :mem_i; char_p :mem_f, :bytes => 3 }
+    a = CArray.new(:fixlen, [3], :bytes=>5)
+    b = a.refer(st, a.dim)
+    is_asserted_by {  false == a.has_data_class? }
+    is_asserted_by {  true == b.has_data_class? }
+    is_asserted_by {  st == b.data_class }
+  end
+
+  example "swap_bytes" do
+    st = CA.struct(:pack=>1) {
+      uint16 :mem_i
+      char_p :mem_f, :bytes => 3
+      struct(:mem_s) {
+        uint16 :mem_i
+        char_p :mem_f, :bytes => 3
+      }
+    }
+    a = CArray.new(st, [3])
+    is_asserted_by {  true == a.has_data_class? }
+    is_asserted_by {  st == a.data_class }
+    is_asserted_by {  CAField == a.field(:mem_i).class }
+    is_asserted_by {  CAField == a.field(:mem_s).class }
+    is_asserted_by {  a.field("mem_i") == a["mem_i"] }
+    a["mem_i"] = 255
+    a["mem_f"] = "abc"
+    a["mem_s"]["mem_i"] = (255 << 8)
+    a["mem_s"]["mem_f"] = "abc"
+    b = CArray.new(st, [3])
+    b["mem_i"] = (255 << 8)
+    b["mem_f"] = "cba"
+    b["mem_s"]["mem_i"] = 255
+    b["mem_s"]["mem_f"] = "cba"
+    is_asserted_by {  b == a.swap_bytes }
+    is_asserted_by {  a == b.swap_bytes }
+    a.swap_bytes!
+    is_asserted_by {  b == a }
+  end
+
+end

data/{test/test_CATranspose.rb → spec/Classes/CATranspose_spec.rb}

@@ -1,26 +1,25 @@
-$:.unshift("../lib", "..")
 
-require 'test/unit'
 require 'carray'
+require "rspec-power_assert"
 
-class TestCArrayCATranspose < Test::Unit::TestCase
+describe "TestCArrayCATranspose " do
 
-  def test_virtual_array
+  example "virtual_array" do
     a = CArray.int(3,3)
     b = a.transposed
     r = b.parent
-    assert_instance_of(CATranspose, b)
-    assert_equal(true, b.virtual?)
-    assert_equal(a, r)
+    is_asserted_by { b.class == CATranspose }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { a == r }
   end
 
-  def test_basic_feature
+  example "basic_feature" do
     # ---
     a = CArray.int(3,3).seq!
     t = a.transposed
-    assert_equal(CA_INT([[0,3,6],
+    is_asserted_by { CA_INT([[0,3,6],
                          [1,4,7],
-                         [2,5,8]]), t)
+                         [2,5,8]]) == t }
 
     # ---
     a = CArray.int(2,2,2).seq!
@@ -28,34 +27,34 @@ class TestCArrayCATranspose < Test::Unit::TestCase
     t2 = a.transposed(0,2,1) # 1 <-> 2
     t3 = a.transposed(2,1,0) # 0 <-> 2
     t4 = a.transposed(1,0,2) # 0 <-> 1
-    assert_equal(CA_INT([[[0,1],
+    is_asserted_by { CA_INT([[[0,1],
                           [2,3]],
                          [[4,5],
-                          [6,7]]]), t1)
-    assert_equal(CA_INT([[[0,2],
+                          [6,7]]]) == t1 }
+    is_asserted_by { CA_INT([[[0,2],
                           [1,3]],
                          [[4,6],
-                          [5,7]]]), t2)
-    assert_equal(CA_INT([[[0,4],
+                          [5,7]]]) == t2 }
+    is_asserted_by { CA_INT([[[0,4],
                           [2,6]],
                          [[1,5],
-                          [3,7]]]), t3)
-    assert_equal(CA_INT([[[0,1],
+                          [3,7]]]) == t3 }
+    is_asserted_by { CA_INT([[[0,1],
                           [4,5]],
                          [[2,3],
-                          [6,7]]]), t4)
+                          [6,7]]]) == t4 }
 
     # ---
     a = CArray.int(2,2,2).seq!
 
     x1 = a.transposed(1,2,0) # 0 -> 2, 1 -> 0, 2 -> 1
     y1 = a.transposed(2,1,0).transposed(1,0,2) # 1 <-> 2; 0 <-> 1
-    assert_equal(y1, x1)
+    is_asserted_by { y1 == x1 }
 
     x2 = a.transposed(2,0,1) # 0 -> 1, 1 -> 2, 2 -> 0
     y2 = a.transposed(2,1,0).transposed(0,2,1) # 0 <-> 2; 1 <-> 2
-    assert_equal(y2, x2)
+    is_asserted_by { y2 == x2 }
 
   end
 
-end
+end

data/spec/Classes/CAUnboudRepeat_spec.rb

@@ -0,0 +1,102 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "CAUnboundRepeat" do
+  
+  example "basic" do 
+    a = CA_INT([1,2,3])
+    b = a[:*,nil]
+    c = a[nil,:*]
+    
+    is_asserted_by { b.class == CAUnboundRepeat }
+    is_asserted_by { b.ndim == 2 }
+    is_asserted_by { b.shape == [1,3] }
+    
+
+    is_asserted_by { c.class == CAUnboundRepeat }
+    is_asserted_by { c.ndim == 2 }
+    is_asserted_by { c.shape == [3,1] }
+
+  end
+  
+  example "ref" do 
+    a = CA_INT(0..2)[:*,nil]
+    is_asserted_by { a[0] == 0 }
+    is_asserted_by { a[1] == 1 }
+    is_asserted_by { a[2] == 2 }
+    is_asserted_by { a.bind(3,3) == CA_INT([[0,1,2],
+                                            [0,1,2],
+                                            [0,1,2]]) }
+    is_asserted_by { a[0,0] == 0 }
+    is_asserted_by { a[0,1] == 1 }
+    is_asserted_by { a[0,2] == 2 }
+    is_asserted_by { a.to_a == [[0,1,2]] }
+  end
+  
+  example "bind" do 
+  
+    a = CA_INT([1,2,3])
+    b = a[:*,nil]
+    c = a[nil,:*]
+
+    is_asserted_by { b.bind(3,3) == CA_INT([[1,2,3],
+                                            [1,2,3],
+                                            [1,2,3]]) }
+    is_asserted_by { c.bind(3,3) == CA_INT([[1,1,1],
+                                            [2,2,2],
+                                            [3,3,3]]) }
+  end
+
+  example "bind_with" do 
+  
+    a = CA_INT([1,2,3])
+    b = a[:*,nil]
+    c = a[nil,:*]
+    d = CArray.int(3,3)
+
+    is_asserted_by { b.bind_with(d) == CA_INT([[1,2,3],
+                                               [1,2,3],
+                                               [1,2,3]]) }
+    is_asserted_by { c.bind_with(d) == CA_INT([[1,1,1],
+                                               [2,2,2],
+                                               [3,3,3]]) }
+  end
+  
+  example "arithmetic operation" do 
+
+    a = CA_INT([1,2,3])
+    b = a[:*,nil]
+    c = a[nil,:*]
+    
+    is_asserted_by { b * c == CA_INT([[1,2,3],
+                                      [2,4,6],
+                                      [3,6,9]]) }
+
+    
+  end
+  
+  example "chain of unboundrepeat" do
+    a = CA_INT([1,2,3])
+    b = CArray.int(3,4)
+
+    is_asserted_by { a[:*,nil].shape == [1,3] }
+    is_asserted_by { a[:*,nil][:*,nil,nil].shape == [1,1,3] }
+
+    expect {  a[:*,nil][nil,:*] }.to raise_error(ArgumentError)
+    
+    is_asserted_by { a[:*,nil][nil,nil,:*].shape == [1,3,1] }
+    is_asserted_by { a[:*,nil][nil,:*,nil].shape == [1,1,3] }
+    is_asserted_by { a[:*,nil][:*,nil,nil].shape == [1,1,3] }
+  end
+  
+  example "extra * in arithmetic operation" do
+    a = CA_INT(1..3)
+    b = CA_INT(1..3)
+    aa = a[:*,:*,nil]
+    bb = b[:*,nil,:*]
+    is_asserted_by { aa.bind_with(bb) == a[3,:%][:*,nil,nil] }
+    is_asserted_by { aa + bb == (a[3,:%]+b[:%,3])[:*,nil,nil] }
+  end
+  
+  
+end