carray 1.4.0 → 1.5.5

data/lib/carray/autoload/autoload_gem_random.rb

@@ -0,0 +1,8 @@
+class CArray
+  class << self
+    autoload_method :srand, "carray-random"
+  end
+  autoload_method :random!, "carray-random"
+  autoload_method :shuffle, "carray-random"
+  autoload_method :shuffle!, "carray-random"
+end

data/lib/carray/basic.rb

@@ -0,0 +1,191 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/basic.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+module CAMath
+  include Math
+end
+
+#
+# monkey patch
+#
+
+def nan
+  0.0/0.0
+end
+
+class Array                          # :nodoc:
+  def +@
+    return CA_SIZE(self)
+  end
+  def to_ca
+    return CA_OBJECT(self)
+  end
+end
+
+class Range                          # :nodoc: 
+  def +@
+    return CA_SIZE(self)    
+  end
+  def to_ca
+    return CA_OBJECT(self)
+  end
+end
+
+class Numeric
+  
+  def eq (other)
+    case other
+    when CArray
+      return other.eq(self)
+    else
+      return send(:eq, *other.coerce(self))
+    end
+  end
+
+  def ne (other)
+    case other
+    when CArray
+      return other.ne(self)
+    else
+      return send(:ne, *other.coerce(self))
+    end
+  end
+  
+end
+
+class CArray
+
+  def has_attribute?
+    if ( not @attribute ) or @attribute.empty?
+      return false
+    else
+      return true
+    end
+  end
+
+  def attribute= (obj)
+    unless obj.is_a?(Hash)
+      raise "attribute should be a hash object"
+    end
+    @attribute = obj
+  end
+
+  def attribute
+    @attribute ||= {}
+    return @attribute
+  end
+  
+  def first
+    self[0]
+  end
+  
+  def last
+    self[-1]
+  end
+
+  # matchup
+
+  def matchup (ref)
+    ri = ref.sort_addr
+    rs = ref[ri].to_ca
+    si = rs.bsearch(self)
+    return ri.project(si)
+  end
+
+  def matchup_nearest (ref, direction: "round")
+    ri = ref.sort_addr
+    rs = ref[ri].to_ca
+    si = rs.section(self).send(direction.intern).int64
+    si.trim!(0,si.size)
+    return ri[si].to_ca
+  end
+
+
+  # index / indices / axes
+
+  def address ()
+    return CArray.int32(*dim).seq!
+  end
+
+  def index (n = 0)
+    unless n.is_a?(Integer)
+      raise ArgumentError, "argument should be an integer"
+    end
+    if n.between?(0, ndim-1)
+      return CArray.int32(dim[n]).seq!
+    else
+      raise ArgumentError,
+            "invalid dimension specifier #{n} (0..#{self.ndim-1})"
+    end
+  end
+
+  #
+  #
+  #
+
+  def indices
+    list = Array.new(ndim) {|i|
+      rpt = self.dim
+      rpt[i] = :%
+      index(i)[*rpt]
+    }
+    if block_given?
+      return yield(*list)
+    else
+      return list
+    end
+  end
+
+    
+
+end
+
+class CArray
+
+  # Returns object carray has elements of splitted carray at dimensions 
+  #      which is given by arguments
+  #
+  #    a = CA_INT([[1,2,3], [4,5,6], [7,8,9]])
+  #
+  #    a.split(0) 
+  #      [1,2,3], [4,5,6], [7,8,9]
+  #
+  #    a.split(1)
+  #      [1,4,7], [2,5,8], [3,6,9]
+  #
+
+  def split (*argv)
+    odim = dim.values_at(*argv)
+    out  = CArray.object(*odim)
+    idx  = [nil] * ndim
+    attach {
+      out.map_with_index! do |o, v|
+        argv.each_with_index do |r, i|
+          idx[r] = v[i]
+        end
+        self[*idx].to_ca
+      end
+    }
+    return out
+  end
+
+end
+
+class CAUnboundRepeat
+
+  def template (*argv, &block)
+    return parent.template(*argv,&block)[*spec.map{|x| x != :* ? nil : x}]
+  end
+
+end
+
+
+
+

data/lib/carray/broadcast.rb

@@ -0,0 +1,101 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/broadcast.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+class CArray
+
+  def broadcast_to (*newdim)
+    
+    if newdim.size < ndim
+      raise "(Broadcasting) can't broadcast to #{newdim.inspect} because too small rank is specified"
+    end
+
+    #
+    # Try to build unbound repeat index (includes :*)
+    #                     with broadcasting rule in Numpy.
+    #
+    repdim = []
+    shape  = []
+
+    srcdim = dim.dup 
+    dstdim = newdim.dup
+    sd = srcdim.pop
+    dd = dstdim.pop
+    while dd
+      if sd == dd
+        repdim.unshift nil
+        shape.unshift(dd)
+        sd = srcdim.pop
+      elsif dd == 1
+        repdim.unshift :*
+      elsif sd == 1 
+        repdim.unshift :*
+        sd = srcdim.pop
+      else
+        raise "(Broadcasting) can't broadcast to #{newdim.inspect} " 
+      end
+      dd = dstdim.pop
+    end
+
+    #
+    # Call Unbound repeat's bind
+    #
+    return self.reshape(*shape)[*repdim].bind(*newdim) if repdim.include?(:*)
+    
+    self
+  end
+
+end
+
+class CScalar
+  
+  def broadcast_to (*newdim)
+    out = CArray.new(data_type, newdim, bytes: bytes)
+    out[] = self
+    out
+  end
+
+end
+
+class CAUnboundRepeat
+
+  alias broadcast_to bind
+
+end
+
+def CArray.broadcast (*argv, expand_scalar: false, &block)
+  
+  sel = argv.select { |arg| arg.is_a?(CArray) }
+  return argv if sel.empty?
+  
+  dim = []
+  ndim = sel.map(&:ndim).max
+  ndim.times do |k|
+    dim[k] = sel.map { |arg| arg.dim[k] || 1 }.max
+  end
+
+  if not expand_scalar
+    list = argv.map { |arg| 
+      case arg
+      when CScalar
+        arg
+      when CArray
+        arg.broadcast_to(*dim)
+      else
+        arg
+      end
+    }
+  else
+    list = argv.map { |arg| arg.is_a?(CArray) ? arg.broadcast_to(*dim) : arg }
+  end
+  
+  return block.call(*list) if block
+  return list
+end
+

data/lib/carray/compose.rb

@@ -0,0 +1,315 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/composition.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#
+#  Copyright (C) 2005-2020 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+class CArray
+  
+  # Returns the array resized to the dimension given as `newdim`.
+  # The new area is filled by the value returned by the block.
+  def resize (*newdim, &block)
+    if newdim.size != ndim
+      raise "ndim mismatch"
+    end
+    offset = Array.new(ndim){0}
+    ndim.times do |i|
+      d = newdim[i]
+      case d
+      when nil
+        newdim[i] = dim[i]
+      when Integer
+        if d < 0
+          newdim[i] *= -1
+          offset[i] = newdim[i] - dim[i]
+        end
+      else
+        raise "invalid dimension size"
+      end
+    end
+    out = CArray.new(data_type, newdim, &block)
+    out.data_class = data_class if has_data_class?
+    if out.has_mask?
+      out.mask.paste(offset, self.false)
+    end
+    out.paste(offset, self)
+    return out
+  end
+
+  # insert
+  def insert_block (offset, bsize, &block)
+    if offset.size != ndim or
+        bsize.size != ndim
+      raise "ndim mismatch"
+    end
+    newdim = dim
+    grids = dim.map{|d| CArray.int32(d) }
+    ndim.times do |i|
+      if offset[i] < 0
+        offset[i] += dim[i]
+      end
+      if offset[i] < 0 or offset[i] >= dim[i] or bsize[i] < 0
+        raise "invalid offset or size"
+      end
+      if bsize[i] > 0
+        newdim[i] += bsize[i]
+      end
+      grids[i][0...offset[i]].seq!
+      grids[i][offset[i]..-1].seq!(offset[i]+bsize[i])
+    end
+    out = CArray.new(data_type, newdim)
+    out.data_class = data_class if has_data_class?
+    if block_given?
+      sel = out.true
+      sel[*grids] = 0
+      out[sel] = block.call
+    end
+    out[*grids] = self
+    return out
+  end
+
+  def delete_block (offset, bsize)
+    if offset.size != ndim or
+      bsize.size != ndim
+      raise "ndim mismatch"
+    end
+    newdim = dim
+    grids  = []
+    ndim.times do |i|
+      if offset[i] < 0
+        offset[i] += dim[i]
+      end
+      if bsize[i] >= 0
+        if offset[i] < 0 or offset[i] >= dim[i]
+          raise "invalid offset or size"
+        end
+        newdim[i] -= bsize[i]
+      else
+        if offset[i] + bsize[i] + 1 < 0 or offset[i] + bsize[i] > dim[i]
+          raise "invalid offset or size"
+        end
+        newdim[i] += bsize[i]
+      end
+      grids[i] = CArray.int32(newdim[i])
+      if bsize[i] >= 0
+        if offset[i] > 0
+          grids[i][0...offset[i]].seq!
+        end
+        if offset[i] + bsize[i] < dim[i]
+          grids[i][offset[i]..-1].seq!(offset[i]+bsize[i])
+        end
+      else
+        if offset[i]+bsize[i] > 0
+          grids[i][0..offset[i]+bsize[i]].seq!
+        end
+        if offset[i]+bsize[i]+1 < dim[i]-1
+          grids[i][offset[i]+bsize[i]+1..-1].seq!(offset[i]+1)
+        end
+      end
+    end
+    return self[*grids].to_ca
+  end
+  
+  def self.combine (data_type, tdim, list, at = 0, bytes: nil)
+    if CArray.data_class?(data_type)
+      data_class = data_type
+      data_type  = :fixlen
+      bytes = data_class::DATA_SIZE
+    else
+      data_class = nil
+    end
+    has_fill_value = false
+    if block_given?
+      fill_value = yield
+      has_fill_value = true
+    end
+    if not tdim.is_a?(Array) or tdim.size == 0
+      raise "invalid binding dimension"
+    end
+    if not list.is_a?(Array) or list.size == 0
+      raise "invalid list"
+    end
+    list = list.map{|x| CArray.wrap_readonly(x, data_type) }
+    ref  = list.detect{|x| x.is_a?(CArray) or not x.scalar? }
+    unless ref
+      raise "at least one element in list should be a carray"
+    end
+    dim   = ref.dim
+    ndim  = ref.ndim
+    tndim = tdim.size
+    if at < 0
+      at += ndim - tndim + 1
+    end
+    unless at.between?(0, ndim - tndim)
+      raise "concatnating position out of range"
+    end
+    list.map! do |x|
+      if x.scalar?
+        rdim = dim.clone
+        rdim[at] = :%
+        x = x[*rdim]        # convert CScalar to CARepeat
+      end
+      x
+    end
+    block = CArray.object(*tdim){ list }
+    edim = tdim.clone
+    idx = Array.new(tdim)
+    offset = Array.new(tdim.size) { [] }
+    tdim.each_with_index do |td, i|
+      edim[i] = 0
+      idx.map!{0}
+      idx[i] = nil
+      block[*idx].each do |e|
+        offset[i] << edim[i]
+        edim[i] += e.dim[at+i]  # extended dimension size
+      end
+    end
+    newdim = dim.clone
+    newdim[at,tndim] = edim     # extended dimension size
+    if has_fill_value
+      obj = CArray.new(data_type, newdim) { fill_value }
+    else      
+      obj = CArray.new(data_type, newdim)
+    end
+    out.data_class = data_class if data_class
+    idx = newdim.map{0}
+    block.each_with_index do |item, tidx|
+      (at...at+tndim).each_with_index do |d,i|
+        idx[d] = offset[i][tidx[i]]
+      end
+      obj.paste(idx, item)
+    end
+    obj
+  end
+
+  def self.bind (data_type, list, at = 0, bytes: nil)
+    return CArray.combine(data_type, [list.size], list, at, bytes: bytes)
+  end
+
+  def self.composite (data_type, tdim, list, at = 0, bytes: nil)
+    if CArray.data_class?(data_type)
+      data_class = data_type
+      data_type  = :fixlen
+      bytes = data_class::DATA_SIZE
+    else
+      data_class = nil
+    end
+    if not tdim.is_a?(Array) or tdim.size == 0
+      raise "invalid tiling dimension"
+    end
+    if not list.is_a?(Array) or list.size == 0
+      raise "invalid carray list"
+    end
+    list = list.map{|x| CArray.wrap_readonly(x, data_type) }
+    ref  = list.detect{|x| x.is_a?(CArray) or not x.scalar? }
+    unless ref
+      raise "at least one element in list should be a carray"
+    end
+    dim   = ref.dim
+    ndim  = ref.ndim
+    if at < 0
+      at += ndim + 1 #  "+ 1" is needed here
+    end
+    unless at.between?(0,ndim)
+      raise "tiling position is out of range"
+    end
+    tndim = tdim.size
+    list.map! do |x|
+      if x.scalar?
+        rdim = dim.clone
+        rdim[at] = :%
+        x = x[*rdim]     # convert CScalar to CARepeat
+      end
+      x
+    end
+    newdim = dim.clone
+    newdim[at,0] = tdim
+    obj = CArray.new(data_type, newdim, bytes: bytes)
+    out.data_class = data_class if data_class
+    idx = Array.new(ndim+tndim) { nil }
+    CArray.each_index(*tdim) do |*tidx|
+      idx[at,tndim] = tidx
+      obj[*idx] = list.shift
+    end
+    obj
+  end
+
+  def self.merge (data_type, list, at = -1, bytes: nil)
+    return CArray.composite(data_type, [list.size], list, at, bytes: bytes)
+  end
+  
+  def self.join (*argv)
+    # get options
+    case argv.first
+    when Class
+      if CArray.data_class?(argv.first)
+        data_class = argv.shift
+        data_type = "fixlen"
+        bytes = data_class::DATA_SIZE
+      else
+        raise "#{argv.first} can not to be a data_class for CArray"
+      end
+    when Integer, Symbol, String
+      type, = *CArray.guess_type_and_bytes(argv.shift, 0)
+    else
+      type = argv.flatten.first.data_type
+    end
+    # process
+    conc = argv.map do |list|
+      case list
+      when CArray
+        if list.ndim == 1
+          list[:%,1]
+        else
+          list
+        end
+      when Array
+        x0 = list.first
+        if list.size == 1 and
+            x0.is_a?(CArray) and
+            x0.ndim == 1
+          list = [x0[:%,1]]
+        else
+        list = list.map { |x|
+          case x
+          when CArray
+            if x.ndim == 1
+              x[:%,1]
+            else
+              x
+            end
+          when Array
+            y = x.first
+            if x.size == 1 and
+                y.is_a?(CArray) and
+                y.ndim == 1
+              y[1,:%]
+            else
+              CArray.join(*x)
+            end
+          else
+            x
+          end
+        }
+        end
+        if block_given?
+          CArray.bind(type, list, 1, &block)
+        else
+          CArray.bind(type, list, 1)
+        end 
+      else
+        list
+      end
+    end
+    if conc.size > 1
+      return CArray.bind(type, conc)
+    else
+      return conc.first
+    end
+  end
+  
+end