numo-narray 0.9.0.1-x86-mingw32

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

@@ -0,0 +1,149 @@
+/*
+  qsort.c
+  Numerical Array Extension for Ruby
+    (C) Copyright 2007-2011 by Masahiro TANAKA
+
+  This program is free software.
+  You can distribute/modify this program
+  under the same terms as Ruby itself.
+  NO WARRANTY.
+*/
+
+/*
+ *      qsort.c: standard quicksort algorithm
+ *
+ *      Modifications from vanilla NetBSD source:
+ *        Add do ... while() macro fix
+ *        Remove __inline, _DIAGASSERTs, __P
+ *        Remove ill-considered "swap_cnt" switch to insertion sort,
+ *        in favor of a simple check for presorted input.
+ *
+ *      CAUTION: if you change this file, see also qsort_arg.c
+ *
+ *      $PostgreSQL: pgsql/src/port/qsort.c,v 1.12 2006/10/19 20:56:22 tgl Exp $
+ */
+
+/*      $NetBSD: qsort.c,v 1.13 2003/08/07 16:43:42 agc Exp $   */
+
+/*-
+ * Copyright (c) 1992, 1993
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *        notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *        notice, this list of conditions and the following disclaimer in the
+ *        documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *        may be used to endorse or promote products derived from this software
+ *        without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.      IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef QSORT_INCL
+#define QSORT_INCL
+#define Min(x, y)               ((x) < (y) ? (x) : (y))
+
+#define swap(type,a,b) \
+    do {type tmp=*(type*)(a); *(type*)(a)=*(type*)(b); *(type*)(b)=tmp;} while(0)
+
+#define vecswap(type, a, b, n) if ((n)>0) swap(type,(a),(b))
+
+#define MED3(a,b,c)                                     \
+    (cmpgt(b,a) ?                                       \
+     (cmpgt(c,b) ? b : (cmpgt(c,a) ? c : a))            \
+     : (cmpgt(b,c) ? b : (cmpgt(c,a) ? a : c)))
+#endif
+
+#undef qsort_dtype
+#define qsort_dtype <%=dtype%>
+#undef qsort_cast
+#define qsort_cast <%=dcast%>
+
+void
+<%=tp%>_qsort(void *a, size_t n, ssize_t es)
+{
+    char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
+    int  d, r, presorted;
+
+ loop:
+    if (n < 7) {
+        for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es)
+            for (pl = pm; pl > (char *) a && cmpgt(pl - es, pl);
+                 pl -= es)
+                swap(qsort_dtype, pl, pl - es);
+        return;
+    }
+    presorted = 1;
+    for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es) {
+        if (cmpgt(pm - es, pm)) {
+            presorted = 0;
+            break;
+        }
+    }
+    if (presorted)
+        return;
+    pm = (char *) a + (n / 2) * es;
+    if (n > 7) {
+        pl = (char *) a;
+        pn = (char *) a + (n - 1) * es;
+        if (n > 40) {
+            d = (n / 8) * es;
+            pl = MED3(pl, pl + d, pl + 2 * d);
+            pm = MED3(pm - d, pm, pm + d);
+            pn = MED3(pn - 2 * d, pn - d, pn);
+        }
+        pm = MED3(pl, pm, pn);
+    }
+    swap(qsort_dtype, a, pm);
+    pa = pb = (char *) a + es;
+    pc = pd = (char *) a + (n - 1) * es;
+    for (;;) {
+        while (pb <= pc && (r = cmp(pb, a)) <= 0) {
+            if (r == 0) {
+                swap(qsort_dtype, pa, pb);
+                pa += es;
+            }
+            pb += es;
+        }
+        while (pb <= pc && (r = cmp(pc, a)) >= 0) {
+            if (r == 0) {
+                swap(qsort_dtype, pc, pd);
+                pd -= es;
+            }
+            pc -= es;
+        }
+        if (pb > pc)
+            break;
+        swap(qsort_dtype, pb, pc);
+        pb += es;
+        pc -= es;
+    }
+    pn = (char *) a + n * es;
+    r = Min(pa - (char *) a, pb - pa);
+    vecswap(qsort_dtype, a, pb - r, r);
+    r = Min(pd - pc, pn - pd - es);
+    vecswap(qsort_dtype, pb, pn - r, r);
+    if ((r = pb - pa) > es)
+        <%=tp%>_qsort(a, r / es, es);
+    if ((r = pd - pc) > es) {
+        a = pn - r;
+        n = r / es;
+        goto loop;
+    }
+}
+

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

@@ -0,0 +1,33 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1;
+    ssize_t  s1;
+    size_t  *idx1;
+    dtype    x;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    if (idx1) {
+        for (; i--;) {
+            x = m_rand;
+            SET_DATA_INDEX(p1,idx1,dtype,x);
+        }
+    } else {
+        for (; i--;) {
+            x = m_rand;
+            SET_DATA_STRIDE(p1,s1,dtype,x);
+        }
+    }
+}
+
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+
+    na_ndloop(&ndf, 1, self);
+    return self;
+}

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

@@ -0,0 +1,46 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t   i;
+    char    *p1;
+    ssize_t  s1;
+    size_t  *idx1;
+    dtype    y;
+    dtype    a[2];
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    if (idx1) {
+        for (; i>1; i-=2) {
+            m_rand_norm(a);
+            *(dtype*)(p1+*idx1)     = a[0];
+            *(dtype*)(p1+*(idx1+1)) = a[1];
+            idx1 += 2;
+        }
+        if (i>0) {
+            m_rand_norm(a);
+            *(dtype*)(p1+*idx1) = a[0];
+        }
+    } else {
+        for (; i>1; i-=2) {
+            m_rand_norm(a);
+            *(dtype*)(p1)    = a[0];
+            *(dtype*)(p1+s1) = a[1];
+            p1 += s1*2;
+        }
+        if (i>0) {
+            m_rand_norm(a);
+            *(dtype*)(p1) = a[0];
+        }
+    }
+}
+
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+
+    na_ndloop(&ndf, 1, self);
+    return self
+}

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

@@ -0,0 +1,32 @@
+static void
+na_gc_mark_robj(narray_data_t* na)
+{
+    size_t n, i;
+    VALUE *a;
+
+    if (na->ptr) {
+        a = (VALUE*)(na->ptr);
+        n = na->base.size;
+        for (i=0; i<n; i++) {
+            rb_gc_mark(a[i]);
+        }
+    }
+}
+
+void na_free(narray_data_t* na);
+
+VALUE
+<%=c_func%>(VALUE klass)
+{
+    narray_data_t *na = ALLOC(narray_data_t);
+
+    na->base.ndim = 0;
+    na->base.type = NARRAY_DATA_T;
+    na->base.flag[0] = 0;
+    na->base.flag[1] = 0;
+    na->base.size = 0;
+    na->base.shape = NULL;
+    na->base.reduce = INT2FIX(0);
+    na->ptr = NULL;
+    return Data_Wrap_Struct(klass, na_gc_mark_robj, na_free, na);
+}

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

@@ -0,0 +1,61 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1;
+    ssize_t s1;
+    size_t *idx1;
+    double  x, beg, step, c;
+    dtype   y;
+    seq_opt_t *g;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    g = (seq_opt_t*)(lp->opt_ptr);
+    beg  = g->beg;
+    step = g->step;
+    c    = g->count;
+    if (idx1) {
+        for (; i--;) {
+            x = beg + step * c++;
+            y = m_from_double(x);
+            *(dtype*)(p1+*idx1) = y;
+            idx1++;
+        }
+    } else {
+        for (; i--;) {
+            x = beg + step * c++;
+            y = m_from_double(x);
+            *(dtype*)(p1) = y;
+            p1 += s1;
+        }
+    }
+    g->count = c;
+}
+
+/*
+  Set Sequence of numbers to self NArray.
+  @overload seq([beg,[step]])
+  @param [Numeric] beg  begining of sequence. (default=0)
+  @param [Numeric] step  step of sequence. (default=1)
+  @return [Numo::<%=class_name%>] self.
+*/
+static VALUE
+<%=c_func%>(int argc, VALUE *args, VALUE self)
+{
+    seq_opt_t *g;
+    VALUE vbeg=Qnil, vstep=Qnil;
+    ndfunc_arg_in_t ain[1] = {{OVERWRITE,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 1, 0, ain, 0 };
+
+    g = ALLOCA_N(seq_opt_t,1);
+    g->beg = 0;
+    g->step = 1;
+    g->count = 0;
+    rb_scan_args(argc, args, "02", &vbeg, &vstep);
+    if (vbeg!=Qnil) {g->beg = NUM2DBL(vbeg);}
+    if (vstep!=Qnil) {g->step = NUM2DBL(vstep);}
+
+    na_ndloop3(&ndf, g, 1, self);
+    return self;
+}

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

@@ -0,0 +1,56 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i;
+    char   *p1, *p2;
+    ssize_t s1, s2;
+    size_t *idx1, *idx2;
+    dtype   x;
+    <%=dtype%> y;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    if (idx1) {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA_INDEX(p1,idx1,dtype,x);
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+                x = m_<%=method%>(x,y);
+                SET_DATA_INDEX(p1,idx1,dtype,x);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_INDEX(p1,idx1,dtype,x);
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+                x = m_<%=method%>(x,y);
+                SET_DATA_INDEX(p1,idx1,dtype,x);
+            }
+        }
+    } else {
+        if (idx2) {
+            for (; i--;) {
+                GET_DATA(p1,dtype,x);
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,y);
+                x = m_<%=method%>(x,y);
+                SET_DATA_STRIDE(p1,s1,dtype,x);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA(p1,dtype,x);
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,y);
+                x = m_<%=method%>(x,y);
+                SET_DATA_STRIDE(p1,s1,dtype,x);
+            }
+        }
+    }
+}
+
+static VALUE
+<%=c_func%>(VALUE self, VALUE a1)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{<%=tpclass%>,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };
+
+    na_ndloop(&ndf, 2, self, a1);
+    return a1;
+}

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

@@ -0,0 +1,36 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t n;
+    char *ptr;
+    ssize_t step;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, ptr, step);
+    <%=tp%>_qsort(ptr, n, step);
+}
+
+/*
+ *  call-seq:
+ *     narray.sort() => narray
+ *     narray.sort(dim0,dim1,...) => narray
+ *
+ *  Return an index array of sort result.
+ *
+ *     Numo::DFloat[3,4,1,2].sort => Numo::DFloat[1,2,3,4]
+ */
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    VALUE reduce;
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{sym_reduce,0}};
+    ndfunc_t ndf = {<%=c_iter%>, STRIDE_LOOP_NIP|NDF_INPLACE|NDF_FLAT_REDUCE, 2,0, ain,0};
+
+    if (!TEST_INPLACE(self)) {
+        self = na_copy(self);
+    }
+    reduce = na_reduce_dimension(argc, argv, 1, &self); // v[0] = self
+
+    na_ndloop(&ndf, 2, self, reduce);
+    return self;
+}

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

@@ -0,0 +1,86 @@
+
+<% [64,32].each do |i| %>
+#define idx_t int<%=i%>_t
+static void
+<%=tp%>_index<%=i%>_qsort(na_loop_t *const lp)
+{
+    size_t   i, n, idx;
+    char    *d_ptr, *i_ptr, *o_ptr;
+    ssize_t  d_step, i_step, o_step;
+    char   **ptr;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR(lp, 0, d_ptr, d_step);
+    INIT_PTR(lp, 1, i_ptr, i_step);
+    INIT_PTR(lp, 2, o_ptr, o_step);
+
+    ptr = (char**)(lp->opt_ptr);
+
+    //printf("(ptr=%lx, d_ptr=%lx,d_step=%ld, i_ptr=%lx,i_step=%ld, o_ptr=%lx,o_step=%ld)\n",(size_t)ptr,(size_t)d_ptr,(ssize_t)d_step,(size_t)i_ptr,(ssize_t)i_step,(size_t)o_ptr,(ssize_t)o_step);
+
+    for (i=0; i<n; i++) {
+        ptr[i] = d_ptr + d_step * i;
+        //printf("(%ld,%.3f)",i,*(double*)ptr[i]);
+    }
+
+    <%=tp%>_index_qsort(ptr, n, sizeof(dtype*));
+
+    //d_ptr = lp->args[0].ptr;
+    //printf("(d_ptr=%lx)\n",(size_t)d_ptr);
+
+    for (i=0; i<n; i++) {
+        idx = (ptr[i] - d_ptr) / d_step;
+        *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
+        //printf("(idx[%ld]=%ld,%d)",i,idx,*(idx_t*)o_ptr);
+        o_ptr += o_step;
+    }
+    //printf("\n");
+}
+#undef idx_t
+<% end %>
+
+/*
+ *  call-seq:
+ *     narray.sort_index() => narray
+ *     narray.sort_index(dim0,dim1,..) => narray
+ *
+ *  Return an index array of sort result.
+ *
+ *     Numo::NArray[3,4,1,2].sort_index => Numo::Int32[2,3,0,1]
+ */
+static VALUE
+<%=c_func%>(int argc, VALUE *argv, VALUE self)
+{
+    size_t size;
+    narray_t *na;
+    VALUE idx, tmp, reduce, res;
+    char *buf;
+    ndfunc_arg_in_t ain[3] = {{cT,0},{0,0},{sym_reduce,0}};
+    ndfunc_arg_out_t aout[1] = {{0,0,0}};
+    ndfunc_t ndf = {0, STRIDE_LOOP_NIP|NDF_FLAT_REDUCE|NDF_CUM, 3,1, ain,aout};
+
+    GetNArray(self,na);
+    if (na->ndim==0) {
+        return INT2FIX(0);
+    }
+    if (na->size > (~(u_int32_t)0)) {
+        ain[1].type =
+        aout[0].type = numo_cInt64;
+        idx = rb_narray_new(numo_cInt64, na->ndim, na->shape);
+        ndf.func = <%=tp%>_index64_qsort;
+    } else {
+        ain[1].type =
+        aout[0].type = numo_cInt32;
+        idx = rb_narray_new(numo_cInt32, na->ndim, na->shape);
+        ndf.func = <%=tp%>_index32_qsort;
+    }
+    rb_funcall(idx, rb_intern("seq"), 0);
+
+    reduce = na_reduce_dimension(argc, argv, 1, &self); // v[0] = self
+
+    size = na->size*sizeof(void*);
+    buf = rb_alloc_tmp_buffer(&tmp, size);
+    res = na_ndloop3(&ndf, buf, 3, self, idx, reduce);
+    rb_free_tmp_buffer(&tmp);
+    return res;
+}

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

@@ -0,0 +1,31 @@
+/*
+  Store elements to Numo::<%=class_name%> from other.
+  @overload store(other)
+  @param [Object] other
+  @return [Numo::<%=class_name%>] self
+*/
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    VALUE r;
+
+    <% Store.definitions.each do |x| %>
+    if (<%=x.condition%>) {
+        <%=x.c_func%>(self,obj);
+        return self;
+    }
+    <% end %>
+
+    if (IsNArray(obj)) {
+        r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
+        if (CLASS_OF(r)==cT) {
+            <%=c_func%>(self,r);
+            return self;
+        }
+    }
+
+    rb_raise(nary_eCastError, "unknown conversion from %s to %s",
+             rb_class2name(CLASS_OF(obj)),
+             rb_class2name(CLASS_OF(self)));
+    return self;
+}

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

@@ -0,0 +1,5 @@
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    return <%=find_tmpl("store").c_func%>(self,<%=find_tmpl("cast_array").c_func%>(obj));
+}

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

@@ -0,0 +1,53 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t  i, s1, s2;
+    char   *p1, *p2;
+    size_t *idx1, *idx2;
+    <%=dtype%> x;
+    dtype y;
+
+    INIT_COUNTER(lp, i);
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);
+    if (idx2) {
+        if (idx1) {
+            for (; i--;) {
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                SET_DATA_INDEX(p1,idx1,dtype,y);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_INDEX(p2,idx2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                SET_DATA_STRIDE(p1,s1,dtype,y);
+            }
+        }
+    } else {
+        if (idx1) {
+            for (; i--;) {
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                SET_DATA_INDEX(p1,idx1,dtype,y);
+            }
+        } else {
+            for (; i--;) {
+                GET_DATA_STRIDE(p2,s2,<%=dtype%>,x);
+                y = <%=macro%>(x);
+                SET_DATA_STRIDE(p1,s1,dtype,y);
+            }
+        }
+    }
+}
+
+
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0},{Qnil,0}};
+    ndfunc_t ndf = { <%=c_iter%>, FULL_LOOP, 2, 0, ain, 0 };
+
+    na_ndloop(&ndf, 2, self, obj);
+    return self;
+}

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

@@ -0,0 +1,22 @@
+static VALUE
+numo_<%=tp%>_new_dim0(dtype x)
+{
+    VALUE v;
+    dtype *ptr;
+
+    v = rb_narray_new(cT, 0, NULL);
+    ptr = (dtype*)(char*)na_get_pointer_for_write(v);
+    *ptr = x;
+    na_release_lock(v);
+    return v;
+}
+
+static VALUE
+<%=c_func%>(VALUE self, VALUE obj)
+{
+    dtype x;
+    x = m_num_to_data(obj);
+    obj = numo_<%=tp%>_new_dim0(x);
+    <%=find_tmpl("store").c_func%>(self,obj);
+    return self;
+}

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

@@ -0,0 +1,41 @@
+void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, s1;
+    char *p1;
+    size_t *idx1;
+    dtype x;
+    volatile VALUE a, y;
+
+    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--;) {
+            GET_DATA_INDEX(p1,idx1,dtype,x);
+            y = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    } else {
+        for (; i--;) {
+            GET_DATA_STRIDE(p1,s1,dtype,x);
+            y = m_data_to_num(x);
+            rb_ary_push(a,y);
+        }
+    }
+}
+
+/*
+  Convert self to Array.
+  @overload <%=method%>
+  @return [Array]
+*/
+static VALUE
+<%=c_func%>(VALUE self)
+{
+    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 };
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
+}