carray 1.5.1 → 1.5.2

data/spec/Features/feature_virtual_spec.rb

@@ -0,0 +1,48 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayVirtual " do
+
+  example "clone" do
+    a = CArray.int(3,3)
+    a[1,1] = UNDEF
+    b = a[1..2,1..2]
+    is_asserted_by {  b == b.clone }
+    is_asserted_by {  b == b.clone.to_ca }
+    is_asserted_by {  b.mask == b.clone.mask }
+    is_asserted_by {  b.object_id != b.clone.object_id }
+    is_asserted_by {  b.mask.object_id != b.clone.mask.object_id }
+  end
+
+  example "attached?" do
+    a = CArray.int(10,10)
+    r = a[]
+    is_asserted_by {  false == r.attached? }
+    r.attach{
+      is_asserted_by {  true == r.attached? }
+    }
+    is_asserted_by {  false == r.attached? }
+    r.attach!{
+      is_asserted_by {  true == r.attached? }
+    }
+  end
+
+  example "root_array" do
+    a = CArray.int(10,10).seq
+    b = a[]
+    c = b[0..5,nil]
+    d = c[c > 50]
+    e = d[d.address]
+    is_asserted_by {  a.object_id == b.root_array.object_id }
+    is_asserted_by {  a.object_id == c.root_array.object_id }
+    is_asserted_by {  a.object_id == d.root_array.object_id }
+    is_asserted_by {  a.object_id == e.root_array.object_id }
+    is_asserted_by { [a.object_id,
+                  b.object_id,
+                  c.object_id,
+                  d.object_id,
+                  e.object_id] == e.ancestors.map{|x| x.object_id} }
+  end
+
+end

data/spec/Features/method_eq_spec.rb

@@ -0,0 +1,81 @@
+
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#eq" do
+
+  example "returns 1 if self and other equal (int)" do
+    ca123 = CA_INT([123])
+
+    is_asserted_by { (ca123).eq(123  )[0] == 1 }
+    is_asserted_by { (ca123).eq(ca123)[0] == 1 }
+  end
+
+  example "returns 1 if self and other equal (object)" do
+    ca123 = CA_OBJECT(["123"])
+
+    is_asserted_by { (ca123).eq("123")[0] == 1 }
+    is_asserted_by { (ca123).eq(ca123)[0] == 1 }
+  end
+
+  example "returns 1 if self and other equal (fixlen)" do
+    ca123 = CA_FIXLEN(["123"], :bytes=>3)
+
+    is_asserted_by { (ca123).eq("123")[0] == 1 }
+    is_asserted_by { (ca123).eq(ca123)[0] == 1 }
+  end
+
+  example "returns 0 if self and other equal (int)" do
+    ca123 = CA_INT([123])
+    ca124 = CA_INT([124])
+
+    is_asserted_by { (ca123).eq(124  )[0] == 0 }
+    is_asserted_by { (ca123).eq(ca124)[0] == 0 }
+  end
+
+  example "returns 0 if self and other equal (object)" do
+    ca123 = CA_OBJECT(["123"])
+    ca124 = CA_OBJECT(["124"])
+
+    is_asserted_by { (ca123).eq("124")[0] == 0 }
+    is_asserted_by { (ca123).eq(ca124)[0] == 0 }
+  end
+
+  example "returns 0 if self and other equal (fixlen)" do
+    ca123 = CA_FIXLEN(["123"], :bytes=>3)
+    ca124 = CA_FIXLEN(["124"], :bytes=>3)
+    ca12  = CA_FIXLEN(["12"], :bytes=>3)
+
+    is_asserted_by { (ca123).eq("124")[0] == 0 }
+    is_asserted_by { (ca123).eq(ca124)[0] == 0 }
+
+    is_asserted_by { (ca123).eq("12")[0] == 0 }
+    is_asserted_by { (ca123).eq(ca12)[0] == 0 }
+  end
+
+  example "returns 0 if self is a NaN" do
+    nan = 0.0/0.0 
+
+    is_asserted_by { (nan             ).eq(CA_DOUBLE([0.0]))[0] == 0 }
+    is_asserted_by { (CA_DOUBLE([nan])).eq(0.0             )[0] == 0 }
+    is_asserted_by { (CA_DOUBLE([nan])).eq(CA_DOUBLE([0.0]))[0] == 0 }
+  end
+
+  example "returns 0 if self and other are NaN" do
+    nan = 0.0/0.0 
+
+    is_asserted_by { (nan             ).eq(CA_DOUBLE([nan]))[0] == 0 }
+    is_asserted_by { (CA_DOUBLE([nan])).eq(nan             )[0] == 0 }
+    is_asserted_by { (CA_DOUBLE([nan])).eq(CA_DOUBLE([nan]))[0] == 0 }
+  end
+
+  example "returns 0 if other is a NaN" do
+    nan = 0.0/0.0 
+
+    is_asserted_by { (0.0             ).eq(CA_DOUBLE([nan]))[0] == 0 }
+    is_asserted_by { (CA_DOUBLE([0.0])).eq(nan             )[0] == 0 }
+    is_asserted_by { (CA_DOUBLE([0.0])).eq(CA_DOUBLE([nan]))[0] == 0 }
+  end
+
+end
+

data/spec/Features/method_is_nan_spec.rb

@@ -0,0 +1,12 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#is_nan" do
+  example "returns 1 if self is not a valid IEEE floating-point number" do
+    is_asserted_by { CA_DOUBLE(0.0).is_nan[0] == 0 }
+    is_asserted_by { CA_DOUBLE(-1.5).is_nan[0] == 0 }
+    is_asserted_by { (CA_DOUBLE(0.0)/CA_DOUBLE(0.0)).is_nan[0] == 1 }
+    is_asserted_by { CA_DOUBLE(0.0/0.0).is_nan[0] == 1 }
+  end
+end
+

data/spec/Features/method_map_spec.rb

@@ -0,0 +1,54 @@
+require 'carray'
+require "rspec-power_assert"
+
+describe "CArray#map" do
+
+  # 2020-07-22
+  example "same shape" do
+    #
+    a = CArray.int32(3,3).seq
+    b = a.map{|x| x.to_s }
+    is_asserted_by { b.class == Array }
+    is_asserted_by { b.size  == 3 }
+    is_asserted_by { b[0].size  == 3 }
+    is_asserted_by { b == [ [ "0", "1", "2" ],
+                            [ "3", "4", "5" ],
+                            [ "6", "7", "8" ] ] }
+
+    # mask does not be templated
+    a = CArray.int32(3,3).seq
+    a[1,1] = UNDEF
+    b = a.map{|x| x.to_s }
+    is_asserted_by { b == [ [ "0", "1", "2" ],
+                            [ "3", UNDEF, "5" ],
+                            [ "6", "7", "8" ] ] }
+  end
+
+  # 2020-07-22
+  example "flatten list" do
+    a = CArray.int32(3,3).seq
+    b = a[nil].map{|x| x.to_s }
+    is_asserted_by { b == [ "0", "1", "2", "3", "4", "5", "6", "7", "8"] }
+  end
+
+  example "string generation" do
+    # ---
+    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
+    is_asserted_by { ["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
+    is_asserted_by { [["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"]] == b }
+  end
+
+end

data/spec/Features/method_max_with.rb

@@ -0,0 +1,20 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#max_with" do
+  
+  # 2020-07-09
+  example "basic" do
+   
+    a = CA_INT([3,2,4,1])
+    b = CA_INT([13,12,14,11])
+    c = CA_INT([23,22,24,21])
+    
+    list = a.max_with(b,c)
+    
+    is_asserted_by { list == [4,14,24] }
+    
+  end
+  
+end
+

data/spec/Features/method_min_with.rb

@@ -0,0 +1,19 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#min_with" do
+  
+  # 2020-07-09
+  example "basic" do
+   
+    a = CA_INT([3,2,4,1])
+    b = CA_INT([13,12,14,11])
+    c = CA_INT([23,22,24,21])
+    
+    list = a.min_with(b,c)
+    
+    is_asserted_by { list == [1,11,21] }
+    
+  end
+  
+end

data/spec/Features/method_ne_spec.rb

@@ -0,0 +1,18 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#ne" do
+  it "returns 0 if self is not a valid IEEE floating-point number" do
+    nan = 0.0/0.0
+    is_asserted_by { 0.0.ne(CA_DOUBLE(nan))[0] == 1 }
+    is_asserted_by { nan.ne(CA_DOUBLE(nan))[0] == 1 }
+    is_asserted_by { nan.ne(CA_DOUBLE(0.0))[0] == 1 }
+    is_asserted_by { CA_DOUBLE(nan).ne(0.0)[0] == 1 }
+    is_asserted_by { CA_DOUBLE(nan).ne(nan)[0] == 1 }
+    is_asserted_by { CA_DOUBLE(0.0).ne(nan)[0] == 1 }
+    is_asserted_by { CA_DOUBLE(nan).ne(CA_DOUBLE(0.0))[0] == 1 }
+    is_asserted_by { CA_DOUBLE(nan).ne(CA_DOUBLE(nan))[0] == 1 }
+    is_asserted_by { CA_DOUBLE(0.0).ne(CA_DOUBLE(nan))[0] == 1 }
+  end
+end
+    

data/spec/Features/method_project_spec.rb

@@ -0,0 +1,188 @@
+require "carray"
+require 'rspec-power_assert'
+
+describe "CArray#project" do
+
+  example "basic" do
+    a = CA_DOUBLE([[11,22,33],
+                   [44,55,66],
+                   [77,88,99]])
+
+    # CA_SIZE
+    idxsz = CA_SIZE([[1,2,3],
+                     [4,5,6],
+                     [7,8,0]])
+
+                     
+    is_asserted_by { a.project(idxsz).class == CArray }          ### entity array
+    is_asserted_by { a.project(idxsz).data_type == a.data_type } ### data_type is inherited from base array
+    is_asserted_by { a.project(idxsz).shape == idxsz.shape }     ### shape is inherieted from index array
+
+    is_asserted_by { 
+      a.project(idxsz) == CA_DOUBLE([[22,33,44],
+                                     [55,66,77],
+                                     [88,99,11]])
+    }
+
+  end
+
+  example "permits integer array for index arugument" do
+
+    a = CA_DOUBLE([[11,22,33],
+                   [44,55,66],
+                   [77,88,99]])
+
+
+    is_asserted_by { 
+      # CA_INT8
+      idx8 = CA_INT8([[1,2,3],
+                      [4,5,6],
+                      [7,8,0]])
+
+      a.project(idx8) == CA_DOUBLE([[22,33,44],
+                                    [55,66,77],
+                                    [88,99,11]])
+    }
+
+    is_asserted_by { 
+      # CA_INT32
+      idx32 = CA_INT32([[1,2,3],
+                        [4,5,6],
+                        [7,8,0]])
+
+      a.project(idx32) == CA_DOUBLE([[22,33,44],
+                                     [55,66,77],
+                                     [88,99,11]])
+    }
+
+    is_asserted_by { 
+      # CA_INT64
+      idx64 = CA_INT64([[1,2,3],
+                        [4,5,6],
+                        [7,8,0]])
+
+      a.project(idx64) == CA_DOUBLE([[22,33,44],
+                                     [55,66,77],
+                                     [88,99,11]])
+    }
+    
+  end
+
+  example "returns array which has the shape of index argument" do
+    # 3x4
+    a = CA_DOUBLE([[0, 1, 2, 3],
+                   [4, 5, 6, 7],
+                                               [8, 9, 10,11]]) + 100
+
+    is_asserted_by { 
+      # 1x12
+      idx = CA_INT64([0,1,2,3,4,5,6,7,8,9,10,11])
+
+      a.project(idx).shape == idx.shape
+    }
+
+    is_asserted_by { 
+      # 2x6
+      idx = CA_INT64([[0,1,2,3,4,5],
+                      [6,7,8,9,10,11]])
+
+      a.project(idx).shape == idx.shape
+    }
+
+    is_asserted_by { 
+      # 4x3
+      idx = CA_INT64([[0,1,2],
+                      [3,4,5],
+                      [6,7,8],
+                      [9,10,11]])
+
+      a.project(idx).shape == idx.shape
+    }
+
+    is_asserted_by { 
+      # 2x3
+      idx = CA_INT64([[0,1,2],
+                      [3,4,5]])
+
+      a.project(idx).shape == idx.shape
+    }
+
+  end
+  
+  example "masked array" do
+
+    # masked base array
+
+    _ = UNDEF
+
+    a = CA_DOUBLE([[11,_ ,33],
+                   [44,55,66],
+                   [77,88,99]])
+
+    is_asserted_by { 
+      # idx without mask
+      idx = CA_INT64([[1,2,3],
+                      [4,5,6],
+                      [7,8,0]])
+
+      a.project(idx) == CA_DOUBLE([[_ ,33,44],
+                                   [55,66,77],
+                                   [88,99,11]])
+    }
+
+    is_asserted_by { 
+      # index with mask
+      idx = CA_SIZE([[1,2,3],
+                     [4,_,6],
+                     [7,8,0]])
+
+      a.project(idx) == CA_DOUBLE([[_ ,33,44],
+                                   [55,_ ,77],
+                                   [88,99,11]])
+    }
+
+    # Related: Comparing the behavior of CArray#[idx] with idx has mask
+    #
+
+    is_asserted_by { 
+      # For CArray#[idx], nothing is raised even if base array has masked element.
+
+      # idx without mask
+      idx = CA_SIZE([[1,2,3],
+                     [4,5,6],
+                     [7,8,0]])
+
+
+      a[idx] == CA_DOUBLE([[_ ,33,44],
+                           [55,66,77],
+                           [88,99,11]])
+    }
+
+    # For CArray#[idx], ArgumentError is raised if idx has masked element.
+    expect { 
+      # idx with mask
+      idx = CA_SIZE([[1,2,3],
+                     [4,_,6],
+                     [7,8,0]])
+      a[idx] 
+    }.to raise_error(ArgumentError)
+
+  end
+
+  example "edge cases" do
+    _ = UNDEF
+    a = CA_DOUBLE([[11,22,33],
+                   [44,55,66],
+                   [77,88,99]])
+    is_asserted_by { a.project(CA_SIZE([])) == CA_DOUBLE([]) }
+    is_asserted_by { a.project(CA_SIZE([9])) == CA_DOUBLE([_]) }
+    is_asserted_by { a.project(CA_SIZE([-1])) == CA_DOUBLE([_]) }
+    is_asserted_by { a.project(CA_SIZE([-1]), 999) == CA_DOUBLE([999]) }
+    is_asserted_by { a.project(CA_SIZE([9]), 999) == CA_DOUBLE([999]) }
+    is_asserted_by { a.project(CA_SIZE([-1]), -999) == CA_DOUBLE([-999]) }
+    is_asserted_by { a.project(CA_SIZE([9]), -999, 999) == CA_DOUBLE([999]) }
+    
+  end
+  
+
+end