carray 1.1.4 → 1.1.5

data/lib/carray/base/inspect.rb

@@ -0,0 +1,252 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/base/inspect.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::Inspector  # :nodoc:
+
+  def initialize (carray)
+    @carray = carray
+  end
+
+  def inspect_string
+    if @carray.rank == 0
+      raise "can't inspect CArray of rank == 0"
+    end
+    formatter  = get_formatter()
+    class_name = get_class_name()
+    type_name  = get_type_name()
+    shape      = get_shape()
+    data_spec  = get_data_spec(0, Array.new(@carray.rank){0}, formatter)
+    info_list  = get_info_list()
+    output = ["<",
+              format("%s.%s(%s)", class_name, type_name, shape.join(",")),
+              ": ",
+              info_list.join(" "),
+              "\n",
+              data_spec,
+              ">"
+             ].join
+    if @carray.tainted?
+      output.taint
+    end
+    return output
+  end
+  
+  private
+
+  def get_class_name
+    return @carray.class.to_s
+  end
+
+  def get_type_name
+    type_name = CArray.data_type_name(@carray.data_type)
+    @carray.instance_exec {
+      case data_type
+      when CA_FIXLEN
+        return format("%s[%i]", type_name, bytes)
+      else
+        return type_name
+      end
+    }
+  end
+
+  def get_shape
+    case @carray.obj_type
+    when CA_OBJ_UNBOUND_REPEAT
+      dim = @carray.spec
+    else
+      dim = @carray.dim
+    end
+    return dim
+  end
+
+  def get_info_list
+    list = []
+    @carray.instance_exec {
+      # ---
+      if data_class
+        list << "data_class=%s" % data_class.inspect
+      end
+      # ---
+      if scalar?
+        list << "scalar"
+      end
+      # ---
+      unless kind_of?(CScalar)
+        list << "elem=%i" % elements
+      end
+      # ---      
+      if has_mask?
+        list << "mask=%i" % count_masked
+      end
+      # ---
+      memsize = elements * bytes
+      case true
+      when memsize < 1024
+        list << "mem=%ib" % memsize
+      when memsize < 1024*1024
+        list << "mem=%.1fkb" % (memsize/1024.0)
+      else
+        list << "mem=%.1fmb" % (memsize/1024.0/1024.0)
+      end
+      # ---
+      if mask_array?
+        list << "mask_array"
+      end
+      if value_array?
+        list << "value_array"
+      end
+      # ---
+      if read_only?
+        list << "ro"
+      end
+      # ---
+      if virtual? and attached?
+        list << "attached"
+      end
+      # ---
+      if has_attribute?
+        list << "attrs={" + attribute.keys.join(",") + "}"
+      end
+    }
+    return list
+  end
+
+  def get_formatter
+    case @carray.data_type
+    when CA_BOOLEAN, CA_INT8, CA_INT16, CA_INT32, CA_INT64
+      lambda{|x| "%i" % x }
+    when CA_UINT8, CA_UINT16, CA_UINT32, CA_UINT64
+      lambda{|x| "%u" % x }
+    when CA_FLOAT32
+      lambda{|x| "%.5g" % x }
+    when CA_FLOAT64, CA_FLOAT128
+      lambda{|x| "%.8g" % x }
+    when CA_CMPLX64, CA_CMPLX128, CA_CMPLX256
+      lambda{|x| format("%.5g%s%.5gi",
+                        x.real, (x.imag >= 0) ? "+" : "-", x.imag.abs) }
+    when CA_FIXLEN
+      if @carray.data_class
+        if @carray.bytes <= 6
+          lambda{|x| "%s" % x.encode.dump }
+        else
+          lambda{|x| "%s" % (x.encode.chomp[0, 5]+"...").dump }
+        end
+      else
+        if @carray.bytes <= 6
+          lambda{|x| "%s" % x.dump }
+        else
+          lambda{|x| "%s" % (x.chomp[0, 5]+"...").dump }
+        end
+      end
+    when CA_OBJECT
+      lambda { |x| x.inspect }
+    end
+  end
+
+  def get_data_spec (level, idx, formatter)
+    io = "[ "
+    rank = @carray.rank
+    dim  = @carray.dim
+    if level == rank - 1
+      over = false
+      dim[level].times do |i|
+        idx[level] = i
+        v = @carray[*idx]
+        if v.undef?
+          io << '_'
+        else
+          io << formatter[v]
+        end
+        if i != dim[level] - 1
+          io << ", "
+        end
+        if io.length > 48 - 2*level
+          if i < dim[level] - 1
+            io << "..."
+            over = true
+          end
+          break
+        end
+      end
+      if over
+        idx[level] = dim[level] - 1
+        v = @carray[*idx]
+        if v.undef?
+          io << ", _"
+        else
+          io << ", " + formatter[v]
+        end
+      end
+    else
+      over = false
+      show = [dim[level], 5].min
+      show.times do |i|
+        idx[level] = i
+        io << get_data_spec(level+1, idx, formatter)
+        if i < show - 1
+          io << ",\n" + "  " * (level+1)
+        end
+        if i >= 2 and dim[level] > 5
+          break
+        end
+      end
+      if dim[level] > 5
+        io << "... ... ..."
+        over = true
+      end
+      if over
+        idx[level] = dim[level] - 1
+        io << "\n"+ "  " * (level+1) + get_data_spec(level+1, idx, formatter)
+      end
+    end
+    io << " ]"
+    return io
+  end
+
+end
+
+class CArray
+
+  def inspect
+    return CArray::Inspector.new(self).inspect_string
+  end
+
+  private
+
+  def desc  
+    output = ""
+    case data_type 
+    when CA_FIXLEN
+      output << sprintf("CArray.%s(%s, :bytes=>%i)", 
+                        data_type_name, dim.inspect[1..-2], bytes)
+    else
+      output << sprintf("CArray.%s(%s)", 
+                        data_type_name, dim.inspect[1..-2])
+    end
+    return output
+  end
+  
+  public
+
+  def code 
+    text = [
+      desc,
+      " { ",
+      self.to_a.pretty_inspect.split("\n").map{|s|
+        " " * (desc.length+3) + s
+      }.join("\n").lstrip,
+      " }"
+    ].join
+    return text
+  end
+
+end

data/lib/carray/base/iterator.rb

@@ -0,0 +1,367 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/base/iterator.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 CAIterator
+
+  include Enumerable 
+
+  def self.define_evaluate_method (name)
+    define_method(name) { |*args|
+      self.evaluate(name, *args) 
+    }
+  end
+
+  [
+    :axes!,
+    :normalize!,
+    :random!,
+    :reverse!,
+    :roll!,
+    :scale!,
+    :seq!,
+    :shift!,
+    :shuffle!,
+    :sort!,
+    :span!,
+    :transpose!,
+  ].each do |name|
+    define_evaluate_method(name)
+  end
+
+  def self.define_filter_method (data_type, name)
+    define_method(name) { |*args|
+      _data_type = data_type || self.reference.data_type
+      self.filter(_data_type, name, *args) 
+    }
+  end
+
+  [
+    [:axes      ],
+    [:normalize ],
+    [:random    ],
+    [:reverse   ],
+    [:roll      ],
+    [:scale     ],
+    [:seq       ],
+    [:shift     ],
+    [:shuffle   ],
+    [:sort      ],
+    [:span      ],
+    [:transpose ],
+  ].each do |name, data_type|
+    define_filter_method(data_type, name)
+  end
+
+  def self.define_calculate_method (data_type, name)
+    define_method(name) { |*args|
+      _data_type = data_type || self.reference.data_type
+      self.calculate(_data_type, name, *args) 
+    }
+  end
+
+  [
+    [:count_masked,     CA_INT32],
+    [:count_not_masked, CA_INT32],
+    [:count_true,       CA_INT32],
+    [:count_false,      CA_INT32],
+    [:size,             CA_INT32],
+    [:min,              nil],
+    [:min_addr,         CA_INT32],
+    [:max,              nil],
+    [:max_addr,         CA_INT32],
+    [:prod,             CA_FLOAT64],
+    [:sum,              CA_FLOAT64],
+    [:wsum,             CA_FLOAT64],
+    [:mean,             CA_FLOAT64],
+    [:wmean,            CA_FLOAT64],
+    [:variancep,        CA_FLOAT64],
+    [:variance,         CA_FLOAT64],
+    [:stddevp,          CA_FLOAT64],
+    [:stddev,           CA_FLOAT64],
+    [:median,           CA_FLOAT64],
+    [:accumulate,       nil],
+    [:cummin,           nil],
+    [:cummax,           nil],
+    [:cumcount,         CA_FLOAT64],
+    [:cumprod,          CA_FLOAT64],
+    [:cumsum,           CA_FLOAT64],
+    [:cumwsum,          CA_FLOAT64],
+    [:count_equal,      CA_INT32],
+    [:count_equiv,      CA_INT32],
+    [:count_close,      CA_INT32],
+    [:all_equal?,       CA_BOOLEAN],
+    [:any_equal?,       CA_BOOLEAN],
+    [:none_equal?,      CA_BOOLEAN],
+    [:all_equiv?,       CA_BOOLEAN],
+    [:any_equiv?,       CA_BOOLEAN],
+    [:none_equiv?,      CA_BOOLEAN],
+    [:all_close?,       CA_BOOLEAN],
+    [:any_close?,       CA_BOOLEAN],
+    [:none_close?,      CA_BOOLEAN],
+    [:nearest_addr,     CA_INT32],
+    [:mul_add,          nil],
+  ].each do |name, data_type|
+    define_calculate_method(data_type, name)
+  end
+
+  # -----------------------------------------------------------
+
+  def ca
+    @iterary ||= CAIteratorArray.new(self)
+    return @iterary
+  end
+
+  def to_a
+    return ca.to_a
+  end
+
+  def pick (*idx)
+    out = prepare_output(reference.data_type, :bytes=>reference.bytes)
+    elements.times do |addr|
+      blk = kernel_at_addr(addr)
+      out[addr] = blk[*idx]
+    end
+    return out
+  end
+
+  def asign! (val)
+    each do |elem|
+      elem[] = val
+    end
+    return self
+  end
+
+  def [] (*idx)
+    if idx.any?{|x| x.is_a?(Symbol) }
+      return ca[*idx]
+    else
+      case idx.size
+      when 0
+        return clone
+      when 1
+        return kernel_at_addr(idx[0])
+      else
+        return kernel_at_index(idx)
+      end
+    end
+  end
+
+  def []= (*idx)
+    val = idx.pop
+    if idx.any?{|x| x.is_a?(Symbol) }
+      ca[*idx] = [val]
+    else
+      case idx.size
+      when 0
+        asign!(val)
+      when 1
+        kernel_at_addr(idx[0])[] = val
+      else
+        kernel_at_index(idx)[] = val
+      end
+    end
+  end
+
+  def put (*idx)
+    val = idx.pop
+    elements.times do |addr|
+      blk = kernel_at_addr(addr)
+      blk[*idx] = val
+    end
+    return self
+  end
+
+  def convert (data_type, options={})
+    out = prepare_output(data_type, options)
+    out.map_addr!{ |addr|
+      blk = kernel_at_addr(addr)
+      yield(blk.clone)
+    }
+    return out
+  end
+
+  def each ()
+    retval = nil
+    if self.class::UNIFORM_KERNEL
+      reference.attach! {
+        blk = kernel_at_addr(0)
+        elements.times do |addr|
+          kernel_move_to_addr(addr, blk)
+          retval = yield(blk.clone)
+        end
+      }
+    else
+      elements.times do |addr|
+        retval = yield(kernel_at_addr(addr).clone)
+      end
+    end
+    return retval
+  end
+
+  def each_with_addr ()
+    retval = nil
+    if self.class::UNIFORM_KERNEL
+      reference.attach! {
+        elements.times do |addr|
+          blk = kernel_at_addr(addr)
+          retval = yield(blk.clone, addr)
+        end
+      }
+    else
+      elements.times do |addr|
+        retval = yield(kernel_at_addr(addr).clone, addr)
+      end
+    end
+    return retval
+  end
+
+  def each_with_index ()
+    retval = nil
+    if self.class::UNIFORM_KERNEL
+      reference.attach! {
+        CArray.each_index(*dim) do |*idx|
+          blk = kernel_at_index(idx)
+          retval = yield(blk.clone, idx)
+        end
+      }
+    else
+      CArray.each_index(*dim) do |*idx|
+        retval = yield(kernel_at_index(idx).clone, idx)
+      end
+    end
+    return retval
+  end
+
+  def inject (*argv)
+    case argv.size
+    when 0
+      memo = nil
+      each_with_addr do |val, addr|
+        if addr == 0
+          memo = val
+        else
+          memo = yield(memo, val)
+        end
+      end
+      return memo
+    when 1
+      memo = argv.first
+      each do |val|
+        memo = yield(memo, val)
+      end
+      return memo
+    else
+      raise "invalid number of arguments (#{argv.size} for 0 or 1)"
+    end
+  end
+
+  def sort_by! (&block)
+    ia = self.ca
+    ia[] = ia.to_a.sort_by(&block).map{|x| x.to_ca }
+    return reference
+  end
+
+  def sort_by (&block)
+    out = reference.template
+    idx = ca.convert(:object, &block).sort_addr
+    ca[idx].each_with_addr do |blk, i|
+      kernel_at_addr(i, out)[] = blk
+    end
+    return out
+  end
+
+  def sort_with (&block)
+    out = reference.template
+    idx = CA.sort_addr(*yield(self))
+    ca[idx].each_with_addr do |blk, i|
+      kernel_at_addr(i, out)[] = blk
+    end
+    return out
+  end
+
+end
+
+
+# -----------------------------------------------------------------
+
+class CArray
+  def windows (*args, &block)
+    return CAWindowIterator.new(self.window(*args, &block))
+  end
+end
+
+# -----------------------------------------------------------------
+
+class CArray
+  
+  def classes (classifier=nil, &block)
+    return CAClassIterator.new(self, classifier).__build__(&block)
+  end
+  
+end
+
+class CAClassIterator < CAIterator # :nodoc:
+  
+  UNIFORM_KERNEL = false
+  
+  def initialize (reference, classifier = nil)
+    @reference = reference
+    @classifier = classifier || @reference.uniq.sort
+    @null = CArray.new(@reference.data_type,[0])
+    @table = {}
+    @rank = 1
+    @dim  = [0]
+    if @classifier.all_masked? or @classifier.size == 0
+      @dim  = [0]
+    else
+#      @dim  = [@classifier.max+1]
+      @dim  = [@classifier.size]
+    end
+  end
+  
+  attr_reader :classifier, :table
+  
+  def __build__ (&block)
+    if @block
+      @classifier.each_with_addr do |v, i|
+        @table[v] = block[v].where
+      end
+    else
+      @classifier.each_with_addr do |v, i|
+        @table[v] = @reference.eq(v).where
+      end
+    end
+    return self
+  end
+  
+  def ranking (&block)
+    block ||= lambda {|a| a.size }
+    values = self.to_a.map{|v| block[v] }.to_ca
+    addrs  = values.sort_addr.reverse
+    return CArray.join([@classifier[addrs], values[addrs]])
+  end
+
+  def kernel_at_addr (addr, ref = nil)
+    ref ||= @reference
+    if @table[addr]
+      return ref[@table[addr]]
+    else
+      return @null
+    end
+  end
+
+  def kernel_at_index (idx, ref = nil)
+    kernel_at_addr(idx[0], ref)
+  end
+
+end
+