numo-narray-alt 0.9.4 → 0.9.5

data/ext/numo/narray/kwargs.c

@@ -15,10 +15,10 @@ struct RBasicRaw {
   VALUE klass;
 };
 
-#define RBASIC_SET_CLASS(obj, cls)                                                                                             \
-  do {                                                                                                                         \
-    VALUE _obj_ = (obj);                                                                                                       \
-    RB_OBJ_WRITE(_obj_, &((struct RBasicRaw*)(_obj_))->klass, cls);                                                            \
+#define RBASIC_SET_CLASS(obj, cls)                                  \
+  do {                                                              \
+    VALUE _obj_ = (obj);                                            \
+    RB_OBJ_WRITE(_obj_, &((struct RBasicRaw*)(_obj_))->klass, cls); \
   } while (0)
 
 /* from class.c */
@@ -69,7 +69,7 @@ static int separate_symbol(st_data_t key, st_data_t value, st_data_t arg) {
 
 VALUE
 rb_extract_keywords(VALUE* orighash) {
-  VALUE parthash[2] = {0, 0};
+  VALUE parthash[2] = { 0, 0 };
   VALUE hash = *orighash;
 
   if (RHASH_EMPTY_P(hash)) {
@@ -84,15 +84,17 @@ rb_extract_keywords(VALUE* orighash) {
   return parthash[0];
 }
 
-int rb_get_kwargs(VALUE keyword_hash, const ID* table, int required, int optional, VALUE* values) {
+int rb_get_kwargs(
+  VALUE keyword_hash, const ID* table, int required, int optional, VALUE* values
+) {
   int i = 0, j;
   int rest = 0;
   VALUE missing = Qnil;
   st_data_t key;
 
-#define extract_kwarg(keyword, val)                                                                                            \
-  (key = (st_data_t)(keyword),                                                                                                 \
-   values ? st_delete(rb_hash_tbl_raw(keyword_hash), &key, (val)) : st_lookup(rb_hash_tbl_raw(keyword_hash), key, (val)))
+#define extract_kwarg(keyword, val)                                                           \
+  (key = (st_data_t)(keyword), values ? st_delete(rb_hash_tbl_raw(keyword_hash), &key, (val)) \
+                                      : st_lookup(rb_hash_tbl_raw(keyword_hash), key, (val)))
 
   if (NIL_P(keyword_hash)) keyword_hash = 0;
 

data/ext/numo/narray/math.c

@@ -40,8 +40,10 @@ static VALUE nary_math_cast2(VALUE type1, VALUE type2) {
   if (RTEST(rb_class_inherited_p(type2, cNArray))) {
     return nary_type_s_upcast(type2, type1);
   }
-  if (RTEST(rb_class_inherited_p(type1, rb_cNumeric)) && RTEST(rb_class_inherited_p(type2, rb_cNumeric))) {
-    if (RTEST(rb_class_inherited_p(type1, rb_cComplex)) || RTEST(rb_class_inherited_p(type2, rb_cComplex))) {
+  if (RTEST(rb_class_inherited_p(type1, rb_cNumeric)) &&
+      RTEST(rb_class_inherited_p(type2, rb_cNumeric))) {
+    if (RTEST(rb_class_inherited_p(type1, rb_cComplex)) ||
+        RTEST(rb_class_inherited_p(type2, rb_cComplex))) {
       return rb_cComplex;
     }
     return rb_cFloat;

data/ext/numo/narray/narray.c

@@ -77,6 +77,8 @@ void Init_nary_math();
 void Init_nary_rand();
 void Init_nary_array();
 void Init_nary_struct();
+// define mean method for integer array
+void Init_nary_mean();
 
 const rb_data_type_t na_data_type = {
   "Numo::NArray",
@@ -857,7 +859,8 @@ void na_copy_flags(VALUE src, VALUE dst) {
   na2->flag[0] = na1->flag[0];
   // na2->flag[1] = NA_FL1_INIT;
 
-  RBASIC(dst)->flags |= (RBASIC(src)->flags) & (FL_USER1 | FL_USER2 | FL_USER3 | FL_USER4 | FL_USER5 | FL_USER6 | FL_USER7);
+  RBASIC(dst)->flags |= (RBASIC(src)->flags) & (FL_USER1 | FL_USER2 | FL_USER3 | FL_USER4 |
+                                                FL_USER5 | FL_USER6 | FL_USER7);
 }
 
 // fix name, ex, allow_stride_for_flatten_view
@@ -1423,10 +1426,12 @@ static VALUE nary_marshal_load(VALUE self, VALUE a) {
     rb_raise(rb_eArgError, "marshal array size should be 4");
   }
   if (RARRAY_AREF(a, 0) != INT2FIX(1)) {
-    rb_raise(rb_eArgError,
-             "NArray marshal version %d is not supported "
-             "(only version 1)",
-             NUM2INT(RARRAY_AREF(a, 0)));
+    rb_raise(
+      rb_eArgError,
+      "NArray marshal version %d is not supported "
+      "(only version 1)",
+      NUM2INT(RARRAY_AREF(a, 0))
+    );
   }
   na_initialize(self, RARRAY_AREF(a, 1));
   NA_FL0_SET(self, FIX2INT(RARRAY_AREF(a, 2)));
@@ -1538,7 +1543,6 @@ static VALUE na_get_reduce_flag_from_axes(VALUE na_obj, VALUE axes) {
   narg = RARRAY_LEN(axes);
   for (i = 0; i < narg; i++) {
     v = RARRAY_AREF(axes, i);
-    // printf("argv[%d]=",i);rb_p(v);
     if (TYPE(v) == T_FIXNUM) {
       beg = FIX2INT(v);
       if (beg < 0) beg += ndim;
@@ -1547,7 +1551,6 @@ static VALUE na_get_reduce_flag_from_axes(VALUE na_obj, VALUE axes) {
       }
       len = 1;
       step = 0;
-      // printf("beg=%d step=%d len=%d\n",beg,step,len);
     } else if (rb_obj_is_kind_of(v, rb_cRange)
 #ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
                || rb_obj_is_kind_of(v, rb_cArithSeq)
@@ -1611,12 +1614,14 @@ nary_reduce_options(VALUE axes, VALUE* opts, int naryc, VALUE* naryv, ndfunc_t*
 }
 
 VALUE
-nary_reduce_dimension(int argc, VALUE* argv, int naryc, VALUE* naryv, ndfunc_t* ndf, na_iter_func_t iter_nan) {
+nary_reduce_dimension(
+  int argc, VALUE* argv, int naryc, VALUE* naryv, ndfunc_t* ndf, na_iter_func_t iter_nan
+) {
   long narg;
   VALUE axes;
   VALUE kw_hash = Qnil;
-  ID kw_table[3] = {id_axis, id_keepdims, id_nan};
-  VALUE opts[3] = {Qundef, Qundef, Qundef};
+  ID kw_table[3] = { id_axis, id_keepdims, id_nan };
+  VALUE opts[3] = { Qundef, Qundef, Qundef };
 
   narg = rb_scan_args(argc, argv, "*:", &axes, &kw_hash);
   rb_get_kwargs(kw_hash, kw_table, 0, 3, opts);
@@ -1968,6 +1973,8 @@ void Init_narray(void) {
   Init_numo_bit();
   Init_numo_robject();
 
+  Init_nary_mean();
+
   Init_nary_math();
 
   Init_nary_rand();

data/ext/numo/narray/ndloop.c

@@ -157,10 +157,19 @@ static void print_ndloop(na_md_loop_t* lp) {
     printf("  user.args[%d].iter = 0x%" SZF "x\n", j, (size_t)lp->user.args[j].iter);
     if (lp->user.args[j].iter) {
       for (i = 0; i < lp->user.ndim; i++) {
-        printf(" &user.args[%d].iter[%d] = 0x%" SZF "x\n", j, i, (size_t)&lp->user.args[j].iter[i]);
-        printf("  user.args[%d].iter[%d].pos = %" SZF "u\n", j, i, lp->user.args[j].iter[i].pos);
-        printf("  user.args[%d].iter[%d].step = %" SZF "d\n", j, i, lp->user.args[j].iter[i].step);
-        printf("  user.args[%d].iter[%d].idx = 0x%" SZF "x\n", j, i, (size_t)lp->user.args[j].iter[i].idx);
+        printf(
+          " &user.args[%d].iter[%d] = 0x%" SZF "x\n", j, i, (size_t)&lp->user.args[j].iter[i]
+        );
+        printf(
+          "  user.args[%d].iter[%d].pos = %" SZF "u\n", j, i, lp->user.args[j].iter[i].pos
+        );
+        printf(
+          "  user.args[%d].iter[%d].step = %" SZF "d\n", j, i, lp->user.args[j].iter[i].step
+        );
+        printf(
+          "  user.args[%d].iter[%d].idx = 0x%" SZF "x\n", j, i,
+          (size_t)lp->user.args[j].iter[i].idx
+        );
       }
     }
     //
@@ -177,10 +186,18 @@ static void print_ndloop(na_md_loop_t* lp) {
       printf("  xargs[%d].bufcp->ndim = %d\n", j, lp->xargs[j].bufcp->ndim);
       printf("  xargs[%d].bufcp->elmsz = %" SZF "d\n", j, lp->xargs[j].bufcp->elmsz);
       printf("  xargs[%d].bufcp->n = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->n);
-      printf("  xargs[%d].bufcp->src_ptr = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->src_ptr);
-      printf("  xargs[%d].bufcp->buf_ptr = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->buf_ptr);
-      printf("  xargs[%d].bufcp->src_iter = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->src_iter);
-      printf("  xargs[%d].bufcp->buf_iter = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->buf_iter);
+      printf(
+        "  xargs[%d].bufcp->src_ptr = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->src_ptr
+      );
+      printf(
+        "  xargs[%d].bufcp->buf_ptr = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->buf_ptr
+      );
+      printf(
+        "  xargs[%d].bufcp->src_iter = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->src_iter
+      );
+      printf(
+        "  xargs[%d].bufcp->buf_iter = 0x%" SZF "x\n", j, (size_t)lp->xargs[j].bufcp->buf_iter
+      );
     }
   }
   printf("}\n");
@@ -295,8 +312,10 @@ static void ndloop_find_max_dimension(na_md_loop_t* lp, ndfunc_t* nf, VALUE args
     loop_nd
 */
 
-static void ndloop_alloc(na_md_loop_t* lp, ndfunc_t* nf, VALUE args, void* opt_ptr, unsigned int copy_flag,
-                         void (*loop_func)(ndfunc_t*, na_md_loop_t*)) {
+static void ndloop_alloc(
+  na_md_loop_t* lp, ndfunc_t* nf, VALUE args, void* opt_ptr, unsigned int copy_flag,
+  void (*loop_func)(ndfunc_t*, na_md_loop_t*)
+) {
   int i, j;
   int narg;
   int max_nd;
@@ -422,7 +441,6 @@ static VALUE ndloop_release(VALUE vlp) {
     }
   }
   for (j = 0; j < lp->narg; j++) {
-    // printf("lp->xargs[%d].bufcp=%lx\n",j,(size_t)(lp->xargs[j].bufcp));
     if (lp->xargs[j].bufcp) {
       xfree(lp->xargs[j].bufcp->buf_iter);
       xfree(lp->xargs[j].bufcp->buf_ptr);
@@ -456,7 +474,10 @@ static void ndloop_check_shape(na_md_loop_t* lp, int nf_dim, narray_t* na) {
         lp->n[i] = n;
       } else if (lp->n[i] != n) {
         // inconsistent array shape
-        rb_raise(nary_eShapeError, "shape1[%d](=%" SZF "u) != shape2[%d](=%" SZF "u)", i, lp->n[i], k, n);
+        rb_raise(
+          nary_eShapeError, "shape1[%d](=%" SZF "u) != shape2[%d](=%" SZF "u)", i, lp->n[i], k,
+          n
+        );
       }
     }
   }
@@ -498,7 +519,6 @@ static void ndloop_set_stepidx(na_md_loop_t* lp, int j, VALUE vna, int* dim_map,
       n = na->shape[k];
       if (n > 1 || nd > 0) {
         i = dim_map[k];
-        // printf("n=%d k=%d i=%d\n",n,k,i);
         LITER(lp, i, j).step = s;
         // LITER(lp,i,j).idx = NULL;
       }
@@ -561,16 +581,17 @@ static void ndloop_init_args(ndfunc_t* nf, na_md_loop_t* lp, VALUE args) {
       GetNArray(v, na);
       nf_dim = nf->ain[j].dim;
       if (nf_dim > na->ndim) {
-        rb_raise(nary_eDimensionError,
-                 "requires >= %d-dimensioal array "
-                 "while %d-dimensional array is given",
-                 nf_dim, na->ndim);
+        rb_raise(
+          nary_eDimensionError,
+          "requires >= %d-dimensioal array "
+          "while %d-dimensional array is given",
+          nf_dim, na->ndim
+        );
       }
       ndloop_check_shape(lp, nf_dim, na);
       dim_beg = lp->ndim + nf->ain[j].dim - na->ndim;
       for (i = 0; i < na->ndim; i++) {
         dim_map[i] = lp->trans_map[i + dim_beg];
-        // printf("dim_map[%d]=%d na->shape[%d]=%d\n",i,dim_map[i],i,na->shape[i]);
       }
       if (nf->ain[j].type == OVERWRITE) {
         lp->xargs[j].flag = flag = NDL_WRITE;
@@ -624,7 +645,9 @@ static int ndloop_check_inplace(VALUE type, int na_ndim, size_t* na_shape, VALUE
   return 1;
 }
 
-static VALUE ndloop_find_inplace(ndfunc_t* nf, na_md_loop_t* lp, VALUE type, int na_ndim, size_t* na_shape, VALUE args) {
+static VALUE ndloop_find_inplace(
+  ndfunc_t* nf, na_md_loop_t* lp, VALUE type, int na_ndim, size_t* na_shape, VALUE args
+) {
   int j;
   VALUE v;
 
@@ -673,7 +696,8 @@ static VALUE ndloop_get_arg_type(ndfunc_t* nf, VALUE args, VALUE t) {
   return t;
 }
 
-static VALUE ndloop_set_output_narray(ndfunc_t* nf, na_md_loop_t* lp, int k, VALUE type, VALUE args) {
+static VALUE
+ndloop_set_output_narray(ndfunc_t* nf, na_md_loop_t* lp, int k, VALUE type, VALUE args) {
   int i, j;
   int na_ndim;
   int lp_dim;
@@ -687,14 +711,11 @@ static VALUE ndloop_set_output_narray(ndfunc_t* nf, na_md_loop_t* lp, int k, VAL
   na_shape = ALLOCA_N(size_t, max_nd);
   dim_map = ALLOCA_N(int, max_nd);
 
-  // printf("max_nd=%d lp->ndim=%d\n",max_nd,lp->ndim);
-
   // md-loop shape
   na_ndim = 0;
   for (i = 0; i < lp->ndim; i++) {
     // na_shape[i] == lp->n[lp->trans_map[i]]
     lp_dim = lp->trans_map[i];
-    // printf("i=%d lp_dim=%d\n",i,lp_dim);
     if (NDF_TEST(nf, NDF_CUM)) { // cumulate with shape kept
       na_shape[na_ndim] = lp->n[lp_dim];
     } else if (na_test_reduce(lp->reduce, lp_dim)) { // accumulate dimension
@@ -706,7 +727,6 @@ static VALUE ndloop_set_output_narray(ndfunc_t* nf, na_md_loop_t* lp, int k, VAL
     } else {
       na_shape[na_ndim] = lp->n[lp_dim];
     }
-    // printf("i=%d lp_dim=%d na_shape[%d]=%ld\n",i,lp_dim,i,na_shape[i]);
     dim_map[na_ndim++] = lp_dim;
     // dim_map[lp_dim] = na_ndim++;
   }
@@ -789,13 +809,11 @@ static void ndfunc_contract_loop(na_md_loop_t* lp) {
   redi = na_test_reduce(lp->reduce, 0);
 
   // for (i=0; i<lp->ndim; i++) {
-  //     printf("lp->n[%d]=%lu\n",i,lp->n[i]);
   // }
 
   for (i = 1; i < lp->ndim; i++) {
     red0 = redi;
     redi = na_test_reduce(lp->reduce, i);
-    // printf("contract i=%d reduce_cond=%d %d\n",i,red0,redi);
     if (red0 != redi) {
       continue;
     }
@@ -808,7 +826,6 @@ static void ndfunc_contract_loop(na_md_loop_t* lp) {
       }
     }
     if (success) {
-      // printf("contract i=%d-th and %d-th, lp->n[%d]=%"SZF"d, lp->n[%d]=%"SZF"d\n",
       //        i-1,i, i,lp->n[i], i-1,lp->n[i-1]);
       //  contract (i-1)-th and i-th dimension
       lp->n[i] *= lp->n[i - 1];
@@ -816,7 +833,6 @@ static void ndfunc_contract_loop(na_md_loop_t* lp) {
       for (k = i - 1; k > cnt; k--) {
         lp->n[k] = lp->n[k - 1];
       }
-      // printf("k=%d\n",k);
       for (; k >= 0; k--) {
         lp->n[k] = 1;
       }
@@ -831,7 +847,6 @@ static void ndfunc_contract_loop(na_md_loop_t* lp) {
       cnt++;
     }
   }
-  // printf("contract cnt=%d\n",cnt);
   if (cnt > 0) {
     for (j = 0; j < lp->narg; j++) {
       LITER(lp, cnt, j).pos = LITER(lp, 0, j).pos;
@@ -839,7 +854,6 @@ static void ndfunc_contract_loop(na_md_loop_t* lp) {
     }
     lp->n = &(lp->n[cnt]);
     lp->ndim -= cnt;
-    // for (i=0; i<lp->ndim; i++) {printf("lp->n[%d]=%lu\n",i,lp->n[i]);}
   }
 }
 
@@ -865,15 +879,12 @@ static void ndfunc_set_user_loop(ndfunc_t* nf, na_md_loop_t* lp) {
     }
     LARG(lp, j).ndim += ud;
     LARG(lp, j).shape = &(lp->n[lp->ndim]);
-    // printf("LARG(lp,j).ndim=%d,LARG(lp,j).shape=%lx\n",LARG(lp,j).ndim,(size_t)LARG(lp,j).shape);
   }
-  // printf("lp->reduce_dim=%d lp->user.ndim=%d lp->ndim=%d\n",lp->reduce_dim,lp->user.ndim,lp->ndim);
 
 skip_ud:
   lp->user.n = &(lp->n[lp->ndim]);
   for (j = 0; j < lp->narg; j++) {
     LARG(lp, j).iter = &LITER(lp, lp->ndim, j);
-    // printf("in ndfunc_set_user_loop: lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
   }
 }
 
@@ -907,11 +918,9 @@ static void ndfunc_set_bufcp(na_md_loop_t* lp, unsigned int loop_spec) {
       if (LARG(lp, j).shape) {
         n = LARG(lp, j).shape[i];
       } else {
-        // printf("shape is NULL\n");
         n = lp->user.n[i];
       }
       stride = sz * n;
-      // printf("{j=%d,i=%d,ndim=%d,nd=%d,idx=%lx,step=%ld,n=%ld,sz=%ld,stride=%ld}\n",j,i,ndim,nd,(size_t)src_iter[i].idx,src_iter[i].step,n,sz,stride);
       if (src_iter[i].idx) {
         f |= 2; // INDEX LOOP
         zero_step = 0;
@@ -931,7 +940,6 @@ static void ndfunc_set_bufcp(na_md_loop_t* lp, unsigned int loop_spec) {
       }
       sz = stride;
     }
-    // printf("[j=%d f=%d loop_spec=%d zero_step=%d]\n",j,f,loop_spec,zero_step);
 
     if (zero_step) {
       // no buffer needed
@@ -942,7 +950,6 @@ static void ndfunc_set_bufcp(na_md_loop_t* lp, unsigned int loop_spec) {
 
     // over loop_spec or reduce_loop is not contiguous
     if (f & loop_spec || (lp->reduce_dim > 1 && ndim > 0)) {
-      // printf("(buf,nd=%d)",nd);
       buf_iter = ALLOC_N(na_loop_iter_t, nd + 3);
       buf_shape = ALLOC_N(size_t, nd);
       buf_iter[nd].pos = 0;
@@ -967,10 +974,8 @@ static void ndfunc_set_bufcp(na_md_loop_t* lp, unsigned int loop_spec) {
       LBUFCP(lp, j)->src_iter = src_iter;
       LBUFCP(lp, j)->buf_iter = buf_iter;
       LARG(lp, j).iter = buf_iter;
-      // printf("in ndfunc_set_bufcp(1): lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
       LBUFCP(lp, j)->src_ptr = LARG(lp, j).ptr;
       LARG(lp, j).ptr = LBUFCP(lp, j)->buf_ptr = xmalloc(sz);
-      // printf("(LBUFCP(lp,%d)->buf_ptr=%lx)\n",j,(size_t)(LBUFCP(lp,j)->buf_ptr));
     }
   }
 
@@ -980,7 +985,6 @@ static void ndfunc_set_bufcp(na_md_loop_t* lp, unsigned int loop_spec) {
         src_iter = LARG(lp,j).iter;
         last_step = src_iter[ndim-1].step;
         if (lp->reduce_dim>1) {
-            //printf("(reduce_dim=%d,ndim=%d,nd=%d,n=%ld,lst=%ld)\n",lp->reduce_dim,ndim,nd,n_total,last_step);
             buf_iter = ALLOC_N(na_loop_iter_t,2);
             buf_iter[0].pos = LARG(lp,j).iter[0].pos;
             buf_iter[0].step = last_step;
@@ -989,7 +993,6 @@ static void ndfunc_set_bufcp(na_md_loop_t* lp, unsigned int loop_spec) {
             buf_iter[1].step = 0;
             buf_iter[1].idx = NULL;
             LARG(lp,j).iter = buf_iter;
-            //printf("in ndfunc_set_bufcp(2): lp->user.args[%d].iter=%lx\n",j,(size_t)(LARG(lp,j).iter));
             lp->xargs[j].free_user_iter = 1;
         }
     }
@@ -1018,7 +1021,6 @@ static void ndloop_copy_to_buffer(na_buffer_copy_t* lp) {
   size_t buf_pos = 0;
   DBG(size_t j);
 
-  // printf("\nto_buf nd=%d elmsz=%ld\n",nd,elmsz);
   DBG(printf("<to buf> ["));
   // zero-dimension
   if (nd == 0) {
@@ -1067,7 +1069,6 @@ static void ndloop_copy_from_buffer(na_buffer_copy_t* lp) {
   size_t buf_pos = 0;
   DBG(size_t j);
 
-  // printf("\nfrom_buf nd=%d elmsz=%ld\n",nd,elmsz);
   DBG(printf("<from buf> ["));
   // zero-dimension
   if (nd == 0) {
@@ -1173,7 +1174,6 @@ static VALUE ndloop_run(VALUE vlp) {
   results = ndloop_set_output(nf, lp, args);
 
   // if (na_debug_flag) {
-  //     printf("-- ndloop_set_output --\n");
   //     print_ndloop(lp);
   // }
 
@@ -1181,7 +1181,6 @@ static VALUE ndloop_run(VALUE vlp) {
   if (lp->loop_func == loop_narray) {
     ndfunc_contract_loop(lp);
     // if (na_debug_flag) {
-    //     printf("-- ndfunc_contract_loop --\n");
     //     print_ndloop(lp);
     // }
   }
@@ -1203,7 +1202,6 @@ static VALUE ndloop_run(VALUE vlp) {
   (*(lp->loop_func))(nf, lp);
 
   // if (na_debug_flag) {
-  //     printf("-- after loop --\n");
   //     print_ndloop(lp);
   // }
 
@@ -1232,14 +1230,12 @@ static void loop_narray(ndfunc_t* nf, na_md_loop_t* lp) {
   if (nd == 0) {
     for (j = 0; j < lp->nin; j++) {
       if (lp->xargs[j].bufcp) {
-        // printf("copy_to_buffer j=%d\n",j);
         ndloop_copy_to_buffer(lp->xargs[j].bufcp);
       }
     }
     (*(nf->func))(&(lp->user));
     for (j = 0; j < lp->narg; j++) {
       if (lp->xargs[j].bufcp && (lp->xargs[j].flag & NDL_WRITE)) {
-        // printf("copy_from_buffer j=%d\n",j);
         //  copy data to work buffer
         ndloop_copy_from_buffer(lp->xargs[j].bufcp);
       }
@@ -1262,14 +1258,12 @@ static void loop_narray(ndfunc_t* nf, na_md_loop_t* lp) {
         } else {
           LITER(lp, i + 1, j).pos = LITER(lp, i, j).pos + LITER(lp, i, j).step * c[i];
         }
-        // printf("j=%d c[i=%d]=%lu pos=%lu\n",j,i,c[i],LITER(lp,i+1,j).pos);
       }
     }
     for (j = 0; j < lp->nin; j++) {
       if (lp->xargs[j].bufcp) {
         // copy data to work buffer
         // cp lp->iter[j][nd..*] to lp->user.args[j].iter[0..*]
-        // printf("copy_to_buffer j=%d\n",j);
         ndloop_copy_to_buffer(lp->xargs[j].bufcp);
       }
     }
@@ -1277,7 +1271,6 @@ static void loop_narray(ndfunc_t* nf, na_md_loop_t* lp) {
     for (j = 0; j < lp->narg; j++) {
       if (lp->xargs[j].bufcp && (lp->xargs[j].flag & NDL_WRITE)) {
         // copy data to work buffer
-        // printf("copy_from_buffer j=%d\n",j);
         ndloop_copy_from_buffer(lp->xargs[j].bufcp);
       }
     }
@@ -1494,8 +1487,8 @@ na_ndloop_inspect(VALUE nary, na_text_func_t func, VALUE opt) {
   volatile VALUE args;
   na_md_loop_t lp;
   VALUE buf;
-  ndfunc_arg_in_t ain[3] = {{Qnil, 0}, {sym_loop_opt}, {sym_option}};
-  ndfunc_t nf = {(na_iter_func_t)func, NO_LOOP, 3, 0, ain, 0};
+  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };
+  ndfunc_t nf = { (na_iter_func_t)func, NO_LOOP, 3, 0, ain, 0 };
   // nf = ndfunc_alloc(NULL, NO_LOOP, 1, 0, Qnil);
 
   buf = na_info_str(nary);
@@ -1535,15 +1528,16 @@ static void loop_store_subnarray(ndfunc_t* nf, na_md_loop_t* lp, int i0, size_t*
   }
   GetNArray(a, na);
   if (na->ndim != nd - i0 + 1) {
-    rb_raise(nary_eShapeError,
-             "mismatched dimension of sub-narray: "
-             "nd_src=%d, nd_dst=%d",
-             na->ndim, nd - i0 + 1);
+    rb_raise(
+      nary_eShapeError,
+      "mismatched dimension of sub-narray: "
+      "nd_src=%d, nd_dst=%d",
+      na->ndim, nd - i0 + 1
+    );
   }
   dim_map = ALLOCA_N(int, na->ndim);
   for (i = 0; i < na->ndim; i++) {
     dim_map[i] = lp->trans_map[i + i0];
-    // printf("dim_map[i=%d] = %d, i0=%d\n", i, dim_map[i], i0);
   }
   ndloop_set_stepidx(lp, 1, a, dim_map, NDL_READ);
   LARG(lp, 1).shape = &(na->shape[na->ndim - 1]);
@@ -1609,7 +1603,6 @@ static void loop_store_rarray(ndfunc_t* nf, na_md_loop_t* lp) {
           a[i + 1] = Qnil;
         }
       } else if (IsNArray(a[i])) {
-        // printf("a[i=%d]=0x%lx\n",i,a[i]);
         loop_store_subnarray(nf, lp, i, c, a[i]);
         goto loop_next;
       } else {
@@ -1619,10 +1612,8 @@ static void loop_store_rarray(ndfunc_t* nf, na_md_loop_t* lp) {
           a[i + 1] = Qnil;
         }
       }
-      // printf("c[%d]=%lu\n",i,c[i]);
     }
 
-    // printf("a[i=%d]=0x%lx\n",i,a[i]);
     if (IsNArray(a[i])) {
       loop_store_subnarray(nf, lp, i, c, a[i]);
     } else {
@@ -1695,7 +1686,6 @@ static void loop_narray_to_rarray(ndfunc_t* nf, na_md_loop_t* lp) {
   c = ALLOCA_N(size_t, nd + 1);
   for (i = 0; i <= nd; i++) c[i] = 0;
   // c[i]=1; // for zero-dim
-  // fprintf(stderr,"in loop_narray_to_rarray, nd=%d\n",nd);
 
   a = ALLOCA_N(VALUE, nd + 1);
   a[0] = a0 = lp->loop_opt;
@@ -1780,7 +1770,6 @@ static void loop_narray_with_index(ndfunc_t* nf, na_md_loop_t* lp) {
         } else {
           LITER(lp, i + 1, j).pos = LITER(lp, i, j).pos + LITER(lp, i, j).step * c[i];
         }
-        // printf("j=%d c[i=%d]=%lu pos=%lu\n",j,i,c[i],LITER(lp,i+1,j).pos);
       }
     }
 

data/ext/numo/narray/numo/intern.h

@@ -72,7 +72,9 @@ void na_release_lock(VALUE); // currently do nothing
 
 // used in reduce methods
 #define na_reduce_dimension nary_reduce_dimension
-VALUE nary_reduce_dimension(int argc, VALUE* argv, int naryc, VALUE* naryv, ndfunc_t* ndf, na_iter_func_t nan_iter);
+VALUE nary_reduce_dimension(
+  int argc, VALUE* argv, int naryc, VALUE* naryv, ndfunc_t* ndf, na_iter_func_t nan_iter
+);
 
 #define na_reduce_options nary_reduce_options
 VALUE nary_reduce_options(VALUE axes, VALUE* opts, int naryc, VALUE* naryv, ndfunc_t* ndf);
@@ -95,13 +97,17 @@ VALUE nary_info_str(VALUE);
 #define na_test_reduce nary_test_reduce
 bool nary_test_reduce(VALUE reduce, int dim);
 
-void nary_step_array_index(VALUE self, size_t ary_size, size_t* plen, ssize_t* pbeg, ssize_t* pstep);
+void nary_step_array_index(
+  VALUE self, size_t ary_size, size_t* plen, ssize_t* pbeg, ssize_t* pstep
+);
 void nary_step_sequence(VALUE self, size_t* plen, double* pbeg, double* pstep);
 void na_parse_enumerator_step(VALUE enum_obj, VALUE* pstep);
 
 // used in aref, aset
 #define na_get_result_dimension nary_get_result_dimension
-int nary_get_result_dimension(VALUE self, int argc, VALUE* argv, ssize_t stride, size_t* pos_idx);
+int nary_get_result_dimension(
+  VALUE self, int argc, VALUE* argv, ssize_t stride, size_t* pos_idx
+);
 #define na_aref_main nary_aref_main
 VALUE nary_aref_main(int nidx, VALUE* idx, VALUE self, int keep_dim, int nd);
 

data/ext/numo/narray/numo/narray.h

@@ -13,8 +13,8 @@ extern "C" {
 #endif
 #endif
 
-#define NARRAY_VERSION "0.9.4"
-#define NARRAY_VERSION_CODE 940
+#define NARRAY_VERSION "0.9.5"
+#define NARRAY_VERSION_CODE 950
 
 #include <math.h>
 #include "numo/compat.h"
@@ -343,31 +343,31 @@ static inline narray_t* _na_get_narray_t(VALUE obj, unsigned char na_type) {
 #define NA_FL0_TEST(x, f) (NA_FLAG0(x) & (f))
 #define NA_FL1_TEST(x, f) (NA_FLAG1(x) & (f))
 
-#define NA_FL0_SET(x, f)                                                                                                       \
-  do {                                                                                                                         \
-    NA_FLAG0(x) |= (f);                                                                                                        \
+#define NA_FL0_SET(x, f) \
+  do {                   \
+    NA_FLAG0(x) |= (f);  \
   } while (0)
-#define NA_FL1_SET(x, f)                                                                                                       \
-  do {                                                                                                                         \
-    NA_FLAG1(x) |= (f);                                                                                                        \
+#define NA_FL1_SET(x, f) \
+  do {                   \
+    NA_FLAG1(x) |= (f);  \
   } while (0)
 
-#define NA_FL0_UNSET(x, f)                                                                                                     \
-  do {                                                                                                                         \
-    NA_FLAG0(x) &= ~(f);                                                                                                       \
+#define NA_FL0_UNSET(x, f) \
+  do {                     \
+    NA_FLAG0(x) &= ~(f);   \
   } while (0)
-#define NA_FL1_UNSET(x, f)                                                                                                     \
-  do {                                                                                                                         \
-    NA_FLAG1(x) &= ~(f);                                                                                                       \
+#define NA_FL1_UNSET(x, f) \
+  do {                     \
+    NA_FLAG1(x) &= ~(f);   \
   } while (0)
 
-#define NA_FL0_REVERSE(x, f)                                                                                                   \
-  do {                                                                                                                         \
-    NA_FLAG0(x) ^= (f);                                                                                                        \
+#define NA_FL0_REVERSE(x, f) \
+  do {                       \
+    NA_FLAG0(x) ^= (f);      \
   } while (0)
-#define NA_FL1_REVERSE(x, f)                                                                                                   \
-  do {                                                                                                                         \
-    NA_FLAG1(x) ^= (f);                                                                                                        \
+#define NA_FL1_REVERSE(x, f) \
+  do {                       \
+    NA_FLAG1(x) ^= (f);      \
   } while (0)
 
 /* FLAGS

data/ext/numo/narray/numo/ndloop.h

@@ -56,7 +56,7 @@ typedef struct NA_LOOP {
 #define OVERWRITE Qtrue // used for CASTABLE(t)
 
 #define NDF_TEST(nf, fl) ((nf)->flag & (fl))
-#define NDF_SET(nf, fl)                                                                                                        \
+#define NDF_SET(nf, fl) \
   { (nf)->flag |= (fl); }
 
 #define NDF_ARG_READ_ONLY 1