numo-narray 0.9.0.1-x86-mingw32

data/ext/numo/narray/gen/dtype.erb.c

@@ -0,0 +1,328 @@
+/*
+  <%=type_name%>.c
+  Numerical Array Extension for Ruby
+    (C) Copyright 1999-2011,2013 by Masahiro TANAKA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+
+#include <ruby.h>
+#include <math.h>
+#include "numo/narray.h"
+#include "numo/template.h"
+#include "SFMT.h"
+
+#define m_map(x) m_num_to_data(rb_yield(m_data_to_num(x)))
+
+<%
+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"
+end
+if is_comparable
+  def_id "gt"
+  def_id "ge"
+  def_id "lt"
+  def_id "le"
+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 "inverse"
+  def_id "square"
+  def_id "floor"
+  def_id "round"
+  def_id "ceil"
+  def_id "nan?"
+  def_id "infinite?"
+  def_id "finite?"
+  def_id ">" ,"op_gt"
+  def_id ">=","op_ge"
+  def_id "<" ,"op_lt"
+  def_id "<=","op_le"
+end
+%>
+
+<% IdVar.declaration.each do |x| %><%=
+ x %>
+<% end %>
+
+#include "numo/types/<%=type_name%>.h"
+
+VALUE cT;
+extern VALUE cRT;
+#ifdef mTM
+VALUE mTM;
+#endif
+
+<%
+if is_object
+  def_allocate "robj_allocate"
+end
+def_method "allocate", 0
+
+def_method "extract", 0
+store_numeric
+cast_array
+store_array
+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_real"
+store_from "Int32", "int32_t",  "m_from_real"
+store_from "Int16", "int16_t",  "m_from_real"
+store_from "Int8",  "int8_t",   "m_from_real"
+store_from "UInt64","u_int64_t","m_from_real"
+store_from "UInt32","u_int32_t","m_from_real"
+store_from "UInt16","u_int16_t","m_from_real"
+store_from "UInt8", "u_int8_t", "m_from_real"
+
+def_method "store", 1
+def_singleton "cast", 1
+
+def_method "aref", -1, "aref", :op=>"[]"
+def_method "aset", -1, "aset", :op=>"[]="
+
+def_method "coerce_cast", 1
+def_method "to_a", 0
+def_method "fill", 1
+def_method "format", -1
+def_method "format_to_a", -1
+def_method "inspect", 0
+
+def_method "each", 0
+unary "map"
+def_method "each_with_index", 0
+def_method "map_with_index", 0
+
+# 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 "inverse"
+
+# 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", "copy"
+  def_alias "im", "copy"
+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", "~"
+  def_alias "floor", "copy"
+  def_alias "round", "copy"
+  def_alias "ceil",  "copy"
+end
+
+if is_float && is_real
+  unary "floor"
+  unary "round"
+  unary "ceil"
+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"
+end
+
+# Float
+
+if is_float
+  cond_unary "isnan"
+  cond_unary "isinf"
+  cond_unary "isfinite"
+end
+
+accum "sum","dtype","cT"
+accum "prod","dtype","cT"
+
+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_index "max_index"
+  accum_index "min_index"
+  def_method "minmax",-1
+end
+
+cum "cumsum","add"
+cum "cumprod","mul"
+
+# dot
+accum_binary "mulsum"
+
+# rmsdev
+# prod
+
+# shuffle
+# histogram
+
+def_method "seq",-1
+def_method "eye",-1
+def_alias  "indgen", "seq"
+
+if !is_object
+  def_method "rand", 0
+end
+
+# y = a[0] + a[1]*x + a[2]*x^2 + a[3]*x^3 + ... + a[n]*x^n
+def_method "poly",-2
+
+if is_comparable && !is_object
+  qsort type_name,"dtype","*(dtype*)"
+  def_method "sort",-1
+  qsort type_name+"_index","dtype*","**(dtype**)"
+  def_method "sort_index",-1
+  def_method "median",-1
+end
+
+# Math
+# histogram
+
+if has_math
+  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"
+  if !is_complex
+    math "atan2",2
+    math "hypot",2
+    math "erf"
+    math "erfc"
+    math "ldexp",2
+  end
+end
+%>
+static VALUE <%= find_tmpl('store').c_func %>(VALUE,VALUE);
+<%
+Function.codes.each do |x| %>
+<%= x %>
+<% end %>
+
+void
+Init_nary_<%=tp%>()
+{
+    volatile VALUE hCast;
+
+    cT = rb_define_class_under(mNumo, "<%=class_name%>", cNArray);
+    <% for x in class_alias %>
+    // alias of <%=class_name%>
+    rb_define_const(mNumo, "<%=x%>", <%=type_var%>);
+    <% end %>
+    <% if has_math %>
+    mTM = rb_define_module_under(cT, "Math"); <% end %>
+
+    rb_define_const(cT, ELEMENT_BIT_SIZE,  INT2FIX(sizeof(dtype)*8));
+    rb_define_const(cT, ELEMENT_BYTE_SIZE, INT2FIX(sizeof(dtype)));
+    rb_define_const(cT, CONTIGUOUS_STRIDE, INT2FIX(sizeof(dtype)));
+
+    rb_define_singleton_method(cT, "[]", <%=cast_func%>, -2);
+
+    <% if is_object %>
+    rb_undef_method(rb_singleton_class(cT),"from_string");
+    rb_undef_method(cT,"to_string");
+    <% end %>
+
+    <% Function.definitions.each do |x| %>
+    <%= x %><% end %>
+    <% IdVar.assignment.each do |x| %>
+    <%= x %><% end %>
+
+    hCast = rb_hash_new();
+    rb_define_const(cT, "UPCAST", hCast);
+    rb_hash_aset(hCast, rb_cArray,   cT);
+    <% for x in upcast %>
+    <%= x %><% end %>
+}

data/ext/numo/narray/gen/tmpl/accum.c

@@ -0,0 +1,36 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   n;
+    char    *p1, *p2;
+    ssize_t  s1;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
+
+    *(<%=dtype%>*)p2 = f_<%=method%>(n,p1,s1);
+}
+
+/*
+  <%=method.capitalize%> of self.
+  @overload <%=method%>(*args)
+  @param [Array of Numeric,Range] args  Affected dimensions.
+  @return [Numo::<%=class_name%>] <%=method%> of self.
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{<%=tpclass%>,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE, 2, 1, ain, aout };
+
+    reduce = na_reduce_dimension(argc, argv, 1, &self);
+    v =  na_ndloop(&ndf, 2, self, reduce);
+<% if tpclass == "cT" %>
+    return numo_<%=tp%>_extract(v);
+<% else %>
+    return rb_funcall(v,rb_intern("extract"),0);
+<% end %>
+}

data/ext/numo/narray/gen/tmpl/accum_binary.c

@@ -0,0 +1,75 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+    dtype    x, y, z;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    if (s3==0) {
+        // Reduce loop
+        GET_DATA(p3,dtype,z);
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            GET_DATA_STRIDE(p2,s2,dtype,y);
+            m_<%=method%>(x,y,z);
+        }
+        SET_DATA(p3,dtype,z);
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            GET_DATA_STRIDE(p2,s2,dtype,y);
+            GET_DATA(p3,dtype,z);
+            m_<%=method%>(x,y,z);
+            SET_DATA_STRIDE(p3,s3,dtype,z);
+        }
+    }
+}
+
+
+static VALUE
+<%=c_func%>_self(int argc, VALUE *argv, VALUE self)
+{
+    VALUE v, reduce;
+    VALUE naryv[2];
+    ndfunc_arg_in_t ain[4] = {{cT,0},{cT,0},{sym_reduce,0},{sym_init,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP, 4, 1, ain, aout };
+
+    if (argc < 1) {
+        rb_raise(rb_eArgError,"wrong number of arguments (%d for >=1)",argc);
+    }
+    // should fix below: [self.ndim,other.ndim].max or?
+    naryv[0] = self;
+    naryv[1] = argv[0];
+    reduce = na_reduce_dimension(argc-1, argv+1, 2, naryv);
+    v =  na_ndloop(&ndf, 4, self, argv[0], reduce, m_<%=method%>_init);
+    return numo_<%=tp%>_extract(v);
+}
+
+
+/*
+  Binary <%=method%>.
+  @overload <%=op_map%> other
+  @param [Numo::NArray,Numeric] other
+  @return [Numo::NArray] <%=method%> of self and other.
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE klass, v;
+    if (argc < 1) {
+        rb_raise(rb_eArgError,"wrong number of arguments (%d for >=1)",argc);
+    }
+    klass = na_upcast(CLASS_OF(self),CLASS_OF(argv[0]));
+    if (klass==cT) {
+        return <%=c_func%>_self(argc, argv, self);
+    } else {
+        v = rb_funcall(klass, id_cast, 1, self);
+        return rb_funcall2(v, rb_intern("<%=method%>"), argc, argv);
+    }
+}

data/ext/numo/narray/gen/tmpl/accum_index.c

@@ -0,0 +1,58 @@
+<% [64,32].each do |i| %>
+#define idx_t int<%=i%>_t
+static void
+<%=c_iter%>_index<%=i%>(na_loop_t *const lp)
+{
+    size_t   n, idx;
+    char    *d_ptr, *i_ptr, *o_ptr;
+    ssize_t  d_step, i_step;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, d_ptr, d_step);
+
+    idx = f_<%=method%>(n,d_ptr,d_step);
+
+    INIT_PTR(lp, 1, i_ptr, i_step);
+    o_ptr = NDL_PTR(lp,2);
+    *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
+}
+#undef idx_t
+<% end %>
+
+/*
+ *  call-seq:
+ *     narray.<%=method%>() => Integer
+ *     narray.<%=method%>(dim0,dim1,..) => Integer or Numo::Int32/64
+ *
+ *  Return an index of result.
+ *
+ *     Numo::NArray[3,4,1,2].min_index => 3
+ */
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    narray_t *na;
+    VALUE idx, reduce;
+    ndfunc_arg_in_t ain[3] = {{Qnil,0},{Qnil,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{0,0,0}};
+    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_EXTRACT, 3,1, ain,aout};
+
+    GetNArray(self,na);
+    if (na->ndim==0) {
+        return INT2FIX(0);
+    }
+    if (na->size > (~(u_int32_t)0)) {
+        aout[0].type = numo_cInt64;
+        idx = rb_narray_new(numo_cInt64, na->ndim, na->shape);
+        ndf.func = <%=c_iter%>_index64;
+    } else {
+        aout[0].type = numo_cInt32;
+        idx = rb_narray_new(numo_cInt32, na->ndim, na->shape);
+        ndf.func = <%=c_iter%>_index32;
+    }
+    rb_funcall(idx, rb_intern("seq"), 0);
+
+    reduce = na_reduce_dimension(argc, argv, 1, &self);
+
+    return na_ndloop(&ndf, 3, self, idx, reduce);
+}

data/ext/numo/narray/gen/tmpl/allocate.c

@@ -0,0 +1,35 @@
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    narray_t *na;
+    char *ptr;
+
+    GetNArray(self,na);
+
+    switch(NA_TYPE(na)) {
+    case NARRAY_DATA_T:
+        ptr = NA_DATA_PTR(na);
+        if (na->size > 0 && ptr == NULL) {
+            ptr = xmalloc(sizeof(dtype) * na->size);
+            <% if is_object %>
+            {   size_t i;
+                VALUE *a = (VALUE*)ptr;
+                for (i=na->size; i--;) {
+                    *a++ = Qnil;
+                }
+            }
+            <% end %>
+            NA_DATA_PTR(na) = ptr;
+        }
+        break;
+    case NARRAY_VIEW_T:
+        rb_funcall(NA_VIEW_DATA(na), rb_intern("allocate"), 0);
+        break;
+    case NARRAY_FILEMAP_T:
+        //ptr = ((narray_filemap_t*)na)->ptr;
+        // to be implemented
+    default:
+        rb_bug("invalid narray type : %d",NA_TYPE(na));
+    }
+    return self;
+}

data/ext/numo/narray/gen/tmpl/aref.c

@@ -0,0 +1,51 @@
+/*
+  Array element referenece or slice view.
+  @overload [](dim0,...,dimL)
+  @param [Numeric,Range,etc] dim0,...,dimL  Multi-dimensional Index.
+  @return [Numeric,NArray::<%=class_name%>] Element object or NArray view.
+
+  --- Returns the element at +dim0+, +dim1+, ... are Numeric indices
+  for each dimension, or returns a NArray View as a sliced subarray if
+  +dim0+, +dim1+, ... includes other than Numeric index, e.g., Range
+  or Array or true.
+
+      a = Numo::DFloat.new(4,5).seq
+      => Numo::DFloat#shape=[4,5]
+      [[0, 1, 2, 3, 4],
+       [5, 6, 7, 8, 9],
+       [10, 11, 12, 13, 14],
+       [15, 16, 17, 18, 19]]
+
+      a[1,1]
+      => 6.0
+
+      a[1..3,1]
+      => Numo::DFloat#shape=[3]
+      [6, 11, 16]
+
+      a[1,[1,3,4]]
+      => Numo::DFloat#shape=[3]
+      [6, 8, 9]
+
+      a[true,2].fill(99)
+      a
+      => Numo::DFloat#shape=[4,5]
+      [[0, 1, 99, 3, 4],
+       [5, 6, 99, 8, 9],
+       [10, 11, 99, 13, 14],
+       [15, 16, 99, 18, 19]]
+ */
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    ssize_t pos;
+    char *ptr;
+
+    pos = na_get_scalar_position(self, argc, argv, sizeof(dtype));
+    if (pos == -1) {
+        return na_aref_main(argc, argv, self, 0);
+    } else {
+        ptr = na_get_pointer_for_read(self) + pos;
+        return m_extract(ptr);
+    }
+}

data/ext/numo/narray/gen/tmpl/aset.c

@@ -0,0 +1,61 @@
+/*
+  Array element(s) set.
+  @overload []=(dim0,..,dimL,val)
+  @param [Numeric,Range,etc] dim0,..,dimL  Multi-dimensional Index.
+  @param [Numeric,Numo::NArray,etc] val  Value(s) to be set to self.
+  @return [Numeric] returns val (last argument).
+
+  --- Replace element(s) at +dim0+, +dim1+, ... (index/range/array/true
+  for each dimention). Broadcasting mechanism is applied.
+
+      a = Numo::DFloat.new(3,4).seq
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [4, 5, 6, 7],
+       [8, 9, 10, 11]]
+
+      a[1,2]=99
+      a
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [4, 5, 99, 7],
+       [8, 9, 10, 11]]
+
+      a[1,[0,2]] = [101,102]
+      a
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [101, 5, 102, 7],
+       [8, 9, 10, 11]]
+
+      a[1,true]=99
+      a
+      => Numo::DFloat#shape=[3,4]
+      [[0, 1, 2, 3],
+       [99, 99, 99, 99],
+       [8, 9, 10, 11]]
+
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    ssize_t pos;
+    char *ptr;
+    VALUE a;
+
+    argc--;
+    if (argc==0) {
+        <%=c_func.sub(/_aset/,"_store")%>(self, argv[argc]);
+    } else {
+        pos = na_get_scalar_position(self, argc, argv, sizeof(dtype));
+        if (pos == -1) {
+            a = na_aref_main(argc, argv, self, 0);
+            <%=c_func.sub(/_aset/,"_store")%>(a, argv[argc]);
+        } else {
+            ptr = na_get_pointer_for_read(self) + pos;
+            *(dtype*)ptr = m_num_to_data(argv[argc]);
+        }
+
+    }
+    return argv[argc];
+}

data/ext/numo/narray/gen/tmpl/binary.c

@@ -0,0 +1,53 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i, n;
+    char    *p1, *p2, *p3;
+    ssize_t  s1, s2, s3;
+    dtype    x, y;
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    for (i=n; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,dtype,y);
+<% if is_int and %w[div mod divmod].include? method %>
+        if (y==0) {
+            lp->err_type = rb_eZeroDivError;
+            return;
+        }
+<% end %>
+        x = m_<%=method%>(x,y);
+        SET_DATA_STRIDE(p3,s3,dtype,x);
+    }
+}
+
+static VALUE
+<%=c_func%>_self(VALUE self, VALUE other)
+{
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 1, ain, aout };
+
+    return na_ndloop(&ndf, 2, self, other);
+}
+
+/*
+  Binary <%=method%>.
+  @overload <%=op_map%> other
+  @param [Numo::NArray,Numeric] other
+  @return [Numo::NArray] self <%=op_map%> other
+*/
+static VALUE
+<%=c_func%>(VALUE self, VALUE other)
+{
+    VALUE klass, v;
+    klass = na_upcast(CLASS_OF(self),CLASS_OF(other));
+    if (klass==cT) {
+        return <%=c_func%>_self(self, other);
+    } else {
+        v = rb_funcall(klass, id_cast, 1, self);
+        return rb_funcall(v, <%=id_op%>, 1, other);
+    }
+}