carray 1.4.0 → 1.5.5

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

data/spec/Classes/CAWindow_spec.rb

@@ -0,0 +1,54 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCAWindow " do
+
+  example "virtual_array" do
+    a = CArray.int(3,3).seq!
+    b = a.window(-1..1, -1..1)
+    r = b.parent
+    is_asserted_by { b.class == CAWindow }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { a == r }
+  end
+
+
+  example "basic_features" do
+    # ---
+    a = CArray.int(3,3).seq!
+    b = a.window(-1..1, -1..1)
+    is_asserted_by { CA_INT([[0,0,0],
+                         [0,0,1],
+                         [0,3,4]]) ==  b }
+
+    # ---
+    a = CArray.int(3,3).seq!
+    b = a.window(-1..1, -1..1) { UNDEF}
+    _ = UNDEF
+    is_asserted_by { CA_INT([[_,_,_],
+                         [_,0,1],
+                         [_,3,4]]) == b }
+  end
+
+  example "invalid_args" do
+    # ---
+    a = CArray.int(3,3).seq
+    expect { a.window(1) }.to raise_error(ArgumentError)
+    expect { a.window([nil]) }.to raise_error(ArgumentError)
+    expect { a.window(nil, [nil,2]) }.to raise_error(ArgumentError)
+    expect { a.window(1..-1, nil) }.to raise_error(ArgumentError)
+  end
+
+  example "out_of_index" do
+    # ---
+    a = CArray.int(3,3).seq
+    i1 = CA_INT([1,2,3])
+    i2 = CA_INT([-4,-3,-2])
+    expect { a[i1,nil] }.to raise_error(IndexError)
+    expect { a[nil,i1] }.to raise_error(IndexError)
+    expect { a[i2,nil] }.to raise_error(IndexError)
+    expect { a[nil,i2] }.to raise_error(IndexError)
+  end
+
+end

data/spec/Classes/CAWrap_spec.rb

@@ -0,0 +1,8 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCAWrap " do
+  example "default" do
+  end
+end

data/{test/test_CArray.rb → spec/Classes/CArray_spec.rb}

@@ -1,61 +1,60 @@
-$:.unshift("../lib", "..")
 
-require 'test/unit'
 require 'carray'
+require "rspec-power_assert"
 
-class TestCArray < Test::Unit::TestCase
+describe "TestCArray " do
 
   def assert_carray (ca, type, dim, ary)
-    assert_equal(ca, CArray.new(type, dim){ary})
+    is_asserted_by { ca == CArray.new(type, dim) { ary } }
   end
 
-  def test_s_new
+  example "s_new" do
     a = CArray.new(CA_INT32, [3, 2, 1]) { 1 }
-    assert_instance_of(CArray, a)
+    is_asserted_by { a.class == CArray }
   end
 
-  def test_s_type
+  example "s_type" do
     a = CArray.int32(3, 3) { 1 }
     assert_carray(a, CA_INT32, [3,3], 1)
   end
 
-  def test_equal
+  example "equal" do
     a = CArray.int32(3, 3)  { 0 }
     b = CArray.int32(3, 3)  { 0 }
     c = CArray.uint32(3, 3) { 0 }
     d = CArray.uint32(2, 3) { 0 }
     e = CArray.int32(3, 3)  { 1 }
-    assert_equal(a == b, true)
-    assert_equal(a != b, false)
-    assert_equal(a == c, false)
-    assert_equal(a != c, true)
-    assert_equal(a == d, false)
-    assert_equal(a != d, true)
-    assert_equal(a == e, false)
-    assert_equal(a != e, true)
+    is_asserted_by { (a == b) == true }
+    is_asserted_by { (a != b) == false }
+    is_asserted_by { (a == c) == false }
+    is_asserted_by { (a != c) == true }
+    is_asserted_by { (a == d) == false }
+    is_asserted_by { (a != d) == true }
+    is_asserted_by { (a == e) == false }
+    is_asserted_by { (a != e) == true }
   end
 
-  def test_clone
+  example "clone" do
     a = CArray.int32(3, 3)
-    assert_equal(a.clone, a)
+    is_asserted_by { a.clone == a }
   end
 
-  def test_to_s
+  example "to_s" do
     a = CArray.int8(3, 3) { 1 }
-    assert_equal(a.to_s, "\001"*9)
+    is_asserted_by { a.to_s == ("\u0001" * 9) }
 
     a = CArray.int32(3, 3) { 1 }
-    assert_equal(a.to_s, [1].pack("l")*9)
+    is_asserted_by { a.to_s == ([1].pack("l") * 9) }
   end
 
-  def test_to_ca
+  example "to_ca" do
     a = CArray.int32(3, 3).seq
-    assert_equal(a.to_ca, a)
+    is_asserted_by { a.to_ca == a }
 
     c = CArray.int32(4, 4)
     c[0..2, 0..2] = a
     b = c[0..2, 0..2]
-    assert_equal(b.to_ca, b)
+    is_asserted_by { b.to_ca == b }
 
     a = CArray.int32(3, 3).seq
     assert_carray(a[nil, 0].to_ca, CA_INT32, [3], [0,3,6])
@@ -68,25 +67,14 @@ class TestCArray < Test::Unit::TestCase
 #    assert_carray(a[2, nil].to_ca, CA_INT32, [3], [6,7,8])
   end
 
-  def test_store_array
+  example "store_array" do
     a = CArray.int32(3, 3){1}
     b = CArray.int32(3, 3)
     b[] = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
-    assert_equal(a, b)
+    is_asserted_by { a == b }
   end
 
-  def test_seq
-    a = CArray.int32(3, 3)
-    a.seq!
-    assert_carray(a, CA_INT32, [3,3], [
-        [0, 1, 2],
-        [3, 4, 5],
-        [6, 7, 8]
-      ])
-    assert_equal(a.seq, a)
-  end
-
-  def test_set_value
+  example "set_value" do
     a = CArray.int32(3, 3)
     b = CArray.int32(3, 3)
 
@@ -136,93 +124,61 @@ class TestCArray < Test::Unit::TestCase
       ])
   end
 
-  def test_set_point
+  example "set_point" do
     a = CArray.int32(3, 3) { 0 }
 
     a[1, 1] = 1
-    assert_equal(a[1,1], 1)
+    is_asserted_by { a[1, 1] == 1 }
 
   end
 
-  def test_set_addr
+  example "set_addr" do
     a = CArray.int32(3, 3) { 0 }
 
     a[4] = 1
-    assert_equal(a[1,1], 1)
+    is_asserted_by { a[1, 1] == 1 }
 
     a[3..5] = -1
-    assert_equal(a[1,1], -1)
+    is_asserted_by { a[1, 1] == (-1) }
 
     a[3..5] = [1,2,3]
-    assert_equal(a[1,1], 2)
-  end
-
-  def test_dump_io ()
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3)
-    open("bintest", "w") { |io| a.dump_binary(io) }
-    open("bintest")      { |io| b.load_binary(io) }
-    assert_equal(a, b)
-
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3).seq!
-    open("bintest", "w") { |io| a[0..1, 0..1].dump_binary(io) }
-    open("bintest")      { |io| b[0..1, 0..1].load_binary(io) }
-    assert_equal(a, b)
-  ensure
-    File.unlink("bintest")
-  end
-
-  def test_dump_str ()
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3)
-    s = ""
-    a.dump_binary(s)
-    b.load_binary(s)
-    assert_equal(a, b)
-
-    a = CArray.int32(3, 3).seq!
-    b = CArray.int32(3, 3).seq!
-    s = ""
-    a[0..1, 0..1].dump_binary(s)
-    b[0..1, 0..1].load_binary(s)
-    assert_equal(a, b)
+    is_asserted_by { a[1, 1] == 2 }
   end
 
-  def test_reverse
+  example "reverse" do
     a = CArray.uint8(100).seq!
     b = a[-1..0].to_ca
-    assert_equal(a.reverse!, b)
+    is_asserted_by { a.reverse! == b }
   end
 
-  def test_stat
+  example "stat" do
     a = CArray.float32(3,3).seq!(1,2)
     stddev = Math.sqrt(((a - a.mean)**2).sum/(a.elements-1))
 
-    assert_equal(a.max, 17)
-    assert_equal(a.min, 1)
-    assert_equal(a.sum, 81)
-    assert_equal(a.mean, 9)
-    assert_equal(a.stddev, stddev)
+    is_asserted_by { a.max == 17 }
+    is_asserted_by { a.min == 1 }
+    is_asserted_by { a.sum == 81 }
+    is_asserted_by { a.mean == 9 }
+    is_asserted_by { a.stddev == stddev }
 
     c = CArray.int32(4,4)
     c[0..2, 0..2] = a
     a = c[0..2, 0..2]
-    assert_equal(a.max, 17)
-    assert_equal(a.min, 1)
-    assert_equal(a.sum, 81)
-    assert_equal(a.mean, 9)
-    assert_equal(a.stddev, stddev)
+    is_asserted_by { a.max == 17 }
+    is_asserted_by { a.min == 1 }
+    is_asserted_by { a.sum == 81 }
+    is_asserted_by { a.mean == 9 }
+    is_asserted_by { a.stddev == stddev }
   end
 
-  def test_ancestors
+  example "ancestors" do
     # ---
     a = CArray.int(3,3).seq!
     b = a.reshape(9)
     c = b.reshape(3,3)
     d = c[0..1,0..1]
-    assert_equal(a, d.root_array)
-    assert_equal([a,b,c,d], d.ancestors)
+    is_asserted_by { a == d.root_array }
+    is_asserted_by { [a, b, c, d] == d.ancestors }
   end
 
 end