numo-narray 0.9.0.3 → 0.9.0.4

data/ext/numo/narray/gen/tmpl_bit/mask.c

@@ -87,6 +87,8 @@ static VALUE
     volatile VALUE idx_1, view;
     narray_data_t *nidx;
     narray_view_t *nv;
+    narray_t      *na;
+    narray_view_t *na1;
     stridx_t stridx0;
     size_t n_1;
     where_opt_t g;
@@ -112,6 +114,19 @@ static VALUE
     nv->stridx = ALLOC_N(stridx_t,1);
     nv->stridx[0] = stridx0;
     nv->offset = 0;
-    nv->data = val;
+
+    GetNArray(val, na);
+    switch(NA_TYPE(na)) {
+    case NARRAY_DATA_T:
+        nv->data = val;
+        break;
+    case NARRAY_VIEW_T:
+        GetNArrayView(val, na1);
+        nv->data = na1->data;
+        break;
+    default:
+        rb_raise(rb_eRuntimeError,"invalid NA_TYPE: %d",NA_TYPE(na));
+    }
+
     return view;
 }

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

@@ -1,5 +1,104 @@
+static void
+<%=c_iter%>(na_loop_t *const lp)
+{
+    size_t i, n;
+    size_t i1, n1;
+    VALUE  v1, *ptr;
+    BIT_DIGIT *a1;
+    size_t p1;
+    size_t s1, *idx1;
+    VALUE  x;
+    double y;
+    BIT_DIGIT z;
+    size_t len, c;
+    double beg, step;
+
+    INIT_COUNTER(lp, n);
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);
+    v1 = lp->args[1].value;
+    i = 0;
+
+    if (lp->args[1].ptr) {
+        if (v1 == Qtrue) {
+            iter_<%=tp%>_store_<%=tp%>(lp);
+            i = lp->args[1].shape[0];
+            if (idx1) {
+                idx1 += i;
+            } else {
+                p1 += s1 * i;
+            }
+        }
+        goto loop_end;
+    }
+
+    ptr = &v1;
+
+    switch(TYPE(v1)) {
+    case T_ARRAY:
+        n1 = RARRAY_LEN(v1);
+        ptr = RARRAY_PTR(v1);
+        break;
+    case T_NIL:
+        n1 = 0;
+        break;
+    default:
+        n1 = 1;
+    }
+
+    if (idx1) {
+        for (i=i1=0; i1<n1 && i<n; i++,i1++) {
+            x = ptr[i1];
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, na_cStep)) {
+                nary_step_sequence(x,&len,&beg,&step);
+                for (c=0; c<len && i<n; c++,i++) {
+                    y = beg + step * c;
+                    z = m_from_double(y);
+                    STORE_BIT(a1, p1+*idx1, z); idx1++;
+                }
+            }
+            if (TYPE(x) != T_ARRAY) {
+                if (x == Qnil) x = INT2FIX(0);
+                z = m_num_to_data(x);
+                STORE_BIT(a1, p1+*idx1, z); idx1++;
+            }
+        }
+    } else {
+        for (i=i1=0; i1<n1 && i<n; i++,i1++) {
+            x = ptr[i1];
+            if (rb_obj_is_kind_of(x, rb_cRange) || rb_obj_is_kind_of(x, na_cStep)) {
+                nary_step_sequence(x,&len,&beg,&step);
+                for (c=0; c<len && i<n; c++,i++) {
+                    y = beg + step * c;
+                    z = m_from_double(y);
+                    STORE_BIT(a1, p1, z); p1+=s1;
+                }
+            }
+            if (TYPE(x) != T_ARRAY) {
+                z = m_num_to_data(x);
+                STORE_BIT(a1, p1, z); p1+=s1;
+            }
+        }
+    }
+
+ loop_end:
+    z = m_zero;
+    if (idx1) {
+        for (; i<n; i++) {
+            STORE_BIT(a1, p1+*idx1, z); idx1++;
+        }
+    } else {
+        for (; i<n; i++) {
+            STORE_BIT(a1, p1, z); p1+=s1;
+        }
+    }
+}
+
 static VALUE
-<%=c_func%>(VALUE self, VALUE obj)
+<%=c_func%>(VALUE self, VALUE rary)
 {
-    return <%=find_tmpl("store").c_func%>(self,<%=find_tmpl("cast_array").c_func%>(obj));
+    ndfunc_arg_in_t ain[2] = {{OVERWRITE,0}, {rb_cArray,0}};
+    ndfunc_t ndf = {<%=c_iter%>, FULL_LOOP, 2, 0, ain, 0};
+
+    na_ndloop_store_rarray(&ndf, self, rary);
+    return self;
 }

data/ext/numo/narray/gen/tmpl_bit/where.c

@@ -16,14 +16,13 @@ iter_bit_where(na_loop_t *const lp)
     ssize_t s;
     size_t *idx;
     BIT_DIGIT x=0;
-    char   *idx0, *idx1;
+    char   *idx1;
     size_t  count;
     size_t  e;
     where_opt_t *g;
 
     g = (where_opt_t*)(lp->opt_ptr);
     count = g->count;
-    idx0  = g->idx0;
     idx1  = g->idx1;
     e     = g->elmsz;
     INIT_COUNTER(lp, i);
@@ -32,16 +31,9 @@ iter_bit_where(na_loop_t *const lp)
         for (; i--;) {
             LOAD_BIT(a, p+*idx, x);
             idx++;
-            if (x==0) {
-                if (idx0) {
-                    STORE_INT(idx0,e,count);
-                    idx0 += e;
-                }
-            } else {
-                if (idx1) {
-                    STORE_INT(idx1,e,count);
-                    idx1 += e;
-                }
+            if (x!=0) {
+                STORE_INT(idx1,e,count);
+                idx1 += e;
             }
             count++;
         }
@@ -49,22 +41,14 @@ iter_bit_where(na_loop_t *const lp)
         for (; i--;) {
             LOAD_BIT(a, p, x);
             p+=s;
-            if (x==0) {
-                if (idx0) {
-                    STORE_INT(idx0,e,count);
-                    idx0 += e;
-                }
-            } else {
-                if (idx1) {
-                    STORE_INT(idx1,e,count);
-                    idx1 += e;
-                }
+            if (x!=0) {
+                STORE_INT(idx1,e,count);
+                idx1 += e;
             }
             count++;
         }
     }
     g->count = count;
-    g->idx0  = idx0;
     g->idx1  = idx1;
 }
 

data/ext/numo/narray/gen/tmpl_bit/where2.c

@@ -1,3 +1,56 @@
+static void
+iter_bit_where2(na_loop_t *const lp)
+{
+    size_t  i;
+    BIT_DIGIT *a;
+    size_t  p;
+    ssize_t s;
+    size_t *idx;
+    BIT_DIGIT x=0;
+    char   *idx0, *idx1;
+    size_t  count;
+    size_t  e;
+    where_opt_t *g;
+
+    g = (where_opt_t*)(lp->opt_ptr);
+    count = g->count;
+    idx0  = g->idx0;
+    idx1  = g->idx1;
+    e     = g->elmsz;
+    INIT_COUNTER(lp, i);
+    INIT_PTR_BIT_IDX(lp, 0, a, p, s, idx);
+    if (idx) {
+        for (; i--;) {
+            LOAD_BIT(a, p+*idx, x);
+            idx++;
+            if (x==0) {
+                STORE_INT(idx0,e,count);
+                idx0 += e;
+            } else {
+                STORE_INT(idx1,e,count);
+                idx1 += e;
+            }
+            count++;
+        }
+    } else {
+        for (; i--;) {
+            LOAD_BIT(a, p, x);
+            p+=s;
+            if (x==0) {
+                STORE_INT(idx0,e,count);
+                idx0 += e;
+            } else {
+                STORE_INT(idx1,e,count);
+                idx1 += e;
+            }
+            count++;
+        }
+    }
+    g->count = count;
+    g->idx0  = idx0;
+    g->idx1  = idx1;
+}
+
 /*
   Returns two index arrays.
   The first array contains index where the bit is one (true).
@@ -9,23 +62,24 @@ static VALUE
 numo_bit_where2(VALUE self)
 {
     VALUE idx_1, idx_0;
-    size_t size, n_1;
+    size_t size, n_1, n_0;
     where_opt_t *g;
 
     ndfunc_arg_in_t ain[1] = {{cT,0}};
-    ndfunc_t ndf = { iter_bit_where, FULL_LOOP, 1, 0, ain, 0 };
+    ndfunc_t ndf = { iter_bit_where2, FULL_LOOP, 1, 0, ain, 0 };
 
     size = RNARRAY_SIZE(self);
     n_1 = NUM2SIZET(numo_bit_count_true(0, NULL, self));
+    n_0 = size - n_1;
     g = ALLOCA_N(where_opt_t,1);
     g->count = 0;
     if (size>4294967295ul) {
         idx_1 = rb_narray_new(numo_cInt64, 1, &n_1);
-        idx_0 = rb_narray_new(numo_cInt64, 1, &n_1);
+        idx_0 = rb_narray_new(numo_cInt64, 1, &n_0);
         g->elmsz = 8;
     } else {
         idx_1 = rb_narray_new(numo_cInt32, 1, &n_1);
-        idx_0 = rb_narray_new(numo_cInt32, 1, &n_1);
+        idx_0 = rb_narray_new(numo_cInt32, 1, &n_0);
         g->elmsz = 4;
     }
     g->idx1 = na_get_pointer_for_write(idx_1);

data/ext/numo/narray/index.c

@@ -2,11 +2,6 @@
   index.c
   Numerical Array Extension for Ruby
     (C) Copyright 1999-2016 by Masahiro TANAKA
-
-  This program is free software.
-  You can distribute/modify this program
-  under the same terms as Ruby itself.
-  NO WARRANTY.
 */
 //#define NARRAY_C
 
@@ -21,6 +16,24 @@
 #define cIndex numo_cInt32
 #endif
 
+// from ruby/enumerator.c
+struct enumerator {
+    VALUE obj;
+    ID    meth;
+    VALUE args;
+    // use only above in this source
+    VALUE fib;
+    VALUE dst;
+    VALUE lookahead;
+    VALUE feedvalue;
+    VALUE stop_exc;
+    VALUE size;
+    // incompatible below depending on ruby version
+    //VALUE procs;                      // ruby 2.4
+    //rb_enumerator_size_func *size_fn; // ruby 2.1-2.4
+    //VALUE (*size_fn)(ANYARGS);        // ruby 2.0
+};
+
 // note: the memory refed by this pointer is not freed and causes memroy leak.
 typedef struct {
     size_t  n; // the number of elements of the dimesnion
@@ -58,49 +71,10 @@ static VALUE sym_plus;
 static VALUE sym_sum;
 static VALUE sym_tilde;
 static VALUE sym_rest;
-static VALUE id_beg;
-static VALUE id_end;
-static VALUE id_exclude_end;
-
-static int
-na_index_preprocess(VALUE args, int na_ndim)
-{
-    int i;
-    int count_new=0, count_rest=0;
-    int count_other_indices;
-    int nidx = RARRAY_LEN(args);
-    VALUE a;
-
-    for (i=0; i<nidx; i++) {
-        a = rb_ary_entry(args, i);
-
-        if (a==sym_new || a==sym_minus) {
-            RARRAY_ASET(args, i, sym_new);
-            count_new++;
-        } else if (a==sym_rest || a==sym_tilde || a==Qfalse) {
-            RARRAY_ASET(args, i, Qfalse);
-            count_rest++;
-        }
-    }
-
-    count_other_indices = nidx - count_new - count_rest;
-
-    if (count_rest>1) {
-        rb_raise(rb_eIndexError,"multiple rest-dimension is not allowd");
-    }
-    else if (count_rest==0) {
-        // if (!(count_new==0 && nidx==1) && ..
-        if (count_other_indices != 1 && count_other_indices != na_ndim)
-            rb_raise(rb_eIndexError,"# of index(=%i) should be one or "
-                     "equal to narray.ndim(=%i)",count_rest,na_ndim);
-    }
-    else if (count_rest==1) {
-        if (count_other_indices >= na_ndim)
-            rb_raise(rb_eIndexError,"# of index(=%i) >= narray.ndim(=%i) with :rest",
-                     count_other_indices,na_ndim);
-    }
-    return count_new;
-}
+static ID id_beg;
+static ID id_end;
+static ID id_exclude_end;
+static ID id_each, id_step;
 
 
 void
@@ -114,7 +88,6 @@ na_index_set_step(na_index_arg_t *q, int i, size_t n, size_t beg, ssize_t step)
     q->orig_dim = i;
 }
 
-
 void
 na_index_set_scalar(na_index_arg_t *q, int i, ssize_t size, ssize_t x)
 {
@@ -167,18 +140,24 @@ na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, na_index_arg_t *q)
     VALUE idx;
     narray_t *na;
     narray_data_t *nidx;
+    size_t k, n;
+    ssize_t *nidxp;
 
     GetNArray(a,na);
     if (NA_NDIM(na) != 1) {
         rb_raise(rb_eIndexError, "should be 1-d NArray");
     }
-    idx = rb_narray_new(cIndex,1,&NA_SIZE(na));
+    n = NA_SIZE(na);
+    idx = rb_narray_new(cIndex,1,&n);
     na_store(idx,a);
 
     GetNArrayData(idx,nidx);
-    q->idx  = (size_t*)nidx->ptr;
-    nidx->ptr = NULL;
-    q->n    = na->size;
+    nidxp   = (ssize_t*)nidx->ptr;
+    q->idx  = ALLOC_N(size_t, n);
+    for (k=0; k<n; k++) {
+        q->idx[k] = na_range_check(nidxp[k], size, orig_dim);
+    }
+    q->n    = n;
     q->beg  = 0;
     q->step = 1;
     q->reduce = 0;
@@ -186,7 +165,7 @@ na_parse_narray_index(VALUE a, int orig_dim, ssize_t size, na_index_arg_t *q)
 }
 
 static void
-na_parse_range(VALUE range, int orig_dim, ssize_t size, na_index_arg_t *q)
+na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, na_index_arg_t *q)
 {
     int n;
     ssize_t beg, end;
@@ -210,10 +189,44 @@ na_parse_range(VALUE range, int orig_dim, ssize_t size, na_index_arg_t *q)
                  "beg=%"SZF"d,end=%"SZF"d is out of array size (%"SZF"d)",
                  beg, end, size);
     }
-    n = end-beg+1;
+    n = (end-beg)/step+1;
     if (n<0) n=0;
-    na_index_set_step(q,orig_dim,n,beg,1);
+    na_index_set_step(q,orig_dim,n,beg,step);
+
+}
+
+static void
+na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, na_index_arg_t *q)
+{
+    int len;
+    ssize_t step;
+    struct enumerator *e;
+
+    if (!RB_TYPE_P(enum_obj, T_DATA)) {
+        rb_raise(rb_eTypeError,"wrong argument type (not T_DATA)");
+    }
+    e = (struct enumerator *)DATA_PTR(enum_obj);
 
+    if (rb_obj_is_kind_of(e->obj, rb_cRange)) {
+        if (e->meth == id_each) {
+            na_parse_range(e->obj, 1, orig_dim, size, q);
+        }
+        else if (e->meth == id_step) {
+            if (TYPE(e->args) != T_ARRAY) {
+                rb_raise(rb_eArgError,"no argument for step");
+            }
+            len = RARRAY_LEN(e->args);
+            if (len != 1) {
+                rb_raise(rb_eArgError,"invalid number of step argument (1 for %d)",len);
+            }
+            step = NUM2SSIZET(RARRAY_AREF(e->args,0));
+            na_parse_range(e->obj, step, orig_dim, size, q);
+        } else {
+            rb_raise(rb_eTypeError,"unknown Range method: %s",rb_id2name(e->meth));
+        }
+    } else {
+        rb_raise(rb_eTypeError,"not Range object");
+    }
 }
 
 // Analyze *a* which is *i*-th index object and store the information to q
@@ -268,7 +281,10 @@ na_index_parse_each(volatile VALUE a, ssize_t size, int i, na_index_arg_t *q)
 
     default:
         if (rb_obj_is_kind_of(a, rb_cRange)) {
-            na_parse_range(a, i, size, q);
+            na_parse_range(a, 1, i, size, q);
+        }
+        else if (rb_obj_is_kind_of(a, rb_cEnumerator)) {
+            na_parse_enumerator(a, i, size, q);
         }
         else if (rb_obj_is_kind_of(a, na_cStep)) {
             ssize_t beg, step, n;
@@ -297,9 +313,10 @@ na_index_parse_args(VALUE args, narray_t *na, na_index_arg_t *q, int ndim)
 
     for (i=j=k=0; i<nidx; i++) {
         v = RARRAY_AREF(args,i);
-        // rest dimension
+        // rest (ellipsis) dimension
         if (v==Qfalse) {
             for (l = ndim - (nidx-1); l>0; l--) {
+                //printf("i=%d j=%d k=%d l=%d ndim=%d nidx=%d\n",i,j,k,l,ndim,nidx);
                 na_index_parse_each(Qtrue, na->shape[k], k, &q[j]);
                 if (q[j].n > 1) {
                     total *= q[j].n;
@@ -555,8 +572,9 @@ VALUE na_aref_md_protected(VALUE data_value)
         na2->data = self;
         break;
     case NARRAY_VIEW_T:
-        na_index_aref_naview((narray_view_t *)na1,na2,q,ndim,keep_dim);
+        na2->offset = ((narray_view_t *)na1)->offset;
         na2->data = ((narray_view_t *)na1)->data;
+        na_index_aref_naview((narray_view_t *)na1,na2,q,ndim,keep_dim);
         break;
     }
     if (store) {
@@ -580,11 +598,10 @@ na_aref_md_ensure(VALUE data_value)
 }
 
 VALUE
-na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim)
+na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd)
 {
     VALUE args; // should be GC protected
     narray_t *na1;
-    int count_new, ndim;
     na_aref_md_data_t data;
     VALUE store = 0;
     VALUE idx;
@@ -592,14 +609,10 @@ na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim)
 
     GetNArray(self,na1);
 
-    //printf("argc=%d\n",argc);
-
     args = rb_ary_new4(argc,argv);
 
-    count_new = na_index_preprocess(args, na1->ndim);
-
-    if (RARRAY_LEN(args)==1) {
-        idx = RARRAY_AREF(args,0);
+    if (argc == 1 && result_nd == 1) {
+        idx = argv[0];
         if (rb_obj_is_kind_of(idx, rb_cArray)) {
             idx = rb_apply(numo_cNArray,rb_intern("[]"),idx);
         }
@@ -612,16 +625,17 @@ na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim)
             }
         }
         // flatten should be done only for narray-view with non-uniform stride.
-        self = na_flatten(self);
-        GetNArray(self,na1);
+        if (na1->ndim > 1) {
+            self = na_flatten(self);
+            GetNArray(self,na1);
+        }
     }
-    ndim = na1->ndim + count_new;
 
     data.args = args;
     data.self = self;
     data.store = store;
-    data.ndim = ndim;
-    data.q = na_allocate_index_args(ndim);
+    data.ndim = result_nd;
+    data.q = na_allocate_index_args(result_nd);
     data.na1 = na1;
     data.keep_dim = keep_dim;
 
@@ -629,11 +643,9 @@ na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim)
 }
 
 
-
-
 /* method: [](idx1,idx2,...,idxN) */
 VALUE
-na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim)
+na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int nd)
 {
     na_index_arg_to_internal_order(nidx, idx, self);
 
@@ -645,118 +657,111 @@ na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim)
             return rb_funcall(*idx,rb_intern("mask"),1,self);
         }
     }
-    return na_aref_md(nidx, idx, self, keep_dim);
-}
-
-
-/* method: [](idx1,idx2,...,idxN) */
-static VALUE na_aref(int argc, VALUE *argv, VALUE self)
-{
-    VALUE view;
-    view = na_aref_main(argc, argv, self, 0);
-    return rb_funcall(view, rb_intern("extract"), 0);
+    return na_aref_md(nidx, idx, self, keep_dim, nd);
 }
 
 
 /* method: slice(idx1,idx2,...,idxN) */
 static VALUE na_slice(int argc, VALUE *argv, VALUE self)
 {
-    return na_aref_main(argc, argv, self, 1);
-}
-
-
-
+    int nd;
+    size_t pos;
 
-/* method: []=(idx1,idx2,...,idxN,val) */
-static VALUE
-na_aset(int argc, VALUE *argv, VALUE self)
-{
-    VALUE a;
-    argc--;
-
-    if (argc==0)
-        na_store(self, argv[argc]);
-    else {
-        a = na_aref_main(argc, argv, self, 0);
-        na_store(a, argv[argc]);
-    }
-    return argv[argc];
+    nd = na_get_result_dimension(self, argc, argv, 0, &pos);
+    return na_aref_main(argc, argv, self, 1, nd);
 }
 
 
-// convert reduce dims to 0-th element
-// for initialization of min/max func
-// ['*,+,*'] -> [true,0,true]
-VALUE nary_init_accum_aref0(VALUE self, VALUE reduce)
+static int
+check_index_count(int argc, int na_ndim, int count_new, int count_rest)
 {
-    narray_t *na;
-    VALUE a;
-    ID id_bra;
-    unsigned long m;
-    int i, ndim;
-
-    GetNArray(self,na);
-    ndim = na->ndim;
-    a = rb_ary_new();
-    if (FIXNUM_P(reduce)) {
-        m = NUM2ULONG(reduce);
-        if (m==0)
-            for (i=0; i<ndim; i++)
-                rb_ary_push(a,INT2FIX(0));
-        else
-            for (i=0; i<ndim; i++)
-                if ((m>>i) & 1u)
-                    rb_ary_push(a,INT2FIX(0));
-                else
-                    rb_ary_push(a,Qtrue);
-    } else {
-        id_bra = rb_intern("[]");
-        for (i=0; i<ndim; i++)
-            if (rb_funcall(reduce,id_bra,1,INT2FIX(i)) == INT2FIX(1))
-                rb_ary_push(a,INT2FIX(0));
-            else
-                rb_ary_push(a,Qtrue);
+    int result_nd = na_ndim + count_new;
+
+    switch(count_rest) {
+    case 0:
+        if (count_new == 0 && argc == 1) return 1;
+        if (argc == result_nd) return result_nd;
+        rb_raise(rb_eIndexError,"# of index(=%i) should be "
+                 "equal to ndim(=%i)",argc,na_ndim);
+        break;
+    case 1:
+        if (argc-1 <= result_nd) return result_nd;
+        rb_raise(rb_eIndexError,"# of index(=%i) > ndim(=%i) with :rest",
+                 argc,na_ndim);
+        break;
     }
-    return na_aref_md(RARRAY_LEN(a), RARRAY_PTR(a), self, 0);
+    return -1;
 }
 
-
-ssize_t
-na_get_scalar_position(VALUE self, int argc, VALUE *argv, ssize_t stride)
+int
+na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx)
 {
-    int i;
+    int i, j;
+    int count_new=0;
+    int count_rest=0;
+    int count_else=0;
     ssize_t x, s, m, pos, *idx;
     narray_t *na;
     narray_view_t *nv;
     stridx_t sdx;
+    VALUE a;
 
     GetNArray(self,na);
     if (na->size == 0) {
         rb_raise(rb_eRuntimeError, "cannot get index of empty array");
         return -1;
     }
-    if (argc != 1 && argc != na->ndim) {
-        return -1;
-    }
     idx = ALLOCA_N(ssize_t, argc);
-    for (i=0; i<argc; i++) {
-        switch(TYPE(argv[i])) {
+    for (i=j=0; i<argc; i++) {
+        a = argv[i];
+        switch(TYPE(a)) {
         case T_FIXNUM:
-            idx[i] = FIX2LONG(argv[i]);
+            idx[j++] = FIX2LONG(a);
             break;
         case T_BIGNUM:
         case T_FLOAT:
-            idx[i] = NUM2SSIZET(argv[i]);
+            idx[j++] = NUM2SSIZET(a);
             break;
+        case T_FALSE:
+        case T_SYMBOL:
+            if (a==sym_rest || a==sym_tilde || a==Qfalse) {
+                argv[i] = Qfalse;
+                count_rest++;
+                break;
+            } else if (a==sym_new || a==sym_minus) {
+                argv[i] = sym_new;
+                count_new++;
+            }
+            // not break
         default:
-            return -1;
+            count_else++;
         }
     }
+
+    if (count_rest > 1) {
+        rb_raise(rb_eIndexError,"multiple rest-dimension is not allowd");
+    }
+    if (count_else != 0) {
+        return check_index_count(argc, na->ndim, count_new, count_rest);
+    }
+
     switch(na->type) {
     case NARRAY_VIEW_T:
         GetNArrayView(self,nv);
         pos = nv->offset;
-        if (argc==1) {
+        if (j == na->ndim) {
+            for (i=j-1; i>=0; i--) {
+                x = na_range_check(idx[i], na->shape[i], i);
+                sdx = nv->stridx[i];
+                if (SDX_IS_INDEX(sdx)) {
+                    pos += SDX_GET_INDEX(sdx)[x];
+                } else {
+                    pos += SDX_GET_STRIDE(sdx)*x;
+                }
+            }
+            *pos_idx = pos;
+        }
+        else if (argc==1 && j==1) {
             x = na_range_check(idx[0], na->size, 0);
             for (i=na->ndim-1; i>=0; i--) {
                 s = na->shape[i];
@@ -769,44 +774,39 @@ na_get_scalar_position(VALUE self, int argc, VALUE *argv, ssize_t stride)
                     pos += SDX_GET_STRIDE(sdx)*m;
                 }
             }
+            *pos_idx = pos;
         } else {
-            for (i=argc-1; i>=0; i--) {
-                x = na_range_check(idx[i], na->shape[i], i);
-                sdx = nv->stridx[i];
-                if (SDX_IS_INDEX(sdx)) {
-                    pos += SDX_GET_INDEX(sdx)[x];
-                } else {
-                    pos += SDX_GET_STRIDE(sdx)*x;
-                }
-            }
+            return check_index_count(argc, na->ndim, count_new, count_rest);
         }
         break;
     default:
         if (!stride) {
             stride = na_get_elmsz(self);
         }
-        if (argc==1) {
+        if (argc==1 && j==1) {
             x = na_range_check(idx[0], na->size, 0);
-            pos = stride*x;
-        } else {
+            *pos_idx = stride * x;
+        }
+        else if (j == na->ndim) {
             pos = 0;
-            for (i=argc-1; i>=0; i--) {
+            for (i=j-1; i>=0; i--) {
                 x = na_range_check(idx[i], na->shape[i], i);
-                pos += stride*x;
+                pos += stride * x;
                 stride *= na->shape[i];
             }
+            *pos_idx = pos;
+        } else {
+            return check_index_count(argc, na->ndim, count_new, count_rest);
         }
     }
-    return pos;
+    return 0;
 }
 
 
 void
 Init_nary_index()
 {
-    rb_define_method(cNArray, "[]", na_aref, -1);
     rb_define_method(cNArray, "slice", na_slice, -1);
-    rb_define_method(cNArray, "[]=", na_aset, -1);
 
     sym_ast = ID2SYM(rb_intern("*"));
     sym_all = ID2SYM(rb_intern("all"));
@@ -821,4 +821,6 @@ Init_nary_index()
     id_beg = rb_intern("begin");
     id_end = rb_intern("end");
     id_exclude_end = rb_intern("exclude_end?");
+    id_each = rb_intern("each");
+    id_step = rb_intern("step");
 }