numo-narray 0.9.0.1-x86-mingw32

data/lib/erbpp.rb

@@ -0,0 +1,286 @@
+require "erb"
+
+class ErbPP
+  ATTRS = []
+
+  class ParamNotSetError < StandardError; end
+
+  def self.define_attrs(attrs)
+    attrs.each do |attr|
+      ivar = ("@"+attr).to_sym
+      define_method(attr){|*a| attr_method(ivar,*a)}
+    end
+  end
+
+  def attr_method(ivar,arg=nil)
+    if arg.nil?
+      instance_variable_get(ivar)
+    else
+      instance_variable_set(ivar,arg)
+    end
+  end
+
+  def initialize(parent,erb_path,opts={})
+    parents.push(parent) if parent
+    @erb_path = erb_path
+    @tmpl = @erb_path
+
+    @opts = opts
+    if @opts.class != Hash
+      raise ArgumentError, "option is not Hash"
+    end
+
+    @opts.each do |k,v|
+      ivar = ("@"+k.to_s).to_sym
+      instance_variable_set(ivar,v)
+    end
+  end
+
+  def load_erb
+    safe_level = nil
+    trim_mode = '%<>'
+    @erb = ERB.new(File.read(@erb_path),safe_level,trim_mode)
+    @erb.filename = @erb_path
+  end
+
+  def parents
+    @parents ||= []
+  end
+
+  def search_method_in_parents(_meth_id)
+    parents.each do |x|
+      if x.has_attr? _meth_id
+        return x
+      end
+    end
+    parents.each do |x|
+      if f = x.search_method_in_parents(_meth_id)
+        return f
+      end
+    end
+    nil
+  end
+
+  def attrs
+    self.class::ATTRS
+  end
+
+  def has_attr?(_meth_id)
+    respond_to?(_meth_id) or attrs.include?(_meth_id.to_s)
+  end
+
+  def check_params(*params)
+    params.each do |x|
+      val = send(x)
+      if !val # || val.empty?
+        raise ParamNotSetError,"parameter #{x.to_s} is not set"
+      end
+    end
+  end
+
+  alias method_missing_alias method_missing
+
+  def method_missing(_meth_id, *args, &block)
+    ivar = "@"+_meth_id.to_s
+    if args.empty? and instance_variable_defined?(ivar)
+      parm = instance_variable_get(ivar)
+      if parm.nil?
+        raise ParamNotSetError,"parameter #{_meth_id.to_s} is not set"
+      end
+      parm
+    elsif args.size == 1 and attrs.include?(_meth_id.to_s)
+      instance_variable_set(ivar,args.first)
+    elsif x = search_method_in_parents(_meth_id)
+      x.send(_meth_id, *args, &block)
+    else
+      method_missing_alias(_meth_id, *args)
+    end
+  end
+
+  def run
+    load_erb unless @erb
+    @erb.run(binding)
+  end
+
+  def result
+    load_erb unless @erb
+    @erb.result(binding)
+  end
+end
+
+# ----------------------------------------------------------------------
+
+class IdVar
+  DEFS = []
+
+  def id_decl
+    "static ID #{@id_var};"
+  end
+
+  def id_assign
+    "#{@id_var} = rb_intern(\"#{@name}\");"
+  end
+
+  def initialize(parent,name,var=nil)
+    @name = name
+    var = name if var.nil?
+    @id_var = "id_"+var.gsub(/\?/,"_p").gsub(/\!/,"_bang")
+    DEFS.push(self)
+  end
+
+  def self.declaration
+    DEFS.map do |x|
+      x.id_decl
+    end
+  end
+
+  def self.assignment
+    DEFS.map do |x|
+      x.id_assign
+    end
+  end
+end
+
+# ----------------------------------------------------------------------
+
+class Function < ErbPP
+  DEFS = []
+
+  attrs = %w[
+    singleton
+    method
+    n_arg
+  ]
+  define_attrs attrs
+
+  def id_op
+    if op.size == 1
+      "'#{op}'"
+    else
+      "id_#{method}"
+    end
+  end
+
+  def initialize(parent,tmpl,**opts)
+    super
+    @aliases = opts[:aliases] || []
+    @erb_path = File.join(parent.tmpl_dir, tmpl+".c")
+    DEFS.push(self)
+  end
+
+  def c_method
+    "#{m_prefix}#{method}"
+  end
+
+  def c_iter
+    begin
+      t = "_"+type_name
+    rescue
+      t = ""
+    end
+    "iter#{t}_#{method}"
+  end
+  alias c_iterator c_iter
+
+  def c_func
+    s = singleton ? "_s" : ""
+    begin
+      t = "_"+type_name
+    rescue
+      t = ""
+    end
+    "numo#{t}#{s}_#{method}"
+  end
+  alias c_function c_func
+  alias c_instance_method c_func
+
+  def op_map
+    @op || method
+  end
+
+  def code
+    result + "\n\n"
+  end
+
+  def definition
+    s = singleton ? "_singleton" : ""
+    check_params(:mod_var, :op_map, :c_func, :n_arg)
+    m = op_map
+    a = ["rb_define#{s}_method(#{mod_var}, \"#{m}\", #{c_func}, #{n_arg});"]
+    @aliases.map{|x| a << "rb_define_alias(#{mod_var}, \"#{x}\", \"#{m}\");"}
+    a
+  end
+
+  def self.codes
+    a = []
+    DEFS.each do |i|
+      x = i.code
+      a.push(x) if x
+    end
+    a
+  end
+
+  def self.definitions
+    a = []
+    DEFS.each do |i|
+      case x = i.definition
+      when Array
+        a.concat(x)
+      when String
+        a.push(x)
+      else
+        raise "unknown definition: #{x}" if x
+      end
+    end
+    a
+  end
+end
+
+class ModuleFunction < Function
+  def definition
+    m = op_map
+    "rb_define_module_function(#{mod_var}, \"#{m}\", #{c_func}, #{n_arg});"
+  end
+end
+
+class NodefFunction < Function
+  def definition
+    nil
+  end
+end
+
+class Alias < ErbPP
+  def initialize(parent, dst, src)
+    super(parent,nil)
+    @dst = dst
+    @src = src
+    Function::DEFS.push(self)
+  end
+
+  def code
+    nil
+  end
+
+  def definition
+    "rb_define_alias(#{mod_var}, \"#{dst}\", \"#{src}\");"
+  end
+end
+
+class Const < ErbPP
+  def initialize(parent,name,value,desc)
+    super(parent,nil)
+    @name = name
+    @value = value
+    @desc = desc
+    Function::DEFS.push(self)
+  end
+
+  def code
+    nil
+  end
+
+  def definition
+    "/*"+desc+"*/\n    "+
+      "rb_define_const(#{mod_var},\"#{name}\",#{value});"
+  end
+end

data/lib/numo/narray.rb

@@ -0,0 +1,6 @@
+begin
+  major, minor, _ = RUBY_VERSION.split(/\./)
+  require "#{major}.#{minor}/numo/narray.so"
+rescue LoadError
+  require "numo/narray.so"
+end

data/numo-narray.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+open("ext/numo/narray/numo/narray.h") do |f|
+  f.each_line do |l|
+    if /NARRAY_VERSION "([\d.]+)"/ =~ l
+      NARRAY_VERSION = $1
+      break
+    end
+  end
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = "numo-narray"
+  spec.version       = NARRAY_VERSION
+  spec.authors       = ["Masahiro TANAKA"]
+  spec.email         = ["masa16.tanaka@gmail.com"]
+  spec.description   = %q{NArray development version.}
+  spec.summary       = %q{NArray development version}
+  spec.homepage      = "https://github.com/ruby-numo/narray"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files Gemfile README.md Rakefile lib ext numo-narray.gemspec spec`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/numo/narray/extconf.rb"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 0"
+  spec.add_development_dependency "rspec", "~> 3"
+  spec.add_development_dependency "rake-compiler", ">= 1.0.1"
+  spec.add_development_dependency "rake-compiler-dock"
+end

data/spec/bit_spec.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), "../ext/numo/narray/narray")
+#Numo::NArray.debug = true
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+end
+#context :focus=>true do ... end
+
+dtype = Numo::Bit
+
+describe dtype do
+  it{expect(dtype).to be < Numo::NArray}
+end
+
+procs = [
+  [proc{|tp,a| tp[*a] },""],
+  [proc{|tp,a| tp[*a][true] },"[true]"],
+  [proc{|tp,a| tp[*a][0..-1] },"[0..-1]"]
+]
+procs.each do |init,ref|
+
+  describe dtype,"[0,1,1,0,1,0,0,1]"+ref do
+    before(:all) do
+      @src = [0,1,1,0,1,0,0,1]
+      @n = @src.size
+      @a = init.call(dtype,@src)
+    end
+
+    it{expect(@a).to eq @src}
+    it{expect(@a & 0).to eq [0]*@n}
+    it{expect(@a & 1).to eq @src}
+    it{expect(@a | 0).to eq @src}
+    it{expect(@a | 1).to eq [1]*@n}
+    it{expect(@a ^ 0).to eq @src.map{|x| x^0}}
+    it{expect(@a ^ 1).to eq @src.map{|x| x^1}}
+    it{expect(~@a).to eq @src.map{|x| 1-x}}
+
+    it{expect(@a.count_true).to eq 4}
+    it{expect(@a.count_false).to eq 4}
+    it{expect(@a.where).to eq [1,2,4,7]}
+    it{expect(@a.where2).to eq [[1,2,4,7],[0,3,5,6]]}
+    it{expect(@a.mask(Numo::DFloat[1,2,3,4,5,6,7,8])).to eq [2,3,5,8]}
+    it{expect(@a).not_to be_all}
+    it{expect(@a).to     be_any}
+    it{expect(@a).not_to be_none}
+
+    after(:all) do
+      @a = nil
+    end
+  end
+
+end
+
+procs = [
+  [proc{|tp,a| tp[*a] },""],
+  [proc{|tp,a| tp[*a][true,0..-1] },"[true,true]"],
+]
+procs.each do |init,ref|
+
+  describe dtype,"[[0,1,1,0],[1,0,0,1]]"+ref do
+    before(:all) do
+      @src = [[0,1,1,0],[1,0,0,1]]
+      @n = @src.size
+      @a = init.call(dtype,@src)
+    end
+
+    it{expect(@a[5]).to eq 0}
+    it{expect(@a[-1]).to eq 1}
+    it{expect(@a[1,0]).to eq @src[1][0]}
+    it{expect(@a[1,1]).to eq @src[1][1]}
+    it{expect(@a[1,2]).to eq @src[1][2]}
+    it{expect(@a[3..4]).to eq [0,1]}
+    it{expect(@a[0,1..2]).to eq [1,1]}
+    it{expect(@a[0,:*]).to eq @src[0]}
+    it{expect(@a[1,:*]).to eq @src[1]}
+    it{expect(@a[:*,1]).to eq [@src[0][1],@src[1][1]]}
+
+    it{expect(@a.count_true).to eq 4}
+    it{expect(@a.count_false).to eq 4}
+    it{expect(@a.where).to eq [1,2,4,7]}
+    it{expect(@a.where2).to eq [[1,2,4,7],[0,3,5,6]]}
+    it{expect(@a.mask(Numo::DFloat[[1,2,3,4],[5,6,7,8]])).to eq [2,3,5,8]}
+    it{expect(@a).not_to be_all}
+    it{expect(@a).to     be_any}
+    it{expect(@a).not_to be_none}
+
+    after(:all) do
+      @a = nil
+    end
+  end
+
+end

data/spec/narray_spec.rb

@@ -0,0 +1,249 @@
+require File.join(File.dirname(__FILE__), "../ext/numo/narray/narray")
+#Numo::NArray.debug = true
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+end
+#context :focus=>true do ... end
+
+types = [
+  Numo::DFloat,
+  Numo::SFloat,
+  Numo::DComplex,
+  Numo::SComplex,
+  Numo::Int64,
+  Numo::Int32,
+  Numo::Int16,
+  Numo::Int8,
+  Numo::UInt64,
+  Numo::UInt32,
+  Numo::UInt16,
+  Numo::UInt8,
+]
+#types = [Numo::DFloat]
+float_types = [
+  Numo::DFloat,
+  Numo::DComplex,
+]
+
+types.each do |dtype|
+
+  describe dtype  do
+    it{expect(dtype).to be < Numo::NArray}
+  end
+
+  procs = [
+    [proc{|tp,a| tp[*a] },""],
+    [proc{|tp,a| tp[*a][true] },"[true]"],
+    [proc{|tp,a| tp[*a][0..-1] },"[0..-1]"]
+  ]
+  procs.each do |init,ref|
+
+    describe dtype,"[1,2,3,5,7,11]"+ref do
+      before(:all) do
+        @src = [1,2,3,5,7,11]
+        @a = init.call(dtype,@src)
+      end
+      #context :focus=>true do
+
+      it{expect(@a).to be_kind_of dtype}
+      it{expect(@a.size).to eq 6}
+      it{expect(@a.ndim).to eq 1}
+      it{expect(@a.shape).to eq [6]}
+      it{expect(@a).not_to be_inplace}
+      it{expect(@a).to     be_row_major}
+      it{expect(@a).not_to be_column_major}
+      it{expect(@a).to     be_host_order}
+      it{expect(@a).not_to be_byte_swapped}
+      it{expect(@a).to eq [1,2,3,5,7,11]}
+      it{expect(@a.to_a).to eq [1,2,3,5,7,11]}
+      it{expect(@a.to_a).to be_kind_of Array}
+      it{expect(@a.dup).to eq @a}
+      it{expect(@a.clone).to eq @a}
+      it{expect(@a.dup.object_id).not_to eq @a.object_id}
+      it{expect(@a.clone.object_id).not_to eq @a.object_id}
+
+      it{expect(@a.eq([1,1,3,3,7,7])).to eq [1,0,1,0,1,0]}
+      it{expect(@a[3..4]).to eq [5,7]}
+      it{expect(@a[5]).to eq 11}
+      it{expect(@a[-1]).to eq 11}
+      it{expect(@a[[4,3,0,1,5,2]]).to eq [7,5,1,2,11,3]}
+      it{expect(@a.sum).to eq 29}
+      if float_types.include?(dtype)
+        it{expect(@a.mean).to eq 29.0/6}
+        it{expect(@a.var).to eq 13.766666666666669}
+        it{expect(@a.stddev).to eq 3.710345895825168}
+        it{expect(@a.rms).to eq 5.901977069875258}
+      end
+      it{expect(@a.copy.fill(12)).to eq [12]*6}
+      it{expect((@a + 1)).to eq [2,3,4,6,8,12]}
+      it{expect((@a - 1)).to eq [0,1,2,4,6,10]}
+      it{expect((@a * 3)).to eq [3,6,9,15,21,33]}
+      it{expect((@a / 0.5)).to eq [2,4,6,10,14,22]}
+      it{expect((-@a)).to eq [-1,-2,-3,-5,-7,-11]}
+      it{expect((@a ** 2)).to eq [1,4,9,25,49,121]}
+      it{expect(@a.swap_byte.swap_byte).to eq [1,2,3,5,7,11]}
+      if dtype == Numo::DComplex || dtype == Numo::SComplex
+        it{expect(@a.real).to eq @src}
+        it{expect(@a.imag).to eq [0]*6}
+        it{expect(@a.conj).to eq @src}
+        it{expect(@a.angle).to eq [0]*6}
+      else
+        it{expect(@a.min).to eq 1}
+        it{expect(@a.max).to eq 11}
+        it{expect((@a >= 3)).to eq [0,0,1,1,1,1]}
+        it{expect((@a >  3)).to eq [0,0,0,1,1,1]}
+        it{expect((@a <= 3)).to eq [1,1,1,0,0,0]}
+        it{expect((@a <  3)).to eq [1,1,0,0,0,0]}
+        it{expect((@a.eq 3)).to eq [0,0,1,0,0,0]}
+        it{expect(@a.sort).to eq @src}
+        it{expect(@a.sort_index).to eq (0..5).to_a}
+        it{expect(@a.median).to eq 4}
+      end
+    end
+  end
+
+  describe dtype, '[1..4]' do
+    it{expect(dtype[1..4]).to eq [1,2,3,4]}
+  end
+
+  #describe dtype, ".seq(5)" do
+  #  it do
+  #    dtype.seq(5).should == [0,1,2,3,4]
+  #  end
+  #end
+
+  procs2 = [
+    [proc{|tp,src| tp[*src] },""],
+    [proc{|tp,src| tp[*src][true,true] },"[true,true]"],
+    [proc{|tp,src| tp[*src][0..-1,0..-1] },"[0..-1,0..-1]"]
+  ]
+  procs2.each do |init,ref|
+
+    describe dtype,'[[1,2,3],[5,7,11]]'+ref do
+      before(:all) do
+        @src = [[1,2,3],[5,7,11]]
+        @a = init.call(dtype,@src)
+      end
+      #context :focus=>true do
+
+      it{expect(@a).to be_kind_of dtype}
+      it{expect(@a.size).to eq 6}
+      it{expect(@a.ndim).to eq 2}
+      it{expect(@a.shape).to eq [2,3]}
+      it{expect(@a).not_to be_inplace}
+      it{expect(@a).to     be_row_major}
+      it{expect(@a).not_to be_column_major}
+      it{expect(@a).to     be_host_order}
+      it{expect(@a).not_to be_byte_swapped}
+      it{expect(@a).to eq @src}
+      it{expect(@a.to_a).to eq @src}
+      it{expect(@a.to_a).to be_kind_of Array}
+
+      it{expect(@a.eq([[1,1,3],[3,7,7]])).to eq [[1,0,1],[0,1,0]]}
+      it{expect(@a[5]).to eq 11}
+      it{expect(@a[-1]).to eq 11}
+      it{expect(@a[1,0]).to eq @src[1][0]}
+      it{expect(@a[1,1]).to eq @src[1][1]}
+      it{expect(@a[1,2]).to eq @src[1][2]}
+      it{expect(@a[3..4]).to eq [5,7]}
+      it{expect(@a[0,1..2]).to eq [2,3]}
+      it{expect(@a[0,:*]).to eq @src[0]}
+      it{expect(@a[1,:*]).to eq @src[1]}
+      it{expect(@a[:*,1]).to eq [@src[0][1],@src[1][1]]}
+      it{expect(@a[true,[2,0,1]]).to eq [[3,1,2],[11,5,7]]}
+      it{expect(@a.reshape(3,2)).to eq [[1,2],[3,5],[7,11]]}
+      it{expect(@a.reshape(3,nil)).to eq [[1,2],[3,5],[7,11]]}
+      it{expect(@a.reshape(nil,2)).to eq [[1,2],[3,5],[7,11]]}
+      it{expect(@a.transpose).to eq [[1,5],[2,7],[3,11]]}
+      it{expect(@a.transpose(1,0)).to eq [[1,5],[2,7],[3,11]]}
+
+      it{expect(@a.sum).to eq 29}
+      it{expect(@a.sum(0)).to eq [6, 9, 14]}
+      it{expect(@a.sum(1)).to eq [6, 23]}
+      if float_types.include?(dtype)
+        it{expect(@a.mean).to eq 29.0/6}
+        it{expect(@a.mean(0)).to eq [3, 4.5, 7]}
+        it{expect(@a.mean(1)).to eq [2, 23.0/3]}
+      end
+      if dtype == Numo::DComplex || dtype == Numo::SComplex
+        it{expect(@a.real).to eq @src}
+        it{expect(@a.imag).to eq [[0]*3]*2}
+        it{expect(@a.conj).to eq @src}
+        it{expect(@a.angle).to eq [[0]*3]*2}
+      else
+        it{expect(@a.min).to eq 1}
+        it{expect(@a.max).to eq 11}
+        it{expect((@a >= 3)).to eq [[0,0,1],[1,1,1]]}
+        it{expect((@a >  3)).to eq [[0,0,0],[1,1,1]]}
+        it{expect((@a <= 3)).to eq [[1,1,1],[0,0,0]]}
+        it{expect((@a <  3)).to eq [[1,1,0],[0,0,0]]}
+        it{expect((@a.eq 3)).to eq [[0,0,1],[0,0,0]]}
+        it{expect(@a.sort).to eq @src}
+        it{expect(@a.sort_index).to eq [[0,1,2],[3,4,5]]}
+      end
+      it{expect(@a.copy.fill(12)).to eq [[12]*3]*2}
+      it{expect((@a + 1)).to eq [[2,3,4],[6,8,12]]}
+      it{expect((@a + [1,2,3])).to eq [[2,4,6],[6,9,14]]}
+      it{expect((@a - 1)).to eq [[0,1,2],[4,6,10]]}
+      it{expect((@a - [1,2,3])).to eq [[0,0,0],[4,5,8]]}
+      it{expect((@a * 3)).to eq [[3,6,9],[15,21,33]]}
+      it{expect((@a * [1,2,3])).to eq [[1,4,9],[5,14,33]]}
+      it{expect((@a / 0.5)).to eq [[2,4,6],[10,14,22]]}
+      it{expect((-@a)).to eq [[-1,-2,-3],[-5,-7,-11]]}
+      it{expect((@a ** 2)).to eq [[1,4,9],[25,49,121]]}
+      it{expect((dtype[[1,0],[0,1]].dot dtype[[4,1],[2,2]])).to eq [[4,1],[2,2]]}
+      it{expect(@a.swap_byte.swap_byte).to eq @src}
+    end
+
+  end
+
+  describe dtype,"[[[1,2],[3,4]],[[5,6],[7,8]]]" do
+    before do
+      @a = dtype[[[1,2],[3,4]],[[5,6],[7,8]]]
+    end
+
+    it{expect(@a[0, 1, 1]).to eq 4}
+    #it{expect(@a[:rest]).to eq @a} # note: this spec probably shows the correct behaviour
+    it{expect(@a[0, :rest]).to eq [[1,2],[3,4]]}
+    it{expect(@a[0, false]).to eq [[1,2],[3,4]]}
+    it{expect(@a[0, 1, :rest]).to eq [3,4]}
+    it{expect(@a[0, 1, false]).to eq [3,4]}
+    it{expect(@a[:rest, 0]).to eq [[1,3],[5,7]]}
+    it{expect(@a[:rest, 0, 1]).to eq [2,6]}
+    it{expect(@a[1, :rest, 0]).to eq [5,7]}
+    it{expect{@a[1, 1, :rest, 0]}.to raise_error IndexError}
+    it{expect{@a[1, 1, 1, 1, :rest]}.to raise_error IndexError}
+    it{expect{@a[1, 1, 1, :rest, 1]}.to raise_error IndexError}
+  end
+
+  describe dtype, "#dot" do
+    it "vector.dot(vector)" do
+      a = dtype[1..3]
+      b = dtype[2..4]
+      expect(a.dot(b)).to eq (1*2 + 2*3 + 3*4)
+    end
+    it "matrix.dot(vector)" do
+      a = dtype[1..6].reshape(3,2)
+      b = dtype[1..2]
+      expect(a.dot(b)).to eq [5, 11, 17]
+    end
+    it "vector.dot(matrix)" do
+      a = dtype[1..2]
+      b = dtype[1..6].reshape(2,3)
+      expect(a.dot(b)).to eq [9, 12, 15]
+    end
+    it "matrix.dot(matrix)" do
+      a = dtype[1..6].reshape(3,2)
+      b = dtype[1..6].reshape(2,3)
+      expect(a.dot(b)).to eq [[9, 12, 15], [19, 26, 33], [29, 40, 51]]
+      expect(b.dot(a)).to eq [[22, 28], [49, 64]]
+    end
+    it "matrix.dot(matrix) with incorrect shape" do
+      a = dtype[1..6].reshape(3,2)
+      b = dtype[1..9].reshape(3,3)
+      expect{a.dot(b)}.to raise_error(TypeError)
+    end
+  end
+end