numo-narray 0.9.0.4 → 0.9.0.5

data/ext/numo/narray/gen/def/uint32.rb

@@ -1,16 +1,20 @@
-class_name    "UInt32"
-ctype         "u_int32_t"
+set name:                "uint32"
+set type_name:           "uint32"
+set full_class_name:     "Numo::UInt32"
+set class_name:          "UInt32"
+set class_var:           "cT"
+set ctype:               "u_int32_t"
 
-has_math      false
-is_bit        false
-is_int        true
-is_unsigned   true
-is_float      false
-is_complex    false
-is_object     false
-is_real       true
-is_comparable true
-is_double_precision false
+set has_math:            false
+set is_bit:              false
+set is_int:              true
+set is_unsigned:         true
+set is_float:            false
+set is_complex:          false
+set is_object:           false
+set is_real:             true
+set is_comparable:       true
+set is_double_precision: false
 
 upcast_rb "Integer"
 upcast_rb "Float", "DFloat"

data/ext/numo/narray/gen/def/uint64.rb

@@ -1,16 +1,20 @@
-class_name    "UInt64"
-ctype         "u_int64_t"
+set name:                "uint64"
+set type_name:           "uint64"
+set full_class_name:     "Numo::UInt64"
+set class_name:          "UInt64"
+set class_var:           "cT"
+set ctype:               "u_int64_t"
 
-has_math      false
-is_bit        false
-is_int        true
-is_unsigned   true
-is_float      false
-is_complex    false
-is_object     false
-is_real       true
-is_comparable true
-is_double_precision false
+set has_math:            false
+set is_bit:              false
+set is_int:              true
+set is_unsigned:         true
+set is_float:            false
+set is_complex:          false
+set is_object:           false
+set is_real:             true
+set is_comparable:       true
+set is_double_precision: false
 
 upcast_rb "Integer"
 upcast_rb "Float", "DFloat"

data/ext/numo/narray/gen/def/uint8.rb

@@ -1,16 +1,20 @@
-class_name    "UInt8"
-ctype         "u_int8_t"
+set name:                "uint8"
+set type_name:           "uint8"
+set full_class_name:     "Numo::UInt8"
+set class_name:          "UInt8"
+set class_var:           "cT"
+set ctype:               "u_int8_t"
 
-has_math      false
-is_bit        false
-is_int        true
-is_unsigned   true
-is_float      false
-is_complex    false
-is_object     false
-is_real       true
-is_comparable true
-is_double_precision false
+set has_math:            false
+set is_bit:              false
+set is_int:              true
+set is_unsigned:         true
+set is_float:            false
+set is_complex:          false
+set is_object:           false
+set is_real:             true
+set is_comparable:       true
+set is_double_precision: false
 
 upcast_rb "Integer"
 upcast_rb "Float", "DFloat"

data/ext/numo/narray/gen/erbpp2.rb

@@ -0,0 +1,324 @@
+require "erb"
+
+class ErbPP
+
+  def initialize(parent=nil, erb_base=nil, **opts, &block)
+    @parent = parent
+    @children = []
+    @opts = opts
+    set erb_base: erb_base if erb_base
+    @parent.add_child(self) if @parent
+    instance_eval(&block) if block
+  end
+
+  attr_reader :children
+  attr_accessor :parent
+
+  def add_child(child)
+    @children.push(child)
+  end
+
+  def set(**opts)
+    @opts.merge!(opts)
+  end
+
+  def get(key, *args, &block)
+    if respond_to?(key)
+      return send(key, *args, &block)
+    end
+    if args.empty? && block.nil? && @opts.has_key?(key)
+      return @opts[key]
+    end
+    if @parent
+      return @parent.get(key, *args, &block)
+    end
+    nil
+  end
+
+  def description
+    if s = @opts[:description] || @opts[:desc]
+      s.gsub(/\@\{/,"[").gsub(/\@\}/,"]")
+    end
+  end
+
+  alias desc description
+
+  alias method_missing_alias method_missing
+
+  def method_missing(_meth_id, *args, &block)
+    if args.empty?
+      #$stderr.puts _meth_id.inspect
+      v = get(_meth_id, *args, &block)
+      return v if !v.nil?
+    end
+    method_missing_alias(_meth_id, *args, &block)
+  end
+
+  # ERB Loader
+
+  def load_erb(base_name)
+    safe_level = nil
+    trim_mode = '%<>'
+    file = base_name + get(:erb_suffix)
+    dirs = get(:erb_dir)
+    dirs = [dirs] if !dirs.kind_of?(Array)
+    dirs.each do |x|
+      Dir.glob(x).each do |dir|
+        path = File.join(dir,file)
+        if File.exist?(path)
+          erb = ERB.new(File.read(path), safe_level, trim_mode)
+          erb.filename = path
+          return erb
+        end
+      end
+    end
+    raise "file not found: #{file.inspect} in #{dirs.inspect}"
+  end
+
+  def run
+    if base = @opts[:erb_base]
+      load_erb(base).run(binding)
+    end
+  end
+
+  def result
+    if base = @opts[:erb_base]
+      load_erb(base).result(binding)
+    end
+  end
+
+  def write(output)
+    File.open(output,"wt") do |f|
+      f.print(result)
+    end
+  end
+
+  def init_def
+  end
+
+  def find_tmpl(name)
+    @parent.children.find{|x| x.name == name }
+  end
+
+  def find(name)
+    children.find{|x| x.name == name }
+  end
+end
+
+
+class DefLib < ErbPP
+  def initialize(parent=nil, **opts, &block)
+    opts[:erb_base] ||= 'lib'
+    super(parent, **opts, &block)
+  end
+  def id_assign
+    ids = []
+    @children.each{|c| a=c.get(:id_list); ids.concat(a) if a}
+    ids.sort.uniq.map{|x| "id_#{x[1]} = rb_intern(\"#{x[0]}\");"}
+  end
+  def id_decl
+    ids = []
+    @children.each{|c| a=c.get(:id_list); ids.concat(a) if a}
+    ids.sort.uniq.map{|x| "static ID id_#{x[1]};\n"}
+  end
+  def def_class(**opts, &block)
+    DefClass.new(self, **opts, &block)
+  end
+  def def_module(**opts, &block)
+    DefModule.new(self, **opts, &block)
+  end
+end
+
+module DeclMethod
+  def def_alloc_func(m, erb_path=nil, **opts, &block)
+    DefAllocFunc.new(self, erb_path||m, name:m, singleton:true, **opts, &block)
+  end
+  def undef_alloc_func
+    UndefAllocFunc.new(self)
+  end
+  def def_method(m, erb_path=nil, **opts, &block)
+    DefMethod.new(self, erb_path||m, name:m, **opts, &block)
+  end
+  def undef_method(m)
+    UndefMethod.new(self,name:m)
+  end
+  def def_singleton_method(m, erb_path=nil, **opts, &block)
+    DefMethod.new(self, erb_path||m, name:m, singleton:true, **opts, &block)
+  end
+  def undef_singleton_method(m)
+    UndefSingletonMethod.new(self,name:m)
+  end
+  def def_module_function(m, erb_path=nil, **opts, &block)
+    DefModuleFunction.new(self, erb_path||m, name:m, **opts, &block)
+  end
+  def def_alias(from, to)
+    DefAlias.new(self, from:from, to:to)
+  end
+  def def_const(m, v, **opts, &block)
+    DefConst.new(self, name:m, value:v, **opts, &block)
+  end
+end
+
+class DefModule < ErbPP
+  include DeclMethod
+  def initialize(parent, **opts, &block)
+    eb = opts[:erb_base] || 'module'
+    super(parent, erb_base:eb, **opts, &block)
+  end
+  def id_list
+    @id_list ||= []
+  end
+  def def_id(name,var=nil)
+    var = name.gsub(/\?/,"_p").gsub(/\!/,"_bang") if var.nil?
+    id_list << [name,var]
+  end
+  def init_def
+    load_erb(init_erb).result(binding)
+  end
+  def init_erb
+    @opts[:init_erb] || "init_module"
+  end
+  def method_code
+    @children.map{|c| c.result}.join("\n")
+  end
+  def _mod_var
+    @opts[:module_var]
+  end
+end
+
+class DefClass < DefModule
+  def initialize(parent, **opts, &block)
+    eb = opts[:erb_base] || 'class'
+    super(parent, erb_base:eb, **opts, &block)
+  end
+  def _mod_var
+    @opts[:class_var]
+  end
+  def init_erb
+    @opts[:init_erb] || "init_class"
+  end
+  def super_class
+    @opts[:super_class] || "rb_cObject"
+  end
+  def free_func
+    @opts[:free_func] || "gsl_"+get(:name)+"_free"
+  end
+end
+
+class DefMethod < ErbPP
+  include DeclMethod
+
+  def initialize(parent, erb_base, **opts, &block)
+    super(parent, **opts, &block)
+    set erb_base: erb_base
+  end
+
+  def id_op
+    if op.size == 1
+      "'#{op}'"
+    else
+      "id_#{c_name}"
+    end
+  end
+
+  def c_name
+    @opts[:name].gsub(/\?/,"_p").gsub(/\!/,"_bang")
+  end
+
+  def op_map
+    @opts[:op] || @opts[:name]
+  end
+
+  def c_func(n_arg=nil)
+    set n_arg: n_arg if n_arg
+    s = (singleton) ? "_s" : ""
+    "#{@parent.name}#{s}_#{c_name}"
+  end
+
+  def c_iter
+    "iter_#{c_func}"
+  end
+
+  def define_method_args
+    "#{_mod_var}, \"#{op_map}\", #{c_func}, #{n_arg}"
+  end
+
+  def init_def
+    return if n_arg == :nodef
+    s = (singleton) ? "_singleton" : ""
+    "rb_define#{s}_method(#{define_method_args});"
+  end
+
+  def singleton
+    @opts[:singleton]
+  end
+end
+
+class DefModuleFunction < DefMethod
+  def initialize(parent, erb_base, **opts, &block)
+    super(parent, erb_base, **opts, &block)
+    set singleton: true
+  end
+
+  def init_def
+    return if n_arg == :nodef
+    "rb_define_module_function(#{define_method_args});"
+  end
+end
+
+class DefAlias < ErbPP
+  def init_def
+    "rb_define_alias(#{_mod_var}, \"#{from}\", \"#{to}\");"
+  end
+end
+
+class DefAllocFunc < DefMethod
+  def init_def
+    "rb_define_alloc_func(#{_mod_var}, #{c_func});"
+  end
+end
+
+class UndefAllocFunc < ErbPP
+  def init_def
+    "rb_undef_alloc_func(#{_mod_var});"
+  end
+end
+
+class UndefMethod < ErbPP
+  def init_def
+    "rb_undef_method(#{_mod_var},\"#{name}\");"
+  end
+end
+
+class UndefSingletonMethod < ErbPP
+  def init_def
+    "rb_undef_method(rb_singleton_class(#{_mod_var}),\"#{name}\");"
+  end
+end
+
+class DefConst < ErbPP
+  def init_def
+    "/*#{desc}*/
+    rb_define_const(#{_mod_var},\"#{name}\",#{value});"
+  end
+end
+
+class DefStruct < ErbPP
+  def method_code
+    "static VALUE #{class_var};"
+  end
+  def init_def
+    items = members.map{|s| "\"#{s}\""}.join(",")
+    "/*#{description}*/
+    #{class_var} = rb_struct_define(\"#{class_name}\",#{items},NULL);"
+  end
+end
+
+class DefInclueModule < ErbPP
+  def initialize(parent=nil, incl_class, incl_module, **opts, &block)
+    super(parent,incl_class:incl_class,incl_module:incl_module,**opts,&block)
+  end
+  def init_def
+    "rb_include_module(#{get(:incl_class)}, #{get(:incl_module)});"
+  end
+end

data/ext/numo/narray/gen/narray_def.rb

@@ -0,0 +1,252 @@
+require_relative './erbpp2'
+
+module NArrayMethod
+
+  def binary(meth, ope=nil)
+    ope = meth if ope.nil?
+    def_method(meth, "binary", op:ope)
+  end
+
+  def binary2(meth, ope=nil)
+    ope = meth if ope.nil?
+    def_method(meth, "binary2", op:ope)
+  end
+
+  def unary(meth, ope=nil)
+    def_method(meth, "unary", op:ope)
+  end
+
+  def pow
+    def_method("pow", "pow", op:"**")
+  end
+
+  def unary2(meth, dtype, tpclass)
+    h = {dtype:dtype, tpclass:tpclass}
+    def_method(meth, "unary2", **h)
+  end
+
+  def set2(meth, dtype, tpclass)
+    h = {dtype:dtype, tpclass:tpclass}
+    def_method(meth, "set2", h)
+  end
+
+  def cond_binary(meth,op=nil)
+    op = meth unless op
+    def_method(meth, "cond_binary", op:op)
+  end
+
+  def cond_unary(meth)
+    def_method(meth, "cond_unary")
+  end
+
+  def bit_count(meth)
+    def_method(meth, "bit_count")
+  end
+
+  def bit_reduce(meth, init_bit)
+    h = {init_bit:init_bit}
+    def_method(meth, "bit_reduce", **h)
+  end
+
+  def accum(meth, dtype, tpclass)
+    h = {dtype:dtype, tpclass:tpclass}
+    def_method(meth, "accum", **h)
+  end
+
+  def accum_index(meth)
+    def_method(meth, "accum_index")
+  end
+
+  def cum(meth, cmacro)
+    def_method(meth, "cum", cmacro:cmacro)
+  end
+
+  def accum_binary(meth, ope=nil)
+    ope = meth if ope.nil?
+    def_method(meth, "accum_binary", op:ope)
+  end
+
+  def qsort(type_name, dtype, dcast, suffix="")
+    h = {type_name:type_name, dtype:dtype, dcast:dcast, suffix:suffix}
+    def_method("qsort", **h)
+  end
+end
+
+module NMathMethod
+
+  def math(meth, n=1, tmpl=nil, **h)
+    if tmpl.nil?
+      case n
+      when 1
+        tmpl = "unary_s"
+      when 2
+        tmpl = "binary_s"
+      when 3
+        tmpl = "ternary_s"
+      else
+        raise "invalid n=#{n}"
+      end
+    end
+    def_module_function(meth, tmpl, **h)
+  end
+end
+
+# ----------------------------------------------------------------------
+
+module NArrayType
+
+  def type_name
+    @opts[:type_name] ||= class_name.downcase
+  end
+  alias tp type_name
+
+  def type_var
+    @opts[:type_var] ||= "numo_c"+class_name
+  end
+
+  def math_var
+    @opts[:math_var] ||= "numo_m"+class_name+"Math"
+  end
+
+  def real_class_name(arg=nil)
+    if arg.nil?
+      @opts[:real_class_name] ||= class_name
+    else
+      @opts[:real_class_name] = arg
+    end
+  end
+
+  def real_ctype(arg=nil)
+    if arg.nil?
+      @opts[:real_ctype] ||= ctype
+    else
+      @opts[:real_ctype] = arg
+    end
+  end
+
+  def real_type_var
+    @opts[:real_type_var] ||= "numo_c"+real_class_name
+  end
+
+  def real_type_name
+    @opts[:real_type_name] ||= real_class_name.downcase
+  end
+
+  def class_alias(*args)
+    case a = @opts[:class_alias]
+    when Array
+    when nil
+      a = @opts[:class_alias] = []
+    else
+      a = @opts[:class_alias] = [a]
+    end
+    a.concat(args)
+  end
+
+  def upcast(c=nil,t=nil)
+    @opts[:upcast] ||= []
+    if c
+      if t
+        t = "numo_c#{t}"
+      else
+        t = "cT"
+      end
+      @opts[:upcast] << "rb_hash_aset(hCast, numo_c#{c}, #{t});"
+    else
+      @opts[:upcast]
+    end
+  end
+
+  def upcast_rb(c,t=nil)
+    @opts[:upcast] ||= []
+    if t
+      t = "numo_c#{t}"
+    else
+      t = "cT"
+    end
+    if c=="Integer"
+      @opts[:upcast] << "#ifdef RUBY_INTEGER_UNIFICATION"
+      @opts[:upcast] << "rb_hash_aset(hCast, rb_cInteger, #{t});"
+      @opts[:upcast] << "#else"
+      @opts[:upcast] << "rb_hash_aset(hCast, rb_cFixnum, #{t});"
+      @opts[:upcast] << "rb_hash_aset(hCast, rb_cBignum, #{t});"
+      @opts[:upcast] << "#endif"
+    else
+      @opts[:upcast] << "rb_hash_aset(hCast, rb_c#{c}, #{t});"
+    end
+  end
+end
+
+# ----------------------------------------------------------------------
+
+module StoreFrom
+
+  def store_from(cname, dtype=nil, macro=nil)
+    tmpl = (cname=="Bit") ? "store_bit" : "store_from"
+    h = { name:cname.downcase,
+          type_name:cname,
+          type_var:"numo_c"+cname,
+          dtype:dtype,
+          macro:macro }
+    Store.new(self, tmpl, **h)
+  end
+
+  def store_numeric
+    StoreNum.new(self, "store_numeric", name:"numeric")
+  end
+
+  def store_array
+    StoreArray.new(self, "store_array", name:"array")
+  end
+
+  def definitions
+    a = []
+    @children.each do |x|
+      if x.condition("")
+        if x.get(:type_name) == parent.class_name
+          a.unshift(x)
+        else
+          a.push(x)
+        end
+      end
+    end
+    a
+  end
+end
+
+# ----------------------------------------------------------------------
+
+class Store < DefMethod
+  def c_func(n=nil)
+    "#{parent.parent.name}_store_#{name}"
+  end
+
+  def condition(klass)
+    "#{klass}==#{type_var}"
+  end
+
+  def extract_data(ptr,pos,x)
+    case type_name
+    when "Bit"
+      "{BIT_DIGIT b; LOAD_BIT(#{ptr},#{pos},b); x = m_from_real(b);}"
+    when "RObject"
+      "#{x} = m_num_to_data(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /Complex/
+      "{#{dtype} *p = (#{dtype}*)(#{ptr}+#{pos}); #{x} = c_new(REAL(*p),IMAG(*p));}"
+    else
+      "#{x} = m_from_real(*(#{dtype}*)(#{ptr}+#{pos}))"
+    end
+  end
+end
+
+class StoreNum < Store
+  def condition(klass)
+    "IS_INTEGER_CLASS(#{klass}) || #{klass}==rb_cFloat || #{klass}==rb_cComplex"
+  end
+end
+
+class StoreArray < Store
+  def condition(klass)
+    "#{klass}==rb_cArray"
+  end
+end