carray 2.0.0 → 3.0.0

data/lib/carray/compose.rb

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

data/lib/carray/convert.rb

@@ -1,115 +0,0 @@
-
-
-
-class CArray
-
-  #
-  # Returns the 8-bit integer CArray object filled with 0 which
-  # dimension size is same as +self+. The resulted array represents
-  # the logical array which has +false+ for its all elements.
-  #
-  def false ()
-    return template(:boolean)
-  end
-
-  #
-  # Returns the 8-bit integer CArray object filled with 1 which
-  # dimension size is same as +self+. The resulted array represents
-  # the logical array which has +true+ for its all elements.
-  #
-  def true ()
-    return template(:boolean) { 1 }
-  end
-
-  # Returns map
-  def map (&block)
-    return self.convert(CA_OBJECT, &block).to_a
-  end
-
-  #
-  #  ref = CA_INT([[0,1,2],[1,2,0],[2,0,1]])
-  #  a = CArray.int(3,3).seq(1)
-  #  b = CArray.int(3,3).seq(11)
-  #  c = CArray.int(3,3).seq(21)
-  #
-  #  CArray.pickup(CA_OBJECT, ref, [a,b,c])
-  #  => <CArray.object(3,3): elem=9 mem=72b
-  #  [ [ 1, 12, 23 ],
-  #    [ 14, 25, 6 ],
-  #    [ 27, 8, 19 ] ]>
-  #
-  #  CArray.pickup(CA_OBJECT, ref, ["a","b","c"])
-  #  => <CArray.object(3,3): elem=9 mem=36b
-  #  [ [ "a", "b", "c" ],
-  #    [ "b", "c", "a" ],
-  #    [ "c", "a", "b" ] ]>
-  #
-  def self.pickup (data_type, ref, args)
-    out = ref.template(data_type)
-    args.each_with_index do |v, i|
-      s = ref.eq(i)
-      case v
-      when CArray
-        out[s] = v[s]
-      else
-        out[s] = v
-      end
-    end
-    return out
-  end
-
-  # Array#join like method
-  #
-  # > a = CArray.object(3,3).seq("a",:succ)
-  # => <CArray.object(3,3): elem=9 mem=72b
-  # [ [ "a", "b", "c" ],
-  #   [ "d", "e", "f" ],
-  #   [ "g", "h", "i" ] ]>
-  # 
-  # > a.join("\n",",")
-  # => "a,b,c\nd,e,f\ng,h,i"
-  #
-
-  def join (*argv)
-    case argv.size
-    when 0
-      return to_a.join()
-    when 1
-      sep = argv.shift
-      return to_a.join(sep)
-    else
-      sep = argv.shift
-      return self[:i, false].map { |s|
-          s[0, false].join(*argv)
-      }.join(sep)
-    end
-  end
-    
-  # 
-  def to_bit_string (nb)
-    hex = CArray.uint8(((nb*elements)/8.0).ceil)
-    hex.bits[nil].paste([0], self.bits[false,[(nb-1)..0]].flatten)
-    hex.bits[] = hex.bits[nil,[-1..0]]
-    return hex.to_s
-  end
-
-  def from_bit_string (bstr, nb)
-    hex = CArray.uint8(bstr.length).load_binary(bstr)
-    hex.bits[] = hex.bits[nil,[-1..0]]
-    bits = hex.bits.flatten
-    self.bits[false,[(nb-1)..0]][nil].paste([0], bits)
-    return self
-  end
-
-  def self.from_bit_string (bstr, nb, data_type=CA_INT32, dim=nil)
-    if dim
-      obj = CArray.new(data_type, dim)
-    else
-      dim0 = ((bstr.length*8)/nb.to_f).floor
-      obj = CArray.new(data_type, [dim0])
-    end
-    obj.from_bit_string(bstr, nb)
-    return obj
-  end
-  
-end

data/lib/carray/info.rb

@@ -1,110 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/info.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-
-require "carray"
-
-printf "\n"
-printf "CArray Environment Information\n"
-printf "==============================\n"
-printf "\n"
-printf "# version\n"
-printf "    CArray::VERSION      -> %s\n", CArray::VERSION
-printf "    CArray::VERSION_DATE -> %s\n", CArray::VERSION_DATE
-printf "\n"
-printf "# supports\n"
-printf "    CArray::HAVE_COMPLEX -> %s\n", CArray::HAVE_COMPLEX
-printf "    CArray::HAVE_NARRAY  -> %s\n", CArray::HAVE_NARRAY
-printf "\n"
-printf "# limitations\n"
-printf "    CA_RANK_MAX  -> %2i\n", CA_RANK_MAX
-printf "\n"
-printf "# data types\n"
-[
-  "CA_FIXLEN",
-  "CA_INT8",
-  "CA_UINT8",
-  "CA_INT16",
-  "CA_UINT16",
-  "CA_INT32",
-  "CA_UINT32",
-  "CA_INT64",
-  "CA_UINT64",
-  "CA_FLOAT32",
-  "CA_FLOAT64",
-  "CA_FLOAT128",
-  "CA_CMPLX64",
-  "CA_CMPLX128",
-  "CA_CMPLX256",
-  "CA_OBJECT",
-  "CA_BYTE",
-  "CA_SHORT",
-  "CA_INT",
-  "CA_FLOAT",
-  "CA_DOUBLE",
-  "CA_COMPLEX",
-  "CA_DCOMPLEX",
-].each do |name|
-  data_type = eval(name)
-  if CArray.data_type?(data_type)
-#    printf("    %-12s -> %2i    [bytes -> %2i]\n",
-#           name, data_type, CArray.sizeof(data_type))
-  else
-    printf("    %-12s -> not available\n", name)
-  end
-end
-
-printf "\n"
-printf "# default CArray classes\n"
-carrays = []
-cavirtuals = []
-ObjectSpace.each_object(Class) do |c|
-  if c <= CAVirtual
-    cavirtuals.push c
-  elsif c <= CArray
-    carrays.push c
-  end
-end
-printf "    entity  -> %2i [%s]\n", carrays.size, carrays.join(", ")
-printf "    virtual -> %2i\n", cavirtuals.size
-
-printf "\n"
-printf "# default CArray methods\n"
-o = Object.new
-a = CArray.int(3)
-list = a.methods - o.methods
-printf "    methods  -> %2i\n", list.size
-
-def which (cmd)
-  return ENV["PATH"].split(":").detect do |dir|
-    filename = File.join(dir, cmd)
-    File.executable?(filename)
-  end
-end
-
-printf "\n"
-printf "# helper commands\n"
-
-[
-  ["gnuplot", ["carray/graphics/gnuplot.rb"]],
-  ["convert", ["carray/io/imagemagick.rb"]],
-  ["display", ["carray/io/imagemagick.rb"]],
-  ["identify", ["carray/io/imagemagick.rb"]],
-  ["stream", ["carray/io/imagemagick.rb"]],
-].each do |cmd, libs|
-  path = which(cmd)
-  if path
-    printf("    %s -> installed, required by %s\n", cmd, libs.join(","))
-  else
-    printf("    %s -> not installed, required by %s\n", cmd, libs.join(","))
-  end
-end
-
-printf "\n"