carray 1.5.1 → 1.5.6

data/spec/Features/feature_boolean_spec.rb

@@ -0,0 +1,98 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestBooleanType " do
+
+  example "boolean_bit_operations" do
+    a = CArray.int(3,3).seq!
+    e0 = a < 4
+    e1 = a >= 4
+
+    # ---
+    is_asserted_by {  e0 != (e0 & 1) }
+    is_asserted_by {  e0 == (e0 & true) }
+    is_asserted_by {  a.false == (e0 & false) }
+
+    is_asserted_by {  a.true != (e0 | 1) }
+    is_asserted_by {  a.true == (e0 | true) }
+    is_asserted_by {  e0 == (e0 | false) }
+
+    is_asserted_by {  e1 != (e0 ^ 1) }
+    is_asserted_by {  e1 == (e0 ^ true) }
+    is_asserted_by {  e0 == (e0 ^ false) }
+
+    # ---
+    is_asserted_by {  e0 != (1 & e0) }
+    is_asserted_by {  e0 == (true & e0) }
+    is_asserted_by {  a.false == (false & e0) }
+
+    is_asserted_by {  a.true != (1 | e0) }
+    is_asserted_by {  a.true == (true | e0) }
+    is_asserted_by {  e0 == (false | e0) }
+
+    is_asserted_by {  e1 != (1 ^ e0) }
+    is_asserted_by {  e1 == (true ^ e0) }
+    is_asserted_by {  e0 == (false ^ e0) }
+
+  end
+
+  example "boolean_bit_operations2" do
+    a = CArray.int(3,3).seq!
+    e0 = a < 4
+    e1 = a >= 4
+
+    one  = a.one
+    zero = a.zero
+    tt   = a.true
+    ff   = a.false
+
+    # ---
+    is_asserted_by {  e0 != (e0 & one) }
+    is_asserted_by {  e0 == (e0 & tt) }
+    is_asserted_by {  ff == (e0 & ff) }
+
+    is_asserted_by {  tt != (e0 | one) }
+    is_asserted_by {  tt == (e0 | tt) }
+    is_asserted_by {  e0 == (e0 | ff) }
+
+    is_asserted_by {  e1 != (e0 ^ one) }
+    is_asserted_by {  e1 == (e0 ^ tt) }
+    is_asserted_by {  e0 == (e0 ^ ff) }
+
+    # ---
+    is_asserted_by {  e0 != (one & e0) }
+    is_asserted_by {  e0 == (tt & e0) }
+    is_asserted_by {  ff == (ff & e0) }
+
+    is_asserted_by {  tt != (one | e0) }
+    is_asserted_by {  tt == (tt | e0) }
+    is_asserted_by {  e0 == (ff | e0) }
+
+    is_asserted_by {  e1 != (one ^ e0) }
+    is_asserted_by {  e1 == (tt ^ e0) }
+    is_asserted_by {  e0 == (ff ^ e0) }
+
+  end
+
+  example "boolean_bit_operation_with_non_boolean_integer_type" do
+
+    a = CA_BOOLEAN([1,1,1,1])
+    b = CA_INT([0,1,2,3])
+    
+    is_asserted_by { a & b == CA_INT([0, 1, 0, 1]) }
+    is_asserted_by { a | b == CA_INT([1, 1, 3, 3]) }
+    is_asserted_by { a ^ b == CA_INT([1, 0, 3, 2]) }
+
+  end
+
+  example "boolean_arithmetic_operation" do
+    a = CA_BOOLEAN([1,1,0,0])
+    b = CA_INT(    [0,1,1,0])
+
+    expect { a + a }.to raise_error(CArray::DataTypeError)
+
+    is_asserted_by { a + b == CA_INT([1, 2, 1, 0]) }
+  end
+
+end

data/spec/Features/feature_broadcast.rb

@@ -0,0 +1,116 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "CArray.broadcast" do
+
+  example "basic" do
+    a = CArray.int(3,3).seq
+    b = CArray.int(1,3).seq
+    c = CArray.int(3,1).seq
+
+    aa, bb, cc = CArray.broadcast(a,b,c)
+
+    is_asserted_by { aa == a }
+    is_asserted_by { bb == CA_INT([[0,1,2],
+                                   [0,1,2],
+                                   [0,1,2]]) }
+    is_asserted_by { cc == CA_INT([[0,0,0],
+                                   [1,1,1],
+                                   [2,2,2]]) }
+
+  end
+
+  example "with unboud repeat" do
+    a = CArray.int(3,3).seq
+    b = CArray.int(3).seq[:*,nil]
+    c = CArray.int(3).seq[nil,:*]
+
+    aa, bb, cc = CArray.broadcast(a,b,c)
+
+    is_asserted_by { aa == a }
+    is_asserted_by { bb == CA_INT([[0,1,2],
+                                   [0,1,2],
+                                   [0,1,2]]) }
+    is_asserted_by { cc == CA_INT([[0,0,0],
+                                   [1,1,1],
+                                   [2,2,2]]) }
+
+  end
+
+  example "with cscalar" do 
+    a = CArray.int(3,3).seq
+    b = CA_INT(3)            ### CScalar
+
+    aa, bb = CArray.broadcast(a,b)
+    is_asserted_by { aa == a }
+    is_asserted_by { bb.class == CScalar }
+    is_asserted_by { bb == b }
+    
+  end
+  
+  example "can't broadcast" do 
+    a = CArray.int(3,3).seq
+    b = CArray.int(3,2).seq
+    c = CArray.int(2,2).seq
+
+    expect {
+      aa, bb, cc = CArray.broadcast(a,b,c)
+    }.to raise_error(RuntimeError)
+  end
+  
+  example "1 elements array" do 
+    a = CArray.int(1,1).seq
+    b = CArray.int(1,1).seq
+    c = CArray.int(1,1).seq
+
+    aa, bb, cc = CArray.broadcast(a,b,c)
+
+    is_asserted_by { aa == a }
+    is_asserted_by { bb == b }
+    is_asserted_by { cc == c } 
+  end
+  
+  example "include numeric" do 
+    a = CArray.int(1,3).seq
+    b = 1.0
+    c = CArray.int(3,1).seq
+    
+    aa, bb, cc = CArray.broadcast(a,b,c)
+   
+    is_asserted_by { aa == CA_INT([[0,1,2],
+                                   [0,1,2],
+                                   [0,1,2]]) }
+    is_asserted_by { bb == 1.0 }                                   
+    is_asserted_by { cc == CA_INT([[0,0,0],
+                                   [1,1,1],
+                                   [2,2,2]]) }
+
+  end
+
+  example "all numeric" do 
+    a = 1.0
+    b = 2.0
+    c = 3.0
+    aa, bb, cc = CArray.broadcast(a,b,c)
+    is_asserted_by { aa == a }
+    is_asserted_by { bb == b }                                   
+    is_asserted_by { cc == c }
+  end
+  
+  example "extension of dimension" do
+    a = CA_INT([[1,2,3],[4,5,6]])
+    
+    is_asserted_by { a.broadcast_to(1,2,1,3) == CA_INT([[[[ 1, 2, 3 ]],
+                                                         [[ 4, 5, 6 ]]]]) }
+
+    is_asserted_by { a.reshape(2,1,3).broadcast_to(1,2,1,3) == CA_INT([[[[ 1, 2, 3 ]],
+                                                                        [[ 4, 5, 6 ]]]]) }
+      
+    is_asserted_by { a.reshape(1,2,3).broadcast_to(1,2,1,3) == CA_INT([[[[ 1, 2, 3 ]],
+                                                                        [[ 4, 5, 6 ]]]]) }
+      
+      
+  end
+  
+  
+end

data/spec/Features/feature_cast_function.rb

@@ -0,0 +1,19 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "Cast function" do
+
+  example "CA_SIZE" do
+    # ---
+    a = CA_SIZE([1,2,3])
+    is_asserted_by { a.data_type == CA_INT64 }
+  end
+
+  example "CA_SIZE" do
+    # ---
+    a = CA_SIZE([1,2,3])
+    is_asserted_by { a.data_type == CA_INT64 }
+  end
+
+
+end

data/spec/Features/feature_cast_spec.rb

@@ -0,0 +1,33 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCast " do
+
+  example "obj_to_numeric" do
+    # ---
+    a = CA_OBJECT([1,2,3])
+    b = CA_INT32([1,2,3])
+    c = CA_FLOAT64([1,2,3])
+    is_asserted_by {  b == a.int32 }
+    is_asserted_by {  c == a.float64 }
+
+    # ---
+    a = CA_OBJECT(["1","2","3"])
+    b = CA_INT32([1,2,3])
+    c = CA_FLOAT64([1,2,3])
+    is_asserted_by {  b == a.int32 }
+    is_asserted_by {  c == a.float64 }
+
+    # ---
+    a = CA_OBJECT([nil, nil, nil])
+    expect { a.int32 }.to raise_error(TypeError)
+#    assert_raise(TypeError) { a.float32 }
+
+    # ---
+    a = CA_OBJECT(["a", "b", "c"])
+    expect { a.int32 }.to raise_error(ArgumentError)
+#    expect { a.float32 }.to raise_error(ArgumentError)
+  end
+
+
+end

data/spec/Features/feature_class_spec.rb

@@ -0,0 +1,84 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayClass " do
+
+  # CA_BIG_ENDIAN : 1
+  # CA_LITTLE_ENDIAN : 0
+
+  example "endian" do
+    if [1].pack("s") == [1].pack("n")
+      endian = CA_BIG_ENDIAN
+    else
+      endian = CA_LITTLE_ENDIAN
+    end
+    is_asserted_by {  CArray.endian == endian }
+    case endian
+    when CA_BIG_ENDIAN
+      is_asserted_by {  CArray.big_endian? == true }
+      is_asserted_by {  CArray.little_endian? == false }
+    when CA_LITTLE_ENDIAN
+      is_asserted_by {  CArray.big_endian? == false }
+      is_asserted_by {  CArray.little_endian? == true }
+    end
+  end
+
+  example "sizeof" do
+    is_asserted_by {  CArray.sizeof(CA_INT8) == 1 }
+    is_asserted_by {  CArray.sizeof(CA_UINT8) == 1 }
+    is_asserted_by {  CArray.sizeof(CA_INT16) == 2 }
+    is_asserted_by {  CArray.sizeof(CA_UINT16) == 2 }
+    is_asserted_by {  CArray.sizeof(CA_INT32) == 4 }
+    is_asserted_by {  CArray.sizeof(CA_UINT32) == 4 }
+    # is_asserted_by { CArray.sizeof(CA_INT64), 8)
+    # is_asserted_by { CArray.sizeof(CA_UINT64), 8)
+    is_asserted_by {  CArray.sizeof(CA_FLOAT32) == 4 }
+    is_asserted_by {  CArray.sizeof(CA_FLOAT64) == 8 }
+    # is_asserted_by { CArray.sizeof(CA_FLOAT128), 16)
+    # is_asserted_by { CArray.sizeof(CA_CMPLX64), 8)
+    # is_asserted_by { CArray.sizeof(CA_CMPLX128), 16)
+    # is_asserted_by { CArray.sizeof(CA_CMPLX256), 32)
+    is_asserted_by {  CArray.sizeof(CA_FIXLEN) == 0 }
+    # is_asserted_by { CArray.sizeof(CA_OBJECT), 0)
+  end
+
+  example "valid_type?" do
+    # can't test this method
+    expect { CArray.data_type?(-1) }.to raise_error(ArgumentError)
+    is_asserted_by {  CArray.data_type?(CA_FIXLEN) == true }
+    is_asserted_by {  CArray.data_type?(CA_INT8) == true }
+    is_asserted_by {  CArray.data_type?(CA_INT32) == true }
+    is_asserted_by {  CArray.data_type?(CA_FLOAT32) == true }
+    is_asserted_by {  CArray.data_type?(CA_OBJECT) == true }
+    expect { CArray.data_type?(CA_OBJECT+1) }.to raise_error(ArgumentError)
+  end
+
+  example "type_name" do
+    [
+     [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)
+        is_asserted_by {  CArray.data_type_name(type) == name }
+      else
+        expect { CArray.data_type_name(type) }.to raise_error(RuntimeError)
+      end
+    end
+  end
+
+end

data/spec/Features/feature_complex_spec.rb

@@ -0,0 +1,42 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestComplex " do
+
+  example "complex" do
+    a = CArray.complex(3,3) { 1 + 2*CI }
+    is_asserted_by { a.real == CArray.float(3, 3) { 1 } }
+    is_asserted_by { a.imag == CArray.float(3, 3) { 2 } }
+    a.real[] = -1
+    a.imag[] = -2
+    is_asserted_by { a.real == CArray.float(3, 3) { -1 } }
+    is_asserted_by { a.imag == CArray.float(3, 3) { -2 } }
+  end
+
+  example "dcomplex" do
+    a = CArray.dcomplex(3,3) { 1 + 2*CI }
+    is_asserted_by { a.real == CArray.double(3, 3) { 1 } }
+    is_asserted_by { a.imag == CArray.double(3, 3) { 2 } }
+    a.real = -1
+    a.imag = -2
+    is_asserted_by { a.real == CArray.double(3, 3) { -1 } }
+    is_asserted_by { a.imag == CArray.double(3, 3) { -2 } }
+  end
+
+  example "conj" do
+    a = CArray.complex(3,3) { 1 + 2*CI }
+    a.conj!
+    is_asserted_by { a.real == CArray.float(3, 3) { 1 } }
+    is_asserted_by { a.imag == CArray.float(3, 3) { -2 } }
+  end
+
+  example "arg" do
+    a = CArray.complex(3,3) { 1 + 2*CI }
+    a.conj!
+    is_asserted_by { a.real == CArray.float(3, 3) { 1 } }
+    is_asserted_by { a.imag == CArray.float(3, 3) { -2 } }
+  end
+
+
+end

data/{test/test_composite.rb → spec/Features/feature_composite_spec.rb}

@@ -1,11 +1,10 @@
-$:.unshift("../lib", "..")
 
-require 'test/unit'
 require 'carray'
+require "rspec-power_assert"
 
-class TestCArrayComposite < Test::Unit::TestCase
+describe "TestCArrayComposite " do
 
-  def test_combine
+  example "combine" do
     a1 = CArray.int32(2,2){1}
     a2 = CArray.int32(2,2){2}
     a3 = CArray.int32(2,2){3}
@@ -24,7 +23,7 @@ class TestCArrayComposite < Test::Unit::TestCase
                   [4,4],
                  ])
     x = CArray.combine(CA_INT32, [4], list, 0)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
     # ---
     y = CA_INT32([
@@ -32,9 +31,9 @@ class TestCArrayComposite < Test::Unit::TestCase
                   [1,1,2,2,3,3,4,4]
                  ])
     x = CArray.combine(CA_INT32, [4], list, -1)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
     x = CArray.combine(CA_INT32, [4], list, 1)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
     # ---
     y = CA_INT32([
@@ -44,17 +43,17 @@ class TestCArrayComposite < Test::Unit::TestCase
                   [3,3,4,4],
                  ])
     x = CArray.combine(CA_INT32, [2,2], list, 0)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
     x = CArray.combine(CA_INT32, [2,2], list, -1)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
-    assert_raise(RuntimeError) {
+    expect {
       CArray.combine(CA_INT32, [2,2], list, 1)
-    }
+    }.to raise_error(RuntimeError)
 
   end
 
-  def test_composite
+  example "composite" do
     a1 = CArray.int32(2,2){1}
     a2 = CArray.int32(2,2){2}
     a3 = CArray.int32(2,2){3}
@@ -71,7 +70,7 @@ class TestCArrayComposite < Test::Unit::TestCase
                    [ [ 4, 4 ],
                      [ 4, 4 ] ] ])
     x = CArray.composite(CA_INT32, [4], list, 0)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
     # ---
     y = CA_INT32([ [ [ 1, 2, 3, 4 ],
@@ -79,7 +78,7 @@ class TestCArrayComposite < Test::Unit::TestCase
                    [ [ 1, 2, 3, 4 ],
                      [ 1, 2, 3, 4 ] ] ])
     x = CArray.composite(CA_INT32, [4], list, -1)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
     # ---
     y = CA_INT32([ [ [ [ 1, 1 ],
@@ -91,7 +90,7 @@ class TestCArrayComposite < Test::Unit::TestCase
                      [ [ 4, 4 ],
                        [ 4, 4 ] ] ] ])
     x = CArray.composite(CA_INT32, [2,2], list, 0)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
     # ---
     y = CA_INT32([ [ [ [ 1, 1 ],
@@ -103,7 +102,7 @@ class TestCArrayComposite < Test::Unit::TestCase
                      [ [ 3, 3 ],
                        [ 4, 4 ] ] ] ])
     x = CArray.composite(CA_INT32, [2,2], list, 1)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
     # ---
     y = CA_INT32([ [ [ [ 1, 2 ],
@@ -115,10 +114,10 @@ class TestCArrayComposite < Test::Unit::TestCase
                      [ [ 1, 2 ],
                        [ 3, 4 ] ] ] ])
     x = CArray.composite(CA_INT32, [2,2], list, 2)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
     x = CArray.composite(CA_INT32, [2,2], list, -1)
-    assert_equal(y, x)
+    is_asserted_by { y == x }
 
   end