carray 2.0.0 → 3.0.0

data/spec/Features/feature_boolean_spec.rb

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

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

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

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

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

@@ -1,42 +0,0 @@
-
-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/spec/Features/feature_composite_spec.rb

@@ -1,124 +0,0 @@
-
-require 'carray'
-require "rspec-power_assert"
-
-describe "TestCArrayComposite " do
-
-  example "combine" do
-    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)
-    is_asserted_by { 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)
-    is_asserted_by { y == x }
-    x = CArray.combine(CA_INT32, [4], list, 1)
-    is_asserted_by { 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)
-    is_asserted_by { y == x }
-    x = CArray.combine(CA_INT32, [2,2], list, -1)
-    is_asserted_by { y == x }
-
-    expect {
-      CArray.combine(CA_INT32, [2,2], list, 1)
-    }.to raise_error(RuntimeError)
-
-  end
-
-  example "composite" do
-    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)
-    is_asserted_by { 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)
-    is_asserted_by { 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)
-    is_asserted_by { 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)
-    is_asserted_by { 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)
-    is_asserted_by { y == x }
-
-    x = CArray.composite(CA_INT32, [2,2], list, -1)
-    is_asserted_by { y == x }
-
-  end
-
-end

data/spec/Features/feature_convert_spec.rb

@@ -1,46 +0,0 @@
-
-require 'carray'
-require "rspec-power_assert"
-
-describe "TestCArray " do
-
-  example "conversion" do
-    is_asserted_by { CA_INT32(1) == CScalar.int32 { 1 } }
-    is_asserted_by { CA_INT32([1]) == CArray.int32(1) { [1] } }
-    is_asserted_by { CA_INT32([[0, 1], [2, 3]]) == CArray.int32(2, 2).seq! }
-    expect { CA_INT32([1,[1,2]]) }.to raise_error(TypeError)
-  end
-
-  example "compact" do
-    a = CArray.int(4,1,3,1,2,1).seq!
-    b = CArray.int(4,3,2).seq!
-    
-    is_asserted_by { b == a.compacted }
-    is_asserted_by { CARefer == a.compacted.class }
-    is_asserted_by { b == a.compact }
-    is_asserted_by { CArray == a.compact.class }
-  end
-
-  example "to_a" do
-    # ---
-    a = CArray.int(3).seq!
-    is_asserted_by { [0, 1, 2] == a.to_a }
-
-    # ---
-    a = CArray.int(3,3).seq!
-    is_asserted_by { [[0, 1, 2], [3, 4, 5], [6, 7, 8]] == a.to_a }
-  end
-
-  example "convert" do
-    # ---
-    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 
-    is_asserted_by { CA_OBJECT(["a", "b", "c"]) == b }
-  end 
-
-  
-end

data/spec/Features/feature_copy_spec.rb

@@ -1,123 +0,0 @@
-require "carray"
-require 'rspec-power_assert'
-
-describe "Feature: Copying" do
-
-  example "to_ca" do
-    #
-    a = CArray.int32(3,3).seq
-    b = a.to_ca
-    is_asserted_by { CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, 4, 5 ],
-                            [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { a == b }
-
-    # mask does not be templated
-    a = CArray.int32(3,3).seq
-    a[1,1] = UNDEF
-    b = a.to_ca
-    is_asserted_by { CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, UNDEF, 5 ],
-                            [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { a == b }
-  end
-
-  example "template" do
-    #
-    a = CArray.int32(3,3).seq
-    b = a.template {1}
-    is_asserted_by { CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, 4, 5 ],
-                            [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { 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}
-    is_asserted_by { CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, UNDEF, 5 ],
-                            [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { CA_INT32([ [ 1, 1, 1 ],
-                            [ 1, 1, 1 ],
-                            [ 1, 1, 1 ] ]) == b }
-  end
-
-  example "to_type" do
-    #
-    a = CArray.int8(3,3).seq
-    b = a.int32
-    is_asserted_by { CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, 4, 5 ],
-                           [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { 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
-    is_asserted_by { CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, UNDEF, 5 ],
-                           [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { CA_INT32([ [ 0, 1, 2 ],
-                            [ 3, UNDEF, 5 ],
-                            [ 6, 7, 8 ] ]) == b }
-  end
-
-  example "convert" do
-    #
-    a = CArray.int8(3,3).seq
-    b = a.convert(CA_INT32) {|x| 2*x}
-    is_asserted_by { CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, 4, 5 ],
-                           [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { 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 }
-    is_asserted_by { CA_INT8([ [ 0, 1, 2 ],
-                           [ 3, UNDEF, 5 ],
-                           [ 6, 7, 8 ] ]) == a }
-    is_asserted_by { CA_INT32([ [ 0, 2, 4 ],
-                            [ 6, UNDEF, 10 ],
-                            [ 12, 14, 16 ] ]) == b }
-  end
-
-  example "transform" do
-    #
-    a = CArray.uint8(2,4) { 0xff }
-    b = a.refer(CA_UINT16, [2,2]).to_ca
-    is_asserted_by { CA_UINT8([ [ 255, 255, 255, 255 ],
-                            [ 255, 255, 255, 255 ] ]) == a }
-    is_asserted_by { CA_UINT16([ [ 65535, 65535 ],
-                             [ 65535, 65535 ] ]) == b }
-  end
-
-  example "to_a" do
-    #
-    a = CArray.int32(3,3).seq
-    b = a.to_a
-    is_asserted_by { [ [ 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
-    is_asserted_by { [ [ 0, 1, 2 ],
-                   [ 3, UNDEF, 5 ],
-                   [ 6, 7, 8 ] ] == b }
-  end
-
-
-end