cumo 0.1.0

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

@@ -0,0 +1,268 @@
+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, result_class)
+    h = {dtype:dtype, result_class:result_class}
+    def_method(meth, "unary2", **h)
+  end
+
+  def set2(meth, dtype, result_class)
+    h = {dtype:dtype, result_class:result_class}
+    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_count_cpu(meth)
+    def_method(meth, "bit_count_cpu")
+  end
+
+  def bit_reduce(meth, init_bit)
+    h = {init_bit:init_bit}
+    def_method(meth, "bit_reduce", **h)
+  end
+
+  def accum(meth, dtype, result_class)
+    h = {dtype:dtype, result_class:result_class}
+    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] ||= "cumo_c"+class_name
+  end
+
+  def math_var
+    @opts[:math_var] ||= "cumo_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] ||= "cumo_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 = "cumo_c#{t}"
+      else
+        t = "cT"
+      end
+      @opts[:upcast] << "rb_hash_aset(hCast, cumo_c#{c}, #{t});"
+    else
+      @opts[:upcast]
+    end
+  end
+
+  def upcast_rb(c,t=nil)
+    @opts[:upcast] ||= []
+    if t
+      t = "cumo_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:"cumo_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_sint(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));}"
+    when /Float/
+      "#{x} = m_from_real(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /UInt64/
+      "#{x} = m_from_uint64(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /UInt32/
+      "#{x} = m_from_uint32(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /Int64/
+      "#{x} = m_from_int64(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /Int32/
+      "#{x} = m_from_int32(*(#{dtype}*)(#{ptr}+#{pos}))"
+    when /Int/
+      "#{x} = m_from_sint(*(#{dtype}*)(#{ptr}+#{pos}))"
+    else
+      raise "unknown type: #{type_name}"
+    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

data/ext/cumo/narray/gen/spec.rb

@@ -0,0 +1,425 @@
+def_id "cast"
+def_id "eq"
+def_id "ne"
+def_id "pow"
+def_id "mulsum"
+if is_complex
+  def_id "real"
+  def_id "imag"
+else
+  def_id "divmod"
+end
+if is_float
+  def_id "nearly_eq"
+  def_id "copysign"
+end
+if is_int
+  def_id "<<","left_shift"
+  def_id ">>","right_shift"
+end
+if is_comparable && !is_object
+  def_id "gt"
+  def_id "ge"
+  def_id "lt"
+  def_id "le"
+end
+if is_comparable
+  def_id "nan"
+end
+if is_object
+  def_id "bit_and"
+  def_id "bit_or"
+  def_id "bit_xor"
+  def_id "bit_not"
+  def_id "abs"
+  def_id "minus"
+  def_id "reciprocal"
+  def_id "square"
+  def_id "floor"
+  def_id "round"
+  def_id "ceil"
+  def_id "truncate"
+  def_id "nan?"
+  def_id "infinite?"
+  def_id "finite?"
+  def_id "==","eq"
+  def_id "!=","ne"
+  def_id ">" ,"gt"
+  def_id ">=","ge"
+  def_id "<" ,"lt"
+  def_id "<=","le"
+  def_id "<=>","ufo"
+end
+if (is_float || is_complex) && !is_object
+  def_id "gemm"
+end
+
+if is_int && !is_object
+  def_id "minlength" # for bincount
+end
+
+# Constatnts
+
+if is_bit
+  def_const "ELEMENT_BIT_SIZE",  "INT2FIX(1)"
+  def_const "ELEMENT_BYTE_SIZE", "rb_float_new(1.0/8)"
+  def_const "CONTIGUOUS_STRIDE", "INT2FIX(1)"
+else
+  def_const "ELEMENT_BIT_SIZE",  "INT2FIX(sizeof(dtype)*8)"
+  def_const "ELEMENT_BYTE_SIZE", "INT2FIX(sizeof(dtype))"
+  def_const "CONTIGUOUS_STRIDE", "INT2FIX(sizeof(dtype))"
+end
+
+if !is_object
+  if is_float
+    def_const "EPSILON", "M_EPSILON"
+  end
+  if is_float || is_int
+    def_const "MAX", "M_MAX"
+    def_const "MIN", "M_MIN"
+  end
+end
+
+# Un-define
+
+if is_object
+  undef_singleton_method "from_binary"
+  undef_method "to_binary"
+  undef_method "swap_byte"
+  undef_method "to_network"
+  undef_method "to_vacs"
+  undef_method "to_host"
+  undef_method "to_swapped"
+end
+
+# Allocation
+
+def_alloc_func "alloc_func"
+def_method "allocate"
+
+# Type conversion
+
+def_method "extract"
+def_method "extract_cpu"
+def_method "new_dim0"
+
+def_method "store" do
+  extend StoreFrom
+  store_numeric
+  store_from "Bit"
+  if is_complex
+    store_from "DComplex","dcomplex","m_from_dcomplex"
+    store_from "SComplex","scomplex","m_from_scomplex"
+  end
+  store_from "DFloat","double",   "m_from_real"
+  store_from "SFloat","float",    "m_from_real"
+  store_from "Int64", "int64_t",  "m_from_int64"
+  store_from "Int32", "int32_t",  "m_from_int32"
+  store_from "Int16", "int16_t",  "m_from_sint"
+  store_from "Int8",  "int8_t",   "m_from_sint"
+  store_from "UInt64","u_int64_t","m_from_uint64"
+  store_from "UInt32","u_int32_t","m_from_uint32"
+  store_from "UInt16","u_int16_t","m_from_sint"
+  store_from "UInt8", "u_int8_t", "m_from_sint"
+  store_from "RObject", "VALUE",  "m_num_to_data"
+  store_array
+end
+
+def_method "extract_data"
+
+def_method "cast_array"
+def_singleton_method "cast"
+
+def_method "aref", op:"[]"
+def_method "aref_cpu"
+def_method "aset", op:"[]="
+
+def_method "coerce_cast"
+def_method "to_a"
+def_method "fill"
+def_method "format"
+def_method "format_to_a"
+def_method "inspect"
+
+
+# Array manipulation
+
+def_method "each"
+unary "map" if !is_bit
+def_method "each_with_index"
+
+if is_bit
+  unary  "copy"
+  unary  "not", "~"
+  binary "and", "&"
+  binary "or" , "|"
+  binary "xor", "^"
+  binary "eq"
+  bit_count "count_true"
+  def_alias "count_1","count_true"
+  def_alias "count","count_true"
+  bit_count "count_false"
+  def_alias "count_0","count_false"
+  bit_count_cpu "count_true_cpu"
+  def_alias "count_1_cpu","count_true_cpu"
+  def_alias "count_cpu","count_true_cpu"
+  bit_count_cpu "count_false_cpu"
+  def_alias "count_0_cpu","count_false_cpu"
+  bit_reduce "all?", 1
+  bit_reduce "any?", 0
+  def_method "none?", "none_p"
+  def_method "where"
+  def_method "where2"
+  def_method "mask"
+else
+
+def_method "map_with_index"
+
+# Arithmetic
+
+unary2 "abs", "rtype", "cRT"
+
+binary "add", "+"
+binary "sub", "-"
+binary "mul", "*"
+binary "div", "/"
+
+if !is_complex
+  binary "mod", "%"
+  binary2 "divmod"
+end
+
+pow
+
+unary "minus", "-@"
+unary "reciprocal"
+unary "sign"
+unary "square"
+
+# Complex
+
+if is_complex
+  unary "conj"
+  unary "im"
+  unary2 "real", "rtype", "cRT"
+  unary2 "imag", "rtype", "cRT"
+  unary2 "arg",  "rtype", "cRT"
+  def_alias "angle","arg"
+  set2 "set_imag", "rtype", "cRT"
+  set2 "set_real", "rtype", "cRT"
+  def_alias "imag=","set_imag"
+  def_alias "real=","set_real"
+else
+  def_alias "conj", "view"
+  def_alias "im", "view"
+end
+
+def_alias "conjugate","conj"
+
+# base_cond
+
+cond_binary "eq"
+cond_binary "ne"
+
+# nearly_eq  : x=~y is true if |x-y| <= (|x|+|y|)*epsilon
+if is_float
+  cond_binary "nearly_eq"
+else
+  def_alias "nearly_eq", "eq"
+end
+def_alias "close_to", "nearly_eq"
+
+# Integer
+if is_int
+  binary "bit_and", "&"
+  binary "bit_or" , "|"
+  binary "bit_xor", "^"
+  unary  "bit_not", "~"
+  binary "left_shift", "<<"
+  binary "right_shift", ">>"
+  if !is_object
+    def_alias "floor", "view"
+    def_alias "round", "view"
+    def_alias "ceil",  "view"
+    def_alias "trunc", "view"
+    def_alias "rint",  "view"
+  end
+end
+
+if is_float
+  unary "floor"
+  unary "round"
+  unary "ceil"
+  unary "trunc"
+  if !is_object
+    unary "rint"
+    binary "copysign"
+    if !is_complex
+      cond_unary "signbit"
+      def_method "modf", "unary_ret2"
+    end
+  end
+end
+
+if is_comparable
+  cond_binary "gt"
+  cond_binary "ge"
+  cond_binary "lt"
+  cond_binary "le"
+  def_alias ">", "gt"
+  def_alias ">=","ge"
+  def_alias "<", "lt"
+  def_alias "<=","le"
+  def_method "clip"
+end
+
+# Float
+
+if is_float
+  cond_unary "isnan"
+  cond_unary "isinf"
+  cond_unary "isposinf"
+  cond_unary "isneginf"
+  cond_unary "isfinite"
+end
+
+if is_int
+  if is_unsigned
+    accum "sum","u_int64_t","cumo_cUInt64"
+    accum "prod","u_int64_t","cumo_cUInt64"
+  else
+    accum "sum","int64_t","cumo_cInt64"
+    accum "prod","int64_t","cumo_cInt64"
+  end
+else
+  accum "sum","dtype","cT"
+  accum "prod","dtype","cT"
+end
+
+if is_double_precision
+  accum "kahan_sum","dtype","cT"
+end
+
+if is_float
+  accum "mean","dtype","cT"
+  accum "stddev","rtype","cRT"
+  accum "var","rtype","cRT"
+  accum "rms","rtype","cRT"
+end
+
+if is_comparable
+  accum "min","dtype","cT"
+  accum "max","dtype","cT"
+  accum "ptp","dtype","cT"
+  accum_index "max_index"
+  accum_index "min_index"
+  def_method "minmax"
+  def_module_function "maximum", "ewcomp", n_arg:2
+  def_module_function "minimum", "ewcomp", n_arg:2
+end
+
+if is_int && !is_object
+  def_method "bincount"
+end
+
+cum "cumsum","add"
+cum "cumprod","mul"
+
+# dot
+accum_binary "mulsum"
+if (is_float || is_complex) && !is_object
+  def_method "gemm"
+end
+
+# rmsdev
+# prod
+
+# shuffle
+# histogram
+
+def_method "seq"
+if is_float
+  def_method "logseq"
+end
+def_method "eye"
+def_alias  "indgen", "seq"
+
+def_method "rand"
+if is_float && !is_object
+  def_method "rand_norm"
+end
+
+# y = a[0] + a[1]*x + a[2]*x^2 + a[3]*x^3 + ... + a[n]*x^n
+def_method "poly"
+
+if is_comparable && !is_object
+  if is_float
+    qsort type_name,"dtype","*(dtype*)","_prnan"
+    qsort type_name,"dtype","*(dtype*)","_ignan"
+  else
+    qsort type_name,"dtype","*(dtype*)"
+  end
+  def_method "sort"
+  if is_float
+    qsort type_name+"_index","dtype*","**(dtype**)","_prnan"
+    qsort type_name+"_index","dtype*","**(dtype**)","_ignan"
+  else
+    qsort type_name+"_index","dtype*","**(dtype**)"
+  end
+  def_method "sort_index"
+  def_method "median"
+end
+
+# Math
+# histogram
+
+if has_math
+fn = get(:full_class_name)
+cn = get(:class_name)
+nm = get(:name)
+is_c = is_complex
+
+def_module do
+  extend NMathMethod
+  set ns_var: "cT"
+  set class_name: cn
+  set name: "#{nm}_math"
+  set full_module_name: fn+"::NMath"
+  set module_name: "Math"
+  set module_var: "mTM"
+
+  math "sqrt"
+  math "cbrt"
+  math "log"
+  math "log2"
+  math "log10"
+  math "exp"
+  math "exp2"
+  math "exp10"
+  math "sin"
+  math "cos"
+  math "tan"
+  math "asin"
+  math "acos"
+  math "atan"
+  math "sinh"
+  math "cosh"
+  math "tanh"
+  math "asinh"
+  math "acosh"
+  math "atanh"
+  math "sinc"
+  if !is_c
+    math "atan2",2
+    math "hypot",2
+    math "erf"
+    math "erfc"
+    math "log1p"
+    math "expm1"
+    math "ldexp",2
+    math "frexp",1,"frexp"
+  end
+end
+end
+
+end # other than Bit