carray 2.0.0 → 3.0.0

data/lib/carray/object/ca_obj_pack.rb

@@ -1,99 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/object/ca_obj_pack.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-#
-#
-# [ca1, ca2, ca3] => ca4
-#
-#
-#
-
-
-class CAPack < CAObject # :nodoc:
-
-  def initialize (list, options={})
-    @list   = list
-    @ndim   = options[:ndim]
-    unless @ndim
-      @ndim = list.map{|m| m.ndim}.min
-    end
-    @names  = options[:names] || [nil]*@list.size
-    @dim    = guess_dim(list)
-    @struct = guess_struct(list)
-    super(@struct, @dim, :read_only=>true)
-    freeze
-  end
-
-  private
-
-  def fetch_index (idx)
-    out   = @struct.new
-    dummy = idx + [false]
-    @struct.members.each_with_index do |name, i|
-      out[name] = @list[i][*dummy]
-    end
-    return out
-  end
-
-  def copy_data (data)
-    data.fields.zip(@list).each do |mem, d|
-      mem[] = d
-    end
-  end
-
-  def guess_dim (list)
-    dim = nil
-    list.each do |mem|
-      case mem
-      when CArray
-        if mem.ndim < @ndim
-          raise "mem.ndim < @ndim"
-        else
-          newdim = mem.dim[0, @ndim]
-        end
-        if dim
-          unless dim == newdim
-            raise "dim != newdim"
-          end
-        else
-          dim = newdim
-        end
-      end
-    end
-    return dim || [1]
-  end
-
-  def guess_struct (list)
-    st = CA.struct(:pack=>1) { |s|
-      list.each_with_index do |mem, i|
-        name = @names[i]
-        case mem
-        when CArray
-          if mem.ndim == @ndim
-            s.member mem.data_type, name, :bytes=>mem.bytes ### anonymous member
-          else
-            dummy = Array.new(@ndim){0} + [false]
-            s.member mem[*dummy].to_ca, name                ### anonymous member
-          end
-        else
-          raise "invalid object for CAPack"
-        end
-      end
-    }
-    return st
-  end
-
-end
-
-class CArray
-  def self.pack (*argv)
-    return CAPack.new(argv)
-  end
-end

data/lib/carray/obsolete.rb

@@ -1,256 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/obsolete.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-module CA
-  TableMethods = CArray::TableMethods
-end
-
-class CArray
-  
-  ### obsolete methods
-
-  def extend_as_table (column_names)
-    warn "CArray#extend_as_table will be obsolete"
-    self.extend CArray::TableMethods
-    self.column_names = column_names
-    self
-  end
-
-  # Returns the array eliminated all the duplicated elements.
-  def duplicated_values
-    warn "CArray#duplicated_values will be obsolete"
-    if uniq.size == size
-      return []
-    else
-      hash = {}
-      list = []
-      each_with_addr do |v, addr|
-        if v == UNDEF
-          next
-        elsif hash[v]
-          list << [v, addr, hash[v]]
-          hash[v] += 1
-        else
-          hash[v] = 0
-        end
-      end
-      return list
-    end
-  end
-
-  def self.summation (*dim)
-    warn "CArray.summation will be obsolete"
-    out = nil
-    first = true
-    CArray.each_index(*dim) { |*idx|
-      if first
-        out = yield(*idx)
-        first = false
-      else
-        out += yield(*idx)
-      end
-    }
-    return out
-  end
-  
-  def by (other)
-    warn "CArray#by will be obsolete"
-    case other
-    when CArray
-      return (self[nil][nil,:*]*other[nil][:*,nil]).reshape(*(dim+other.dim))
-    else
-      return self * other
-    end
-  end
-
-  def save_binary (filename, opt={})    # :nodoc: 
-    warn "CArray#save_binary will be obsolete, use CArray.save"
-    open(filename, "w") { |io|
-      return Serializer.new(io).save(self, opt)
-    }
-  end
-
-  def self.load_binary (filename, opt={})     # :nodoc: 
-    warn "CArray.load_binary will be obsolete, use CArray.load"
-    open(filename) { |io|
-      return Serializer.new(io).load(opt)
-    }
-  end
-
-  def save_binary_io (io, opt={})        # :nodoc:
-    warn "CArray#save_binary_io will be obsolete, use CArray.save"
-    return Serializer.new(io).save(self, opt) 
-  end
-
-  def self.load_binary_io (io, opt={})   # :nodoc:
-    warn "CArray#load_binary_io will be obsolete, use CArray.load"
-    return Serializer.new(io).load(opt)   
-  end 
-
-  def to_binary (io="", opt={})          # :nodoc:
-    warn "CArray#to_binary will be obsolete, use CArray.dump"
-    Serializer.new(io).save(self, opt) 
-    return io
-  end
-
-  def self.from_binary (io, opt={})      # :nodoc:
-    warn "CArray.from_binary will be obsolete, use CArray.load"
-    return Serializer.new(io).load(opt)   
-  end 
-
-  def replace_value (from, to)
-    warn "CArray#replace_value will be obsolete"
-    self[:eq, from] = to
-    return self
-  end
-  
-  def asign (*idx)
-    warn "CArray#asign will be obsolete"
-    self[*idx] = yield
-    return self
-  end
-  
-  def fa                               # :nodoc:
-    warn "CArray#fa will be obsolete, use CArray#t"
-    return self.t
-  end
-
-  def block_iterator (*argv)           # :nodoc:
-    warn "CArray#block_iterator will be obsolete, use CArray#blocks"
-    return blocks(*argv)
-  end
-
-  def window_iterator (*argv)          # :nodoc:
-    warn "CArray#window_iterator will be obsolete, use CArray#windows"
-    return windows(*argv)
-  end
-
-  def rotated (*argv)                  # :nodoc:
-    warn "CArray#rotated will be obsolete, use CArray#rolled"
-    argv.push({:roll => Array.new(ndim){1} })
-    return shifted(*argv)
-  end
-
-  def rotate! (*argv)                  # :nodoc:
-    warn "CArray#rotate! will be obsolete, use CArray#roll!"
-    self[] = self.rolled(*argv)
-    return self
-  end
-
-  def rotate (*argv)                   # :nodoc:
-    warn "CArray#rotate will be obsolete, use CArray#roll"
-    return self.rolled(*argv).to_ca
-  end
-
-  def select (&block)                  # :nodoc:
-    warn "CArray#select will be obsolete"
-    case block.arity
-    when 1
-      return self[*yield(self)]
-    when -1, 0
-      return self[*instance_exec(&block)]
-    else
-      raise
-    end
-  end
-
-  def transform (type, dim, opt = {}) # :nodoc:
-    warn("CArray#transform will be obsolete")
-    return refer(type, dim, opt).to_ca
-  end
-  
-  def classify (klass, outlier = nil)  # :nodoc:
-    warn "CArray#classify will be obsolete"
-    b = CArray.int32(*dim)
-    f = CArray.boolean(*dim) { 1 }
-    attach {
-      (klass.elements-1).times do |i|
-        r = f.and(self < klass[i+1])
-        b[r] = i
-        f[r] = 0
-      end
-      if outlier
-        b[self < klass[0]] = outlier
-        b[f] = outlier
-      else
-        b[self < klass[0]] = -1
-        b[f] = klass.elements-1
-      end
-    }
-    return b
-  end
-
-
-
-end
-
-=begin
-
-class Numeric
-  
-  [
-    :boolean,
-    :int8,
-    :uint8,
-    :int16,
-    :uint16,
-    :int32,
-    :uint32,
-    :int64,
-    :uint64,
-    :float32,
-    :float64,
-    :float128,
-    :cmplx64,
-    :cmplx128,
-    :cmplx256,
-    :byte,
-    :short,
-    :int,
-    :float,
-    :double,
-    :complex,
-    :dcomplex,
-    :object
-  ].each do |name|
-    class_eval %{
-      def #{name} ()
-        warn "Numeric##{name} will be obsolete"
-        CScalar.new(#{name.inspect}) {self}
-      end
-    }
-  end
-
-end
-
-class CArray
-  def histogram (klass)
-    c = CArray.int32(klass.elements-1)
-    f = CArray.boolean(*dim) { 1 }
-    attach {
-      k = 0
-      r = f.and(self < klass[0])
-      f[r] = 0
-      (klass.elements-1).times do |i|
-        r = f.and(self < klass[i+1])
-        c[k] = r.count_true
-        f[r] = 0
-        k+=1
-      end
-    }
-    return c
-  end
-
-  def self.load_from_file (filename, data_type, dim, opt={}) # :nodoc:
-    raise "Sorry, CArray.load_from_file is depleted"
-  end
-
-end
-=end

data/lib/carray/ordering.rb

@@ -1,181 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/ordering.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-class CArray
-  
-  # reversed
-  def reversed
-    return self[*([-1..0]*ndim)]
-  end
-  
-  # roll / shift
-
-  def shift! (*argv, &block)
-    self[] = self.shifted(*argv, &block)
-    return self
-  end
-
-  def shift (*argv, &block)
-    return self.shifted(*argv, &block).to_ca
-  end
-
-  def rolled (*argv)
-    argv.push({:roll => Array.new(ndim){1} })
-    return shifted(*argv)
-  end
-
-  def roll! (*argv)
-    self[] = self.rolled(*argv)
-    return self
-  end
-
-  def roll (*argv)
-    return self.rolled(*argv).to_ca
-  end
-    
-  # Returns the reference which elements are sorted by the comparison method
-  # given as block
-  def sorted_by (type=nil, opt={}, &block)
-    type, bytes =
-      CArray.guess_type_and_bytes(type||data_type, opt[:bytes]||bytes)
-    cmpary = convert(type, :bytes=>bytes, &block)
-    return self[cmpary.sort_addr]
-  end
-
-  # Returns the array which elements are sorted by the comparison method
-  # given as block
-  def sort_by (type=nil, opt={}, &block)
-    type, bytes =
-      CArray.guess_type_and_bytes(type||data_type, opt[:bytes]||bytes)
-    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?
-      return UNDEF
-    else
-      addr = convert(:object, &block).max_addr
-      return self[addr]
-    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
-    else
-      addr = convert(:object, &block).min_addr
-      return self[addr]
-    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
-
-  def nlargest (n)
-    obj = self.to_ca
-    list = []
-    n.times do |i|
-      k = obj.max_addr
-      list << obj[k]
-      obj[k] = UNDEF
-    end
-    list.to_ca.to_type(data_type)
-  end
-
-  def nlargest_addr (n)
-    obj = self.to_ca
-    list = []
-    n.times do |i|
-      k = obj.max_addr
-      list << k
-      obj[k] = UNDEF
-    end
-    CA_INT64(list)
-  end
-
-  def nsmallest (n)
-    obj = self.to_ca
-    list = []
-    n.times do |i|
-      k = obj.min_addr
-      list << obj[k]
-      obj[k] = UNDEF
-    end
-    list.to_ca.to_type(data_type)
-  end
-
-  def nsmallest_addr (n)
-    obj = self.to_ca
-    list = []
-    n.times do |i|
-      k = obj.min_addr
-      list << k
-      obj[k] = UNDEF
-    end
-    CA_INT64(list)
-  end
-
-  def order (dir = 1)
-    if dir >= 0   ### ascending order
-      if has_mask?
-        obj = template(:int32) { UNDEF }
-        sel = is_not_masked
-        obj[sel][self[sel].sort_addr].seq!
-        return obj
-      else
-        obj = template(:int32)
-        obj[sort_addr].seq!
-        return obj
-      end
-    else           ### descending order
-      if has_mask?
-        obj = template(:int32) { UNDEF}
-        sel = is_not_masked
-        obj[sel][self[sel].sort_addr.reversed].seq!
-        return obj
-      else  
-        obj = template(:int32)
-        obj[sort_addr.reversed].seq!
-        return obj
-      end
-    end
-  end
-
-end

data/lib/carray/testing.rb

@@ -1,51 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/test.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-class CArray
-
-  def test (&block)
-    return convert(:boolean) {|v| yield(v) ? true : false }
-  end
-
-  def contains (*list)
-    result = self.false()
-    list.each do |item|
-      result = result | self.eq(item)
-    end
-    return result 
-  end
-
-  def between (a, b)
-    return (self >= a) & (self <= b)
-  end
-
-  def where_range
-    w = where
-    x = (w - w.shifted(1){-2}).sub!(1).where
-    y = (w - w.shifted(-1){-2}).add!(1).where
-    list = []
-    x.each_addr do |i|
-      list.push(w[x[i]]..w[y[i]])
-    end
-    return list
-  end
-  
-  # Returns the array eliminated all the duplicated elements.
-  def uniq
-    ary = flatten.to_a.uniq
-    if has_mask?
-      ary.delete(UNDEF)
-    end
-    out = CArray.new(data_type, [ary.length], :bytes=>bytes) { ary }
-    out.data_class = data_class if has_data_class?
-    return out
-  end
-
-end

data/lib/carray/transform.rb

@@ -1,109 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  carray/composition.rb
-#
-#  This file is part of Ruby/CArray extension library.
-#
-#  Copyright (C) 2005-2020 Hiroki Motoyoshi
-#
-# ----------------------------------------------------------------------------
-
-class CArray
-  
-  # reshape
-
-  def reshape (*newdim)
-    ifalse = nil
-    i = 0
-    0.upto(newdim.size-1) do |i|
-      if newdim[i].nil?
-        newdim[i] = dim[i]
-      elsif newdim[i] == false 
-        ifalse = i
-        break
-      end
-    end
-    k = 0
-    (newdim.size-1).downto(i+1) do |j|
-      if newdim[j].nil?
-        newdim[j] = dim[ndim-1-k]
-      end
-      k += 1
-    end
-    if ifalse
-      newdim[ifalse] = 
-          elements/newdim.select{|x| x!=false}.inject(1){|s,x| s*x}
-    end
-    return refer(data_type, newdim, :bytes=>bytes)
-  end
-
-  # flatten
-
-  def flattened
-    return reshape(elements)
-  end
-
-  def flatten
-    return reshape(elements).to_ca
-  end
-
-  def transpose! (*argv)
-    self[] = self.transposed(*argv)
-    return self
-  end
-
-  def transpose (*argv)
-    return self.transposed(*argv).to_ca
-  end
-
-  # Reutrns the reference which ndim is reduced 
-  # by eliminating the dimensions which size == 1 
-  def compacted
-    if ndim == 1
-      return self[]
-    else
-      newdim = dim.reject{|x| x == 1 }
-      return ( ndim != newdim.size ) ? reshape(*newdim) : self[]
-    end
-  end
-
-  # Returns the array which ndim is reduced 
-  # by eliminating the dimensions which size == 1 
-  def compact
-    if ndim == 1
-      return self.to_ca
-    else
-      newdim = dim.reject{|x| x == 1 }
-      return ( ndim != newdim.size ) ? reshape(*newdim).to_ca : self.to_ca
-    end
-  end
-
-  # Returns (1,n) array from 1-dimensional array 
-  def to_row 
-    if ndim != 1
-      raise "ndim should be 1"
-    end
-    return self[1,:%]
-  end
-  
-  # Returns (n,1) array from 1-dimensional array 
-  def to_column
-    if ndim != 1
-      raise "ndim should be 1"
-    end
-    return self[:%,1]
-  end
-
-  # pulled
-
-  def pulled (*args)
-    idx = args.map{|s| s.nil? ? :% : s}
-    return self[*idx]
-  end
-  
-  def pull (*args)
-    idx = args.map{|s| s.nil? ? :% : s}
-    return self[*idx].to_ca
-  end
-
-end