carray 1.5.1 → 1.5.2

data/lib/carray/construct.rb

@@ -58,10 +58,23 @@ class CArray
   def span! (range)
     first = range.begin.to_r
     last  = range.end.to_r
-    if range.exclude_end?
-      seq!(first, (last-first)/elements)
+    if integer?
+      if range.exclude_end?
+        step = ((last-1)-first+1)/elements
+      else
+        step = (last-first+1)/elements
+      end      
+    else
+      if range.exclude_end?
+        step = (last-first)/elements
+      else
+        step = (last-first)/(elements-1)
+      end
+    end
+    if integer? && step.denominator != 1
+      self[] = (first + seq * step).floor
     else
-      seq!(first, (last-first)/(elements-1))
+      seq!(first, step)
     end
     return self
   end
@@ -397,7 +410,11 @@ class CArray
   
     def linspace (x1, x2, n = 100)
       data_type = self::DataType
-      data_type ||= guess_data_type_from_values(x1, x2)
+      unless data_type
+        guess = guess_data_type_from_values(x1, x2)
+        guess = CA_FLOAT64 if guess == CA_INT64
+        data_type = guess
+      end
       CArray.new(data_type, [n]).span(x1..x2)
     end
   

data/lib/carray/iterator.rb

@@ -280,6 +280,7 @@ class CAIterator
   end
 
   def sort_with (&block)
+    warn "CAIterator#sort_with will be obsolete"
     out = reference.template
     idx = CA.sort_addr(*yield(self))
     ca[idx].each_with_addr do |blk, i|

data/lib/carray/ordering.rb

@@ -13,7 +13,6 @@
 class CArray
   
   # reversed
-
   def reversed
     return self[*([-1..0]*ndim)]
   end
@@ -42,7 +41,6 @@ class CArray
   def roll (*argv)
     return self.rolled(*argv).to_ca
   end
-
     
   # Returns the reference which elements are sorted by the comparison method
   # given as block
@@ -61,6 +59,16 @@ class CArray
     cmpary = convert(type, :bytes=>bytes, &block)
     return self[cmpary.sort_addr].to_ca
   end
+  
+  def sorted_with (*others)
+    addr = sort_addr
+    ([self] + others).map { |x| x[addr] }
+  end
+
+  def sort_with (*others)
+    addr = sort_addr
+    ([self] + others).map { |x| x[addr].to_ca }
+  end
 
   def max_by (&block)
     if empty?
@@ -71,6 +79,15 @@ class CArray
     end
   end
 
+  def max_with (*others)
+    if empty?
+      return ([self] + others).map { |x| UNDEF }
+    else
+      addr = max_addr
+      return ([self] + others).map { |x| x[addr] }
+    end
+  end
+
   def min_by (&block)
     if empty?
       return UNDEF
@@ -80,6 +97,15 @@ class CArray
     end
   end
 
+  def min_with (*others)
+    if empty?
+      return ([self] + others).map { |x| UNDEF }
+    else
+      addr = min_addr
+      return ([self] + others).map { |x| x[addr] }
+    end
+  end
+
   def range 
     return (self.min)..(self.max)
   end

data/spec/Classes/CABitfield_spec.rb

@@ -0,0 +1,58 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCArrayCABitfield " do
+
+  example "virtual_array" do
+    a = CArray.int(3,3) { 1 }
+    b = a.bitfield(0)
+    r = b.parent
+    is_asserted_by { b.class == CABitfield }
+    is_asserted_by { true == b.virtual? }
+    is_asserted_by { a == r }
+  end
+
+  example "basic_features" do
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(0)
+    b[] = 1
+    is_asserted_by { a.template { 1 } == a }
+    is_asserted_by { b.template { 1 } == b }
+    b[] = 0
+    is_asserted_by { a.template { 0 } == a }
+    is_asserted_by { b.template { 0 } == b }
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(0..1)
+    b[] = 3
+    is_asserted_by { a.template { 3 } == a }
+    is_asserted_by { b.template { 3 } == b }
+    
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(5..6)
+    b[] = 3
+    is_asserted_by { a.template { 3 << 5 } == a }
+    is_asserted_by { b.template { 3 } == b }
+    
+    # ---
+    a = CArray.int(3,3)
+    b = a.bitfield(27..28)
+    b[] = 3
+    is_asserted_by { a.template { 3 << 27 } == a }
+    is_asserted_by { b.template { 3 } == b }
+  end
+  
+  example "out_of_index" do
+    # ---
+    a = CArray.int8(3)
+    expect { a.bitfield(-1..0) }.to raise_error(IndexError)
+    expect { a.bitfield(0..16) }.to raise_error(IndexError)
+    expect { a.bitfield([nil,2]) }.to raise_error(IndexError)
+    expect { a.bitfield([nil,1]) }.not_to raise_error()
+  end
+
+  
+end

data/spec/Classes/CABlockIterator_spec.rb

@@ -0,0 +1,114 @@
+require "carray"
+require "rspec-power_assert"
+
+describe CABlockIterator do
+
+  describe "each method" do
+
+    before do
+      @original = CArray.object(4,4).seq!
+      @it = @original.blocks(0..1, 0..1)
+    end
+
+    example "should call 4-times its block" do
+      count = 0
+      @it.each do |blk|
+        count += 1
+      end
+      is_asserted_by { count == 4 }
+    end
+
+    example "should have the block parameter of 2x2 CABlock object" do
+      @it.each do |blk|
+        is_asserted_by { blk.class == CABlock }
+        is_asserted_by { blk.data_type == CA_OBJECT }
+        is_asserted_by { blk.dim == [2,2] }
+      end
+    end
+
+  end
+
+  describe "reference method []" do
+
+    before do
+      @original = CArray.object(4,4).seq!
+      @it = @original.blocks(0..1, 0..1)
+    end
+
+    example "should return a 2x2 CABlock object" do
+      blk = @it[0]
+      is_asserted_by { blk.class == CABlock }
+      is_asserted_by { blk.data_type == CA_OBJECT }
+      is_asserted_by { blk == CA_OBJECT([[0,1],[4,5]]) }
+      blk = @it[1,0]
+      is_asserted_by { blk.class == CABlock }
+      is_asserted_by { blk.data_type == CA_OBJECT }
+      is_asserted_by { blk == CA_OBJECT([[8,9],[12,13]]) }
+    end
+
+    example "should return a 2x2 CABlock object" do
+      is_asserted_by { @it[0] == @it.kernel_at_addr(0, @it.reference) }
+      is_asserted_by { @it[1,0] == @it.kernel_at_index([1,0], @it.reference) }
+    end
+
+  end
+
+  describe "store method []=" do
+
+    before do
+      @original = CArray.object(4,4).seq!
+      @it = @original.blocks(0..1, 0..1)
+    end
+
+    example "should return a 2x2 CABlock object" do
+      @it[0] = 1
+      @it[1,0] = 2
+      is_asserted_by { @it.reference == CA_OBJECT( [ [ 1, 1, 2, 3 ],
+                                               [ 1, 1, 6, 7 ],
+                                               [ 2, 2, 10, 11 ],
+                                               [ 2, 2, 14, 15 ] ] ) }
+    end
+
+  end
+
+  describe "pick method" do
+
+    before do
+      @original = CArray.object(4,4).seq!
+      @it = @original.blocks(0..1, 0..1)
+    end
+
+    example "should return a 2x2 CABlock object" do
+      blk = @it.pick(0)
+      is_asserted_by { blk.class == CArray }
+      is_asserted_by { blk.data_type == CA_OBJECT }
+      is_asserted_by { blk == CA_OBJECT([[0,2],[8,10]]) }
+      blk = @it.pick(1,0)
+      is_asserted_by { blk.class == CArray }
+      is_asserted_by { blk.data_type == CA_OBJECT }
+      is_asserted_by { blk == CA_OBJECT([[4,6],[12,14]]) }
+    end
+
+  end
+
+  describe "put method" do
+
+    before do
+      @original = CArray.object(4,4).seq!
+      @it = @original.blocks(0..1, 0..1)
+    end
+
+    example "should store value via 2x2 CBlock object" do
+      @it.put(0,1)
+      @it.put(0,1,2)
+      is_asserted_by { @it.pick(0) == CA_OBJECT([[1,1],[1,1]]) }
+      is_asserted_by { @it.pick(0,1) == CA_OBJECT([[2,2],[2,2]]) }
+      is_asserted_by { @it.reference == CA_OBJECT([[ 1, 2, 1, 2 ],
+                                             [ 4, 5, 6, 7 ],
+                                             [ 1, 2, 1, 2 ],
+                                             [ 12, 13, 14, 15 ]]) }
+    end
+
+  end
+
+end

data/spec/Classes/CABlock_spec.rb

@@ -0,0 +1,205 @@
+
+require 'carray'
+require "rspec-power_assert"
+
+describe "TestCABlock " do
+
+  example "virtual_array" do
+    a = CArray.int(3,3)
+    b = a[0..1,0..1]
+    r = b.parent
+    t = b.root_array
+    is_asserted_by { b.class == CABlock }
+    is_asserted_by { r.class == CArray }
+    is_asserted_by { a == r }
+    is_asserted_by { a == t }
+  end
+
+  example "block" do
+    a = CArray.int32(3, 3) { 1 }
+    b = CArray.int32(3) { 1 }
+
+    is_asserted_by { a[nil, 1] == b }
+    is_asserted_by { a[1, nil] == b }
+
+    a[nil, 1].seq!
+    b.seq!
+    is_asserted_by { a[nil, 1] == b }
+
+    a[1, nil].seq!
+    b.seq!
+    is_asserted_by { a[1, nil] == b }
+  end
+
+  example "CABlock" do
+    a = CArray.int32(4, 4)
+
+    a.seq!
+    b = a[1..2, 1..2]
+
+    is_asserted_by { b.class == CABlock }
+    is_asserted_by { b.rank == a.rank }
+    is_asserted_by { b.dim == [2, 2] }
+    is_asserted_by { b.elements == 4 }
+
+    c = CArray.int32(2, 2){ [[5,6],[9,10]] }
+    is_asserted_by { b == c }
+
+    d = a.clone
+    d[1..2, 1..2] = 1
+    b[] = 1
+    is_asserted_by { a == d }
+
+    a.seq!
+    is_asserted_by { b == c }
+  end
+
+
+  example "s_new" do
+    a = CArray.int32(4, 4) { 1 }
+    b = a[0..2, 0..2]
+    is_asserted_by { b.data_type == CA_INT32 }
+    is_asserted_by { b.rank == 2 }
+    is_asserted_by { b.bytes == CArray.sizeof(CA_INT32) }
+    is_asserted_by { b.size0 == [4, 4] }
+    is_asserted_by { b.dim == [3, 3] }
+    is_asserted_by { b.start == [0, 0] }
+    is_asserted_by { b.step == [1, 1] }
+    is_asserted_by { b.count == [3, 3] }
+    is_asserted_by { b.elements == 9 }
+    is_asserted_by { b == CArray.int32(3, 3) { 1 } }
+  end
+
+  example "block_of_block" do
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    c = b[0..1, 0..1]
+
+    is_asserted_by { b == CArray.int32(3, 3) {
+       [
+         [0, 1, 2],
+         [4, 5, 6],
+         [8, 9, 10],
+       ]
+       } }
+
+    is_asserted_by { c == CArray.int32(2, 2) {
+       [
+         [0, 1],
+         [4, 5],
+       ]
+       } }
+  end
+
+  example "block_of_block_set_value" do
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    c = b[0..1, 0..1]
+
+    a[0..1, 0..1] = 1
+
+    is_asserted_by { b == CArray.int32(3, 3) {
+       [
+         [1, 1, 2],
+         [1, 1, 6],
+         [8, 9, 10],
+       ]
+       } }
+
+    is_asserted_by { c == CArray.int32(2, 2) {
+       [
+         [1, 1],
+         [1, 1],
+       ]
+       } }
+
+    c[] = 2
+
+    is_asserted_by { b == CArray.int32(3, 3) {
+       [
+         [2, 2, 2],
+         [2, 2, 6],
+         [8, 9, 10],
+       ]
+       } }
+
+    is_asserted_by { a[0..1, 0..1] == CArray.int32(2, 2) {
+       [
+         [2, 2],
+         [2, 2],
+       ]
+       } }
+  end
+
+  example "block_of_block_downrank" do
+    a = CArray.new(CA_INT32, [4, 4, 4]) { 0 }
+    b = a[0..2, 0..2, 1]
+    c = b[0..1, 1]
+
+    b.seq!
+
+    is_asserted_by { b == a[0..2, 0..2, 1] }
+    is_asserted_by { c == CArray.int32(2) { [1, 4] } }
+
+    c[] = 1
+
+    is_asserted_by { a[0..1, 1, 1] == CArray.int(2) { 1 } }
+  end
+
+  example "block_of_block_ref_address" do
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    c = b[1..0, 0..1]
+
+    is_asserted_by { c[2] == 0 }
+    is_asserted_by { c[[2]] == CArray.int32(1) { [0] } }
+    is_asserted_by { c[nil] == CArray.int32(4) { [4, 5, 0, 1] } }
+    is_asserted_by { c[1..2] == CArray.int32(2) { [5, 0] } }
+    is_asserted_by { c[[nil, 2]] == CArray.int32(2) { [4, 0] } }
+    is_asserted_by { c[[(1..-1), 2]] == CArray.int32(2) { [5, 1] } }
+
+    c[nil] = 1
+    is_asserted_by { a[0..1, 0..1] == CArray.int32(2, 2) { 1 } }
+  end
+
+  example "refer_of_block" do
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[nil, 0..2]
+    c = b.reshape(2, 6)
+#    is_asserted_by { b.to_a.flatten, c.to_a.flatten)
+
+    c[0, 0] = 3
+    is_asserted_by { b[0, 0] == 3 }
+    is_asserted_by { a[0, 0] == 3 }
+  end
+
+  example "refer_of_block_cast" do
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[nil, 0..2]
+    c = b.reshape(2, 6)
+    is_asserted_by { c.float32[0, 1] == 1.0 }
+    is_asserted_by { c.float64[0, 1] == 1.0 }
+  end
+
+  example "block_of_block_self_asign" do
+    a = CArray.new(CA_INT32, [4, 4]).seq!
+    b = a[0..2, 0..2]
+    b[0..1, 0..1] = a[0..1, 0..1]
+  end
+
+  example "block_move" do
+    a = CArray.int(10, 10).seq!
+    b = a[0..2, 0..2]
+
+    is_asserted_by { b == CArray.int(3, 3) { [[0, 1, 2], [10, 11, 12], [20, 21, 22]] } }
+
+    b.move(1,1)
+    is_asserted_by { b == CArray.int(3, 3) { [[11, 12, 13], [21, 22, 23], [31, 32, 33]] } }
+
+    b.move(7,7)
+    is_asserted_by { b == CArray.int(3, 3) { [[77, 78, 79], [87, 88, 89], [97, 98, 99]] } }
+
+    expect { b.move(8,8) }.to raise_error(ArgumentError) 
+  end
+  
+end