numo-narray 0.9.0.1-x64-mingw32

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

@@ -0,0 +1,45 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t    i;
+    char     *p1;
+    BIT_DIGIT *a2;
+    size_t    p2;
+    ssize_t   s1, s2;
+    size_t   *idx1;
+    dtype     x;
+    BIT_DIGIT b;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            b = (m_<%=method%>(x)) ? 1:0;
+            STORE_BIT(a2,p2,b);
+            p2+=s2;
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            b = (m_<%=method%>(x)) ? 1:0;
+            STORE_BIT(a2,p2,b);
+            p2+=s2;
+        }
+    }
+}
+
+/*
+  Condition of <%=method%>.
+  @overload <%=method%>
+  @return [Numo::Bit] Condition of <%=method%>.
+*/
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{cT,0}};
+    ndfunc_arg_out_t aout[1] = {{numo_cBit,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 1, ain, aout };
+
+    return na_ndloop(&ndf, 1, self);
+}

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

@@ -0,0 +1,42 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1, *p2;
+    ssize_t  s1, s2;
+    dtype    x, y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR(lp, 0, p1, s1);
+    INIT_PTR(lp, 1, p2, s2);
+    //printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
+
+    GET_DATA_STRIDE(p1,s1,dtype,x);
+    SET_DATA_STRIDE(p2,s2,dtype,x);
+    //printf("i=%lu x=%f\n",i,x);
+    for (i--; i--;) {
+        GET_DATA_STRIDE(p1,s1,dtype,y);
+        x = m_<%=cmacro%>(x,y);
+        SET_DATA_STRIDE(p2,s2,dtype,x);
+        //printf("i=%lu x=%f\n",i,x);
+    }
+}
+
+/*
+  <%=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 reduce;
+    ndfunc_arg_in_t ain[2] = {{cT,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{cT,0}};
+    ndfunc_t ndf = { <%=c_iter%>, STRIDE_LOOP_NIP|NDF_INPLACE|NDF_FLAT_REDUCE|NDF_CUM,
+                     2, 1, ain, aout };
+
+    reduce = na_reduce_dimension(argc, argv, 1, &self);
+    return na_ndloop(&ndf, 2, self, reduce);
+}

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

@@ -0,0 +1,43 @@
+void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, s1;
+    char *p1;
+    size_t *idx1;
+    dtype x;
+    VALUE y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            y = m_data_to_num(x);
+            rb_yield(y);
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            y = m_data_to_num(x);
+            rb_yield(y);
+        }
+    }
+}
+
+/*
+  Calls the given block once for each element in self,
+  passing that element as a parameter.
+  @overload <%=method%>
+  @return [Numo::NArray] self
+  For a block {|x| ... }
+  @yield [x]  x is element of NArray.
+*/
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+
+    na_ndloop(&ndf, 1, self);
+    return self;
+}

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

@@ -0,0 +1,64 @@
+static inline void
+yield_each_with_index(dtype x, size_t *c, VALUE *a, int nd, int md)
+{
+    int j;
+
+    a[0] = m_data_to_num(x);
+    for (j=0; j<=nd; j++) {
+        a[j+1] = SIZE2NUM(c[j]);
+    }
+    rb_yield(rb_ary_new4(md,a));
+}
+
+
+void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, s1;
+    char *p1;
+    size_t *idx1;
+    dtype x;
+    VALUE *a;
+    size_t *c;
+    int nd, md;
+
+    c = (size_t*)(lp->opt_ptr);
+    nd = lp->ndim - 1;
+    md = lp->ndim + 1;
+    a = ALLOCA_N(VALUE,md);
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    c[nd] = 0;
+    if (idx1) {
+        for (; i--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            yield_each_with_index(x,c,a,nd,md);
+            c[nd]++;
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            yield_each_with_index(x,c,a,nd,md);
+            c[nd]++;
+        }
+    }
+}
+
+/*
+  Invokes the given block once for each element of self,
+  passing that element and indices along each axis as parameters.
+  @overload <%=method%>
+  @return [Numo::NArray] self
+  For a block {|x,i,j,...| ... }
+  @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
+*/
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP_NIP, 1,0, ain,0};
+
+    na_ndloop_with_index(&ndf, 1, self);
+    return self;
+}

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

@@ -0,0 +1,23 @@
+/*
+  Extract an element only if self is a dimensionless NArray.
+  @overload extract
+  @return [Numeric,Numo::NArray]
+  --- Extract element value as Ruby Object if self is a dimensionless NArray,
+  otherwise returns self.
+*/
+VALUE
+numo_<%=tp%>_extract(VALUE self)
+{
+    volatile VALUE v;
+    char *ptr;
+    narray_t *na;
+    GetNArray(self,na);
+
+    if (na->ndim==0) {
+        ptr = na_get_pointer_for_read(self) + na_get_offset(self);
+        v = m_extract(ptr);
+        na_release_lock(self);
+        return v;
+    }
+    return self;
+}

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

@@ -0,0 +1,91 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   n0, n1;
+    size_t   i0, i1;
+    ssize_t  s0, s1;
+    char    *p0, *p1;
+    char    *g;
+    ssize_t kofs;
+    dtype   data;
+
+    g = (char*)(lp->opt_ptr);
+    kofs = *(ssize_t*)g;
+    data = *(dtype*)(g+sizeof(ssize_t));
+
+    n0 = lp->args[0].shape[0];
+    n1 = lp->args[0].shape[1];
+    s0 = lp->args[0].iter[0].step;
+    s1 = lp->args[0].iter[1].step;
+    p0 = NDL_PTR(lp,0);
+
+    for (i0=0; i0 < n0; i0++) {
+        p1 = p0;
+        for (i1=0; i1 < n1; i1++) {
+            *(dtype*)p1 = (i0+kofs==i1) ? data : m_zero;
+            p1 += s1;
+        }
+        p0 += s0;
+    }
+}
+
+/*
+  Eye: Set a value to diagonal components, set 0 to non-diagonal components.
+  @overload <%=method%>([element,offset])
+  @param [Numeric] element  Diagonal element to be stored. Default is 1.
+  @param [Integer] offset Diagonal offset from the main diagonal.  The
+      default is 0. k>0 for diagonals above the main diagonal, and k<0
+      for diagonals below the main diagonal.
+  @return [Numo::<%=class_name%>] <%=method%> of self.
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,2}};
+    ndfunc_t ndf = {<%=c_iter%>, NO_LOOP, 1,0, ain,0};
+    ssize_t kofs;
+    dtype data;
+    char *g;
+    int nd;
+    narray_t *na;
+
+    // check arguments
+    if (argc > 2) {
+        rb_raise(rb_eArgError,"too many arguments (%d for 0..2)",argc);
+    } else if (argc == 2) {
+        data = m_num_to_data(argv[0]);
+        kofs = NUM2SSIZE(argv[1]);
+    } else if (argc == 1) {
+        data = m_num_to_data(argv[0]);
+        kofs = 0;
+    } else {
+        data = m_one;
+        kofs = 0;
+    }
+
+    GetNArray(self,na);
+    nd = na->ndim;
+    if (nd < 2) {
+        rb_raise(nary_eDimensionError,"less than 2-d array");
+    }
+
+    // Diagonal offset from the main diagonal.
+    if (kofs >= 0) {
+        if ((size_t)(kofs) >= na->shape[nd-1]) {
+            rb_raise(rb_eArgError,"invalid diagonal offset(%ld) for "
+                     "last dimension size(%ld)",kofs,na->shape[nd-1]);
+        }
+    } else {
+        if ((size_t)(-kofs) >= na->shape[nd-2]) {
+            rb_raise(rb_eArgError,"invalid diagonal offset(%ld) for "
+                     "last-1 dimension size(%ld)",kofs,na->shape[nd-2]);
+        }
+    }
+
+    g = ALLOCA_N(char,sizeof(ssize_t)+sizeof(dtype));
+    *(ssize_t*)g = kofs;
+    *(dtype*)(g+sizeof(ssize_t)) = data;
+
+    na_ndloop3(&ndf, g, 1, self);
+    return self;
+}

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

@@ -0,0 +1,38 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1;
+    ssize_t  s1;
+    size_t  *idx1;
+    VALUE    x = lp->option;
+    dtype    y;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    y = m_num_to_data(x);
+    if (idx1) {
+        for (; i--;) {
+            SET_DATA_INDEX(p1,idx1,dtype,y);
+        }
+    } else {
+        for (; i--;) {
+            SET_DATA_STRIDE(p1,s1,dtype,y);
+        }
+    }
+}
+
+/*
+  Fill elements with other.
+  @overload <%=method%> other
+  @param [Numeric] other
+  @return [Numo::<%=class_name%>] self.
+*/
+static VALUE
+<%=c_func%>(VALUE self, VALUE val)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_option}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };
+
+    na_ndloop(&ndf, 2, self, val);
+    return self;
+}

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

@@ -0,0 +1,60 @@
+static VALUE
+format_<%=tp%>(VALUE fmt, dtype* x)
+{
+    // fix-me
+    char s[48];
+    int n;
+
+    if (NIL_P(fmt)) {
+        n = m_sprintf(s,*x);
+        return rb_str_new(s,n);
+    }
+    return rb_funcall(fmt, '%', 1, m_data_to_num(*x));
+}
+
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2;
+    ssize_t s1, s2;
+    size_t *idx1;
+    dtype *x;
+    VALUE y;
+    VALUE fmt = lp->option;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR(lp, 1, p2, s2);
+    if (idx1) {
+        for (; i--;) {
+            x = (dtype*)(p1+*idx1); idx1++;
+            y = format_<%=tp%>(fmt, x);
+            SET_DATA_STRIDE(p2, s2, VALUE, y);
+        }
+    } else {
+        for (; i--;) {
+            x = (dtype*)p1;         p1+=s1;
+            y = format_<%=tp%>(fmt, x);
+            SET_DATA_STRIDE(p2, s2, VALUE, y);
+        }
+    }
+}
+
+/*
+  Format elements into strings.
+  @overload <%=method%> format
+  @param [String] format
+  @return [Numo::RObject] array of formated strings.
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE fmt=Qnil;
+
+    ndfunc_arg_in_t ain[2] = {{Qnil,0},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{numo_cRObject,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 2, 1, ain, aout };
+
+    rb_scan_args(argc, argv, "01", &fmt);
+    return na_ndloop(&ndf, 2, self, fmt);
+}

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

@@ -0,0 +1,47 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1;
+    ssize_t s1;
+    size_t *idx1;
+    dtype *x;
+    VALUE y;
+    volatile VALUE a;
+    VALUE fmt = lp->option;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    a = rb_ary_new2(i);
+    rb_ary_push(lp->args[1].value, a);
+    if (idx1) {
+        for (; i--;) {
+            x = (dtype*)(p1 + *idx1);  idx1++;
+            y = format_<%=tp%>(fmt, x);
+            rb_ary_push(a,y);
+        }
+    } else {
+        for (; i--;) {
+            x = (dtype*)p1;  p1+=s1;
+            y = format_<%=tp%>(fmt, x);
+            rb_ary_push(a,y);
+        }
+    }
+}
+
+/*
+  Format elements into strings.
+  @overload <%=method%> format
+  @param [String] format
+  @return [Array] array of formated strings.
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    volatile VALUE fmt=Qnil;
+    ndfunc_arg_in_t ain[3] = {{Qnil,0},{sym_loop_opt},{sym_option}};
+    ndfunc_arg_out_t aout[1] = {{rb_cArray,0}}; // dummy?
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP_NIP, 3, 1, ain, aout };
+
+    rb_scan_args(argc, argv, "01", &fmt);
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
+}