carray 1.3.5 → 1.5.2

data/lib/carray/autoload/autoload_gem_ffi.rb

@@ -0,0 +1,9 @@
+class CArray
+  autoload_method "mp", "carray-ffi"
+end
+
+module FFI
+  class MemoryPointer
+    autoload_method "ca", "carray-ffi"     
+  end
+end

data/lib/carray/autoload/autoload_gem_gnuplot.rb

@@ -0,0 +1,2 @@
+autoload_method "CA.gnuplot", "carray-gnuplot"
+

data/lib/carray/autoload/autoload_gem_io_csv.rb

@@ -0,0 +1,14 @@
+autoload_method "CArray.load_csv", "carray-io-csv"
+autoload_method "CArray.from_csv", "carray-io-csv"
+
+class CArray
+  autoload_method "save_csv", "carray-io-csv"
+  autoload_method "to_csv", "carray-io-csv"
+  autoload_method "to_tabular", "carray-io-csv"
+end
+
+module CA
+  autoload :CSVReader, "carray-io-csv"
+  autoload :CSVWriter, "carray-io-csv"
+end
+

data/lib/carray/autoload/autoload_gem_io_pg.rb

@@ -0,0 +1,6 @@
+autoload_method "CArray.load_pg", "carray-io-pg"
+
+class CArray
+  autoload_method "unescape_bytea", "carray-io-pg"
+  autoload_method "escape_bytea", "carray-io-pg"
+end

data/lib/carray/autoload/autoload_gem_io_sqlite3.rb

@@ -0,0 +1,12 @@
+autoload_method "CArray.load_sqlite3", "carray-io-sqlite3"
+
+class CArray
+  autoload_method "unblob", "carray-io-sqlite3"
+  autoload_method "to_sqlite3", "carray-io-sqlite3"
+end
+
+if Object.const_defined?(:SQLite3)
+  require "carray-io-sqlite3"
+else
+  autoload :SQLite3, "carray-io-sqlite3"
+end

data/lib/carray/autoload/autoload_gem_narray.rb

@@ -0,0 +1,10 @@
+class CArray
+  autoload_method :na,    "carray-narray"
+  autoload_method :to_na, "carray-narray"
+end
+
+class NArray
+  autoload_method :ca,    "carray-narray"
+  autoload_method :to_ca, "carray-narray"  
+end
+

data/lib/carray/autoload/autoload_gem_numo_narray.rb

@@ -0,0 +1,15 @@
+class CArray
+  autoload_method :to_numo,        "carray-numo-narray"
+  autoload_method :numo,           "carray-numo-narray"
+  autoload_method "self.as_numo",  "carray-numo-narray"
+  autoload_method "self.as_numo!", "carray-numo-narray"
+  autoload_method :as_numo,        "carray-numo-narray"
+  autoload_method :as_numo!,       "carray-numo-narray"
+end
+
+module Numo
+  class NArray
+    autoload_method :to_ca, "carray-numo-narray"
+    autoload_method :ca,    "carray-numo-narray"
+  end
+end

data/lib/carray/autoload/autoload_gem_opencv.rb

@@ -0,0 +1,16 @@
+module OpenCV
+  class CvMat
+    autoload_method "ca", "carray-opencv"
+    autoload_method "to_ca", "carray-opencv"
+    autoload_method "from_ca", "carray-opencv"
+    autoload_method "image", "carray-opencv"
+  end
+  class IplImage < CvMat
+    autoload_method "ca", "carray-opencv"
+  end
+end
+
+class CArray
+  autoload_method "to_cvmat", "carray-opencv"
+  autoload_method "to_iplimage", "carray-opencv"
+end

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/autoload/autoload_gem_rmagick.rb

@@ -0,0 +1,23 @@
+module Magick
+  class Image
+    autoload_method "export_pixels_to_ca", "carray-rmagick"
+    autoload_method "import_pixels_from_ca", "carray-rmagick"
+  end
+end
+
+class CArray
+  autoload_method "self.load_image", "carray-rmagick"
+  autoload_method "save_image", "carray-rmagick"
+  autoload_method "display_image", "carray-rmagick"
+  autoload_method "to_image", "carray-rmagick"
+end
+
+autoload :CAMagickImage, "carray-rmagick"
+
+module Magick
+  class Image
+    autoload_method "ca", "carray-rmagick"
+    autoload_method "to_ca", "carray-rmagick"
+  end
+end
+

data/lib/carray/basic.rb

@@ -0,0 +1,193 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/basic.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#  You can redistribute it and/or modify it under the terms of
+#  the Ruby Licence.
+#
+#  Copyright (C) 2005 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,45 @@
+
+class CArray
+  def broadcast_to (*new_dim)
+    if new_dim.size < ndim
+      raise "can't broadcast to #{new_dim.inspect} because of mismatch in rank"
+    end
+    flag_unbound_repeat = false
+    sdim = []
+    ([1]*(new_dim.size-ndim) + dim).each_with_index do |d, k|
+      if new_dim[k] == 1
+        sdim << 1
+      elsif d == 1
+        flag_unbound_repeat = true
+        sdim << :*
+      elsif d != new_dim[k]
+        raise "can't broadcast to #{new_dim.inspect} because of mismatch in #{d} for #{new_dim[k]} in #{k}th dim"
+      else
+        sdim << nil
+      end
+    end
+    return self[*sdim].bind(*new_dim) if flag_unbound_repeat
+    return self
+  end
+end
+
+class CScalar
+  def broadcast_to (*new_dim)
+    return self
+  end
+end
+
+class CAUnboundRepeat
+  alias broadcast_to bind
+end
+
+def CArray.broadcast (*argv)
+  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
+  return argv.map{|arg| arg.is_a?(CArray) ? arg.broadcast_to(*dim) : arg }
+end

data/lib/carray/compose.rb

@@ -0,0 +1,291 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/composition.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#  You can redistribute it and/or modify it under the terms of
+#  the Ruby Licence.
+#
+#  Copyright (C) 2005 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)
+    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)
+    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)
+    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
+    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)
+    return CArray.combine(data_type, [list.size], list, at)
+  end
+
+  def self.composite (data_type, tdim, list, at = 0)
+    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)
+    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)
+    return CArray.composite(data_type, [list.size], list, at)
+  end
+  
+  def self.join (*argv)
+    # get options
+    case argv.first
+    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