numo-narray 0.9.0.1-x64-mingw32

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);
+    }
+}

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

@@ -0,0 +1,55 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i, n;
+    char    *p1, *p2, *p3, *p4;
+    ssize_t  s1, s2, s3, s4;
+    dtype    x, y, a, b;
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    INIT_PTR(lp, 3, p4, s4);
+    for (i=n; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,dtype,y);
+<% if is_int and %w[divmod].include? method %>
+        if (y==0) {
+            lp->err_type = rb_eZeroDivError;
+            return;
+        }
+<% end %>
+        m_<%=method%>(x,y,a,b);
+        SET_DATA_STRIDE(p3,s3,dtype,a);
+        SET_DATA_STRIDE(p4,s4,dtype,b);
+    }
+}
+
+static VALUE
+<%=c_func%>_self(VALUE self, VALUE other)
+{
+    ndfunc_arg_in_t ain[2] = {{cT,0},{cT,0}};
+    ndfunc_arg_out_t aout[2] = {{cT,0},{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP, 2, 2, ain, aout };
+
+    return na_ndloop(&ndf, 2, self, other);
+}
+
+/*
+  Binary <%=method%>.
+  @overload <%=op_map%> other
+  @param [Numo::NArray,Numeric] other
+  @return [Numo::NArray] <%=method%> of self and 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);
+    }
+}

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

@@ -0,0 +1,34 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char    *p1, *p2, *p3;
+    ssize_t s1, s2, s3;
+    dtype    x, y;
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    INIT_PTR(lp, 2, p3, s3);
+    for (; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,x);
+        GET_DATA_STRIDE(p2,s2,dtype,y);
+        x = m_<%=method%>(x,y);
+        SET_DATA_STRIDE(p3,s3,dtype,x);
+    }
+}
+
+/*
+  Calculate <%=method%>(a1,a2).
+  @overload <%=method%>(a1,a2)
+  @param [Numo::NArray,Numeric] a1  first value
+  @param [Numo::NArray,Numeric] a2  second value
+  @return [Numo::<%=class_name%>] <%=method%>(a1,a2).
+*/
+static VALUE
+<%=c_func%>(VALUE mod, VALUE a1, VALUE a2)
+{
+    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, a1, a2);
+}