carray 1.1.4 → 1.1.5

data/lib/carray/io/table.rb

@@ -0,0 +1,77 @@
+
+module CA
+  
+  module TableMethods
+
+    attr_reader :column_names
+
+    def column_names= (list)
+      if self.empty?
+        return
+      elsif list.nil? 
+        return
+      elsif list.empty? 
+        return
+      elsif list and list.size != dim1
+        raise "column_names list size is invalid (#{list.size} <=> #{dim1} )"
+      else
+        @column_names = list
+      end
+    end
+
+    def column (name)
+      if name.is_a?(Integer)
+        return self[false, name]
+      elsif @column_names
+        case name
+        when Symbol
+          if i = @column_names.index(name) or i = @column_names.index(name.to_s) 
+            return self[false, i]
+          end          
+        when String
+          if i = @column_names.index(name) or i = @column_names.index(name.intern) 
+            return self[false, i]
+          end
+        end
+      end
+      return nil
+    end
+
+    def row (i)
+      keys = @column_names || (0...dim0).to_a
+      output = {}
+      data = self[i, nil]
+      keys.each_with_index do |key, j|
+        output[key] = data[j]
+      end
+      return output
+    end
+
+    def rows (arg)
+      table = self[arg, nil].to_ca
+      table.extend(CA::TableMethods)
+      table.column_names = @column_names
+      return table
+    end
+
+    def select
+      idx = yield(self)
+      case idx.data_type
+      when CA_BOOLEAN
+        idx = idx.where
+      end
+      return rows(+idx)
+    end
+
+  end
+  
+end
+
+class CArray
+  
+  def extend_as_table (column_names)
+    self.extend CA::TableMethods
+    self.column_names = column_names
+  end
+    
+end

data/lib/carray/math/histogram.rb

@@ -0,0 +1,179 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/math/histogram.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
+#
+# ----------------------------------------------------------------------------
+
+#
+# N-dimensional histogram class
+#
+
+#
+# c0 : b0 <= x < b1  
+# c1 : b1 <= x < b2  
+# c2 : b2 <= x < b3  
+#
+
+require 'carray'
+
+class CAHistogram < CArray
+
+  def initialize (*argv, &block)
+
+    case argv.first
+    when Integer, String, Symbol
+      data_type = argv.shift
+    else
+      data_type = CA_INT32
+    end
+
+    scales = argv.shift
+    opt    = argv.shift || {}
+
+    option = {
+      :include_upper  => false,
+      :include_lowest => true,
+      :offsets        => nil,
+    }.update( opt )
+
+    @include_upper  = option[:include_upper]
+    @include_lowest = option[:include_lowest]    
+
+    unless scales.kind_of?(Array)
+      raise "scales should be an array of scales"
+    end
+
+    rank = scales.size
+    @scales = scales.clone
+    @scales.map! { |s| CArray.wrap_readonly(s, CA_DOUBLE) }
+    
+    if option[:offsets]
+      if option[:offsets].size == scales.size
+        @offsets = option[:offsets]
+      else
+        raise "invalid length of offset in option"
+      end
+    else
+      @offsets = Array.new(rank) { 0 }
+    end
+
+    dim = Array.new(rank) { |i| 
+      case @offsets[i]
+      when 0
+        @scales[i].size
+      when 1
+        @scales[i].size + 1
+      else
+        raise "invalid offset value"
+      end
+    }
+    
+    super(data_type, dim, &block)
+
+    @mid_points = Array.new(rank) { |i|
+      x = (@scales[i] + @scales[i].shifted(-1))/2
+      x[0..-2].to_ca
+    }
+
+    @inner = self[*Array.new(rank) { |i| @offsets[i]..-2 }]
+
+  end
+
+  attr_reader :scales, :include_lowest, :include_upper, :offsets
+  attr_reader :mid_points, :inner
+
+  alias midpoints mid_points
+
+  def increment (*values)
+    idx = Array.new(rank) {|i|
+      vi = CArray.wrap_readonly(values[i], CA_DOUBLE)
+      @scales[i].bin(vi, @include_upper, @include_lowest, @offsets[i]).to_ca
+    }
+    incr_addr(index2addr(*idx))
+    self
+  end
+
+  def add (*values)
+    val = CArray.wrap_readonly(values.pop, self.data_type)
+    sel = val.ne(0)
+    val = val[sel].to_ca
+    idx = Array.new(rank) {|i|
+      vi = CArray.wrap_readonly(values[i], CA_DOUBLE)[sel]
+      @scales[i].bin(vi, @include_upper, @include_lowest, @offsets[i]).to_ca
+    }
+    index2addr(*idx).each_with_addr do |addr, i|
+      self[addr] += val[i]
+    end
+    self
+  end
+
+end
+
+class CArray
+  
+  def bin (val, include_upper, include_lowest, offset=0)
+
+    scales = CArray.wrap_readonly(self, CA_DOUBLE)
+    
+    x = scales.section(val)
+#    x.inherit_mask(val)
+    unless x.is_a?(CArray)
+      x = CA_DOUBLE(x)
+    end
+
+    if include_upper
+      if include_lowest
+        x[:eq, 0] = 0.5
+      end
+      xi = x.ceil.int32 - 1
+    else
+      xi = x.floor.int32 
+    end
+
+    case offset
+    when 0
+      xi[:gt, elements-1] = elements - 1
+      xi[:lt, 0] = UNDEF
+    when 1
+      xi.add!(1)
+      xi[:gt, elements] = elements
+      xi[:lt, 1] = 0
+    else
+      raise "invalid offset value"
+    end
+
+    return xi
+  end
+  
+end
+
+if __FILE__ == $0
+
+  scale = CArray.float(50).span(0..10)
+  hist  = CAHistogram.new([scale, scale])
+
+  x = CArray.float(1000000).randomn!.mul!(3).abs!
+  y = CArray.float(1000000).randomn!.mul!(3).abs!
+
+  hist.increment(x, y)
+
+#  p scale
+#  p hist
+#  p hist.out_of_table
+#  p hist[:i,nil].sum
+
+  CA.gnuplot { |g|
+#    g.image(hist, :title => "2D histogram test")
+    g.grid3d(
+      [scale, scale, hist],
+      :with => "dots",
+      :title => "2D histogram test")
+  }
+
+end

data/lib/carray/math/interp.rb

@@ -0,0 +1,57 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/math/interp.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
+#
+# ----------------------------------------------------------------------------
+
+require "carray"
+
+class CA::Interp
+
+  ADAPTERS = {}
+
+  def initialize (type, scales, value, options={})
+    adapter_class = ADAPTERS[type]
+    if adapter_class
+      @type    = type
+      @adapter = adapter_class.new(scales, value, options)
+    else
+      raise RuntimeError, "unknown interp adapter <#{type}>"
+    end
+  end
+
+  def [] (*args)
+    return @adapter.evaluate(*args)
+  end
+
+  def method_missing (id, *args)
+    return @adapter.send(id, *args)
+  end
+
+end
+
+class CA::Interp::Adapter # :nodoc:
+
+  def self.install_adapter (name)
+    CA::Interp::ADAPTERS[name] = self
+  end
+  
+end
+
+def CA.interp (*argv)
+  return CA::Interp.new(*argv)
+end
+
+CA.each_load_path("carray/math/interp") {
+  Dir["adapter_*.rb"].each do |basename|
+    if basename =~ /\A(adapter_.+)\.rb\Z/
+      require "carray/math/interp/" + $1
+    end
+  end
+}

data/lib/carray/math/interp/adapter_gsl_spline.rb

@@ -0,0 +1,47 @@
+#
+#
+#
+
+#
+# :type => type
+#
+#   * "linear"
+#   * "polynomial"
+#   * "cspline"
+#   * "cspline_periodic"
+#   * "akima"
+#   * "akima_periodic"
+#
+
+require "carray/math/interp"
+begin
+  require "gsl"
+rescue LoadError
+end
+
+class CA::Interp::GSLSpline < CA::Interp::Adapter
+  
+  install_adapter "gsl:spline"
+  
+  def initialize (scales, value, options={})
+    @y  = value
+    @x  = scales
+    type = options[:type] || "linear"
+    CArray.attach(@x, @y) {
+      @interp = GSL::Spline.alloc(type, @x.na, @y.na)
+    }
+  end
+  
+  def evaluate (x0)
+    case x0
+    when CArray
+      return x0.attach { @interp.eval(x0.na).ca }
+    else
+      return @interp.eval(x0)
+    end
+  end
+  
+  alias grid evaluate
+
+end
+

data/lib/carray/math/recurrence.rb

@@ -0,0 +1,95 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/math/recurrence.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
+#
+# ----------------------------------------------------------------------------
+
+require 'carray'
+
+class CARecurrence < CAObject # :nodoc:
+
+  #
+  # init should be a hash like,
+  #  * [0] => 1, [1] => 1 ...
+  #  * [0,0] => 1, [0,1] => 2 ...
+  #
+
+  def initialize (data, init = {}, &block)
+    @value = data
+    @flag = CArray.boolean(*data.dim)
+    @block = block
+    init.each do |idx, val|
+      @value[*idx] = val
+      @flag[*idx] = 1
+    end
+    super(data.data_type, data.dim, :bytes => data.bytes, :read_only => true)
+  end
+
+  def reset (init = {})
+    @flag[] = 0
+    init.each do |idx, val|
+      @value[*idx] = val
+      @flag[*idx] = 1
+    end
+  end
+
+  private
+
+  def fetch_addr (addr)
+    if @flag[addr] == 1
+      return @value[addr]
+    else
+      idx = addr2index(addr)
+      val = @block[@value, *idx]
+      @value[addr] = val
+      @flag[idx] = 1
+      return val
+    end
+  end
+
+  def copy_data (data)
+    each_addr do |addr|
+      fetch_addr(addr)
+    end
+    data[] = @value
+  end
+
+end
+
+class CArray
+
+  def recurrence! (init = {}, &block)
+    lazy = CARecurrence.new(self, init, &block)
+    CArray.attach(lazy) {}
+    return self
+  end
+
+  def recurrence (*argv, &block)
+    return self.template.recurrence!(*argv, &block)
+  end
+
+end
+
+if __FILE__ == $0
+
+  x = 0.5
+  leg = CArray.float(24).recurrence!([0]=>1, [1]=>x) { |a, i|
+    w  = x * a[i-1]
+    wy = w - a[i-2]
+    wy+w-wy/i
+  }
+
+  p leg
+
+  CA.gnuplot { |g|
+    g.plot2d([leg.address, leg, nil, "linespoints"])
+  }
+
+end
+