cumo 0.4.3 → 0.5.0

data/ext/cumo/narray/gen/tmpl_bit/unary.c

@@ -24,8 +24,7 @@ static void
             CUMO_STORE_BIT_STEP(a3, p3, s3, idx3, y);
         }
     } else {
-        o1 =  p1 % CUMO_NB;
-        o1 -= p3;
+        o1 =  p1-p3;
         l1 =  CUMO_NB+o1;
         r1 =  CUMO_NB-o1;
         if (p3>0 || n<CUMO_NB) {
@@ -48,17 +47,32 @@ static void
             }
         } else {
             for (; n>=CUMO_NB; n-=CUMO_NB) {
-                x = *a1>>o1;
-                if (o1<0)  x |= *(a1-1)>>l1;
-                if (o1>0)  x |= *(a1+1)<<r1;
+                if (o1==0) {
+                    x = *a1;
+                } else if (o1>0) {
+                    x = *a1>>o1  | *(a1+1)<<r1;
+                } else {
+                    x = *a1<<-o1 | *(a1-1)>>l1;
+                }
                 a1++;
                 y = m_<%=name%>(x);
                 *(a3++) = y;
             }
         }
         if (n>0) {
-            x = *a1>>o1;
-            if (o1<0)  x |= *(a1-1)>>l1;
+            if (o1==0) {
+                x = *a1;
+            } else if (o1>0) {
+                x = *a1>>o1;
+                if ((int)n>r1) {
+                    x |= *(a1+1)<<r1;
+                }
+            } else {
+                x = *(a1-1)>>l1;
+                if ((int)n>-o1) {
+                    x |= *a1<<-o1;
+                }
+            }
             y = m_<%=name%>(x);
             *a3 = (y & CUMO_SLB(n)) | (*a3 & CUMO_BALL<<n);
         }

data/ext/cumo/narray/index.c

@@ -183,7 +183,6 @@ static void
 cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_na_index_arg_t *q)
 {
     int n;
-    VALUE excl_end;
     ssize_t beg, end, beg_orig, end_orig;
     const char *dot = "..", *edot = "...";
 
@@ -197,10 +196,15 @@ cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_
         beg += size;
     }
     if (T_NIL == TYPE(x.end)) { // endless range
-        end = size -1;
+        end = size - 1;
         if (RTEST(x.exclude_end)) {
             dot = edot;
         }
+        if (beg < 0 || beg >= size) {
+            rb_raise(rb_eRangeError,
+                     "%"SZF"d%s is out of range for size=%"SZF"d",
+                     beg_orig, dot, size);
+        }
     } else {
         end = end_orig = NUM2SSIZET(x.end);
         if (end < 0) {
@@ -210,19 +214,15 @@ cumo_na_parse_range(VALUE range, ssize_t step, int orig_dim, ssize_t size, cumo_
             end--;
             dot = edot;
         }
-    }
-    if (beg < 0 || beg >= size || end < 0 || end >= size) {
-        if (T_NIL == TYPE(x.end)) { // endless range
-            rb_raise(rb_eRangeError,
-                     "%"SZF"d%s is out of range for size=%"SZF"d",
-                     beg_orig, dot, size);
-        } else {
+        if (beg < 0 || beg >= size || end < 0 || end >= size) {
             rb_raise(rb_eRangeError,
                      "%"SZF"d%s%"SZF"d is out of range for size=%"SZF"d",
                      beg_orig, dot, end_orig, size);
         }
     }
 #else
+    VALUE excl_end;
+
     beg = beg_orig = NUM2SSIZET(rb_funcall(range,cumo_id_beg,0));
     if (beg < 0) {
         beg += size;
@@ -258,7 +258,7 @@ cumo_na_parse_enumerator_step(VALUE enum_obj, VALUE *pstep)
     if (!RB_TYPE_P(enum_obj, T_DATA)) {
         rb_raise(rb_eTypeError,"wrong argument type (not T_DATA)");
     }
-    e = (cumo_enumerator_t *)DATA_PTR(enum_obj);
+    e = CUMO_RENUMERATOR_PTR(enum_obj);
 
     if (!rb_obj_is_kind_of(e->obj, rb_cRange)) {
         rb_raise(rb_eTypeError,"not Range object");
@@ -292,7 +292,7 @@ cumo_na_parse_enumerator(VALUE enum_obj, int orig_dim, ssize_t size, cumo_na_ind
         rb_raise(rb_eTypeError,"wrong argument type (not T_DATA)");
     }
     cumo_na_parse_enumerator_step(enum_obj, &step);
-    e = (cumo_enumerator_t *)DATA_PTR(enum_obj);
+    e = CUMO_RENUMERATOR_PTR(enum_obj);
     cumo_na_parse_range(e->obj, NUM2SSIZET(step), orig_dim, size, q); // e->obj : Range Object
 }
 
@@ -568,6 +568,188 @@ cumo_na_index_aref_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
     na2->base.size = total;
 }
 
+void cumo_na_index_at_nadata_index_stride_add_kernel_launch(size_t *idx, size_t *idx1, ssize_t s1, uint64_t n);
+void cumo_na_index_at_nadata_index_beg_step_stride_kernel_launch(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n);
+void cumo_na_index_at_nadata_index_beg_step_stride_add_kernel_launch(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n);
+
+static void
+cumo_na_index_at_nadata(cumo_narray_data_t *na1, cumo_narray_view_t *na2,
+                     cumo_na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
+{
+    int i;
+    size_t size = q[ndim-1].n;
+    ssize_t stride1;
+    ssize_t *strides_na1;
+    size_t  *index;
+    ssize_t beg, step;
+    int use_cumo_cuda_runtime_malloc = 0;
+
+    strides_na1 = ALLOCA_N(ssize_t, na1->base.ndim);
+    cumo_na_get_strides_nadata(na1, strides_na1, elmsz);
+
+    if (q[ndim-1].idx != NULL) {
+        index = q[ndim-1].idx;
+    } else {
+        //index = ALLOC_N(size_t, size);
+        index = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*size);
+        use_cumo_cuda_runtime_malloc = 1;
+    }
+    CUMO_SDX_SET_INDEX(na2->stridx[0], index);
+
+    for (i=ndim-1; i>=0; i--) {
+        stride1 = strides_na1[q[i].orig_dim];
+        if (i==ndim-1) {
+            if (size == 0) {
+                rb_raise(cumo_na_eShapeError, "cannot get element of empty array");
+            }
+        } else {
+            if (size != q[i].n) {
+                rb_raise(cumo_na_eShapeError, "index array sizes mismatch");
+            }
+        }
+
+        if (q[i].idx != NULL) {
+            if (i==ndim-1) {
+                cumo_na_index_aref_nadata_index_stride_kernel_launch(index, stride1, size);
+                q[i].idx = NULL;
+            } else {
+                cumo_na_index_at_nadata_index_stride_add_kernel_launch(index, q[i].idx, stride1, size);
+            }
+        } else {
+            beg  = q[i].beg;
+            step = q[i].step;
+            if (i==ndim-1) {
+                cumo_na_index_at_nadata_index_beg_step_stride_kernel_launch(index, beg, step, stride1, size);
+            } else {
+                cumo_na_index_at_nadata_index_beg_step_stride_add_kernel_launch(index, beg, step, stride1, size);
+            }
+        }
+
+    }
+    na2->base.size = size;
+    na2->base.shape[0] = size;
+    if (use_cumo_cuda_runtime_malloc) {
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("index", "cumo_na_index_at_nadata");
+        cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    }
+}
+
+void cumo_na_index_at_naview_index_index_index_add_kernel_launch(size_t *idx, size_t *idx1, size_t *idx2, uint64_t n);
+void cumo_na_index_at_naview_index_index_beg_step_add_kernel_launch(size_t *idx, size_t *idx1, size_t beg, ssize_t step, uint64_t n);
+void cumo_na_index_at_naview_index_stride_last_add_kernel_launch(size_t *idx, ssize_t s1, size_t last, uint64_t n);
+
+static void
+cumo_na_index_at_naview(cumo_narray_view_t *na1, cumo_narray_view_t *na2,
+                     cumo_na_index_arg_t *q, ssize_t elmsz, int ndim, int keep_dim)
+{
+    int i;
+    size_t  *index;
+    size_t size = q[ndim-1].n;
+    int use_cumo_cuda_runtime_malloc = 0;
+
+    if (q[ndim-1].idx != NULL) {
+        index = q[ndim-1].idx;
+    } else {
+        //index = ALLOC_N(size_t, size);
+        index = (size_t*)cumo_cuda_runtime_malloc(sizeof(size_t)*size);
+        use_cumo_cuda_runtime_malloc = 1;
+    }
+    CUMO_SDX_SET_INDEX(na2->stridx[0], index);
+
+    for (i=ndim-1; i>=0; i--) {
+        cumo_stridx_t sdx1 = na1->stridx[q[i].orig_dim];
+        if (i==ndim-1) {
+            if (size == 0) {
+                rb_raise(cumo_na_eShapeError, "cannot get element of empty array");
+            }
+        } else {
+            if (size != q[i].n) {
+                rb_raise(cumo_na_eShapeError, "index array sizes mismatch");
+            }
+        }
+
+        if (q[i].idx != NULL && CUMO_SDX_IS_INDEX(sdx1)) {
+            // index <- index
+            size_t *index1 = CUMO_SDX_GET_INDEX(sdx1);
+            if (i==ndim-1) {
+                cumo_na_index_aref_naview_index_index_kernel_launch(index, index1, size);
+                q[i].idx = NULL;
+            } else {
+                cumo_na_index_at_naview_index_index_index_add_kernel_launch(index, index1, q[i].idx, size);
+            }
+        }
+        else if (q[i].idx == NULL && CUMO_SDX_IS_INDEX(sdx1)) {
+            // step <- index
+            size_t beg  = q[i].beg;
+            ssize_t step = q[i].step;
+            size_t *index1 = CUMO_SDX_GET_INDEX(sdx1);
+            if (i==ndim-1) {
+                cumo_na_index_aref_naview_index_index_beg_step_kernel_launch(index, index1, beg, step, size);
+            } else {
+                cumo_na_index_at_naview_index_index_beg_step_add_kernel_launch(index, index1, beg, step, size);
+            }
+        }
+        else if (q[i].idx != NULL && CUMO_SDX_IS_STRIDE(sdx1)) {
+            // index <- step
+            ssize_t stride1 = CUMO_SDX_GET_STRIDE(sdx1);
+            if (stride1<0) {
+                size_t  last;
+                stride1 = -stride1;
+                last = na1->base.shape[q[i].orig_dim] - 1;
+                if (na2->offset < last * stride1) {
+                    rb_raise(rb_eStandardError,"bug: negative offset");
+                }
+                na2->offset -= last * stride1;
+                if (i==ndim-1) {
+                    cumo_na_index_aref_naview_index_stride_last_kernel_launch(index, stride1, last, size);
+                    q[i].idx = NULL;
+                } else {
+                    cumo_na_index_at_naview_index_stride_last_add_kernel_launch(index, stride1, last, size);
+                }
+            } else {
+                if (i==ndim-1) {
+                    cumo_na_index_aref_nadata_index_stride_kernel_launch(index, stride1, size);
+                    q[i].idx = NULL;
+                } else {
+                    cumo_na_index_at_nadata_index_stride_add_kernel_launch(index, q[i].idx, stride1, size);
+                }
+            }
+        }
+        else if (q[i].idx == NULL && CUMO_SDX_IS_STRIDE(sdx1)) {
+            // step <- step
+            size_t beg  = q[i].beg;
+            ssize_t step = q[i].step;
+            ssize_t stride1 = CUMO_SDX_GET_STRIDE(sdx1);
+            if (stride1<0) {
+                size_t  last;
+                stride1 = -stride1;
+                last = na1->base.shape[q[i].orig_dim] - 1;
+                if (na2->offset < last * stride1) {
+                    rb_raise(rb_eStandardError,"bug: negative offset");
+                }
+                na2->offset -= last * stride1;
+                if (i==ndim-1) {
+                    cumo_na_index_at_nadata_index_beg_step_stride_kernel_launch(index, last - beg, -step, stride1, size);
+                } else {
+                    cumo_na_index_at_nadata_index_beg_step_stride_add_kernel_launch(index, last - beg, -step, stride1, size);
+                }
+            } else {
+                if (i==ndim-1) {
+                    cumo_na_index_at_nadata_index_beg_step_stride_kernel_launch(index, beg, step, stride1, size);
+                } else {
+                    cumo_na_index_at_nadata_index_beg_step_stride_add_kernel_launch(index, beg, step, stride1, size);
+                }
+            }
+        }
+    }
+    na2->base.size = size;
+    na2->base.shape[0] = size;
+    if (use_cumo_cuda_runtime_malloc) {
+        CUMO_SHOW_SYNCHRONIZE_FIXME_WARNING_ONCE("index", "cumo_na_index_at_naview");
+        cumo_cuda_runtime_check_status(cudaDeviceSynchronize());
+    }
+}
+
 static int
 cumo_na_ndim_new_narray(int ndim, const cumo_na_index_arg_t *q)
 {
@@ -587,6 +769,7 @@ typedef struct {
     cumo_narray_t *na1;
     int keep_dim;
     size_t pos; // offset position for 0-dimensional narray. 0-dimensional array does not use q.
+    int at_mode; // 0: aref, 1: at
 } cumo_na_aref_md_data_t;
 
 static cumo_na_index_arg_t*
@@ -614,6 +797,7 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
     cumo_na_index_arg_t *q = data->q;
     cumo_narray_t *na1 = data->na1;
     int keep_dim = data->keep_dim;
+    int at_mode = data->at_mode;
 
     int ndim_new;
     VALUE view;
@@ -624,10 +808,14 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
 
     if (cumo_na_debug_flag) print_index_arg(q,ndim);
 
-    if (keep_dim) {
-        ndim_new = ndim;
+    if (at_mode) {
+        ndim_new = 1;
     } else {
-        ndim_new = cumo_na_ndim_new_narray(ndim, q);
+        if (keep_dim) {
+            ndim_new = ndim;
+        } else {
+            ndim_new = cumo_na_ndim_new_narray(ndim, q);
+        }
     }
     view = cumo_na_s_allocate_view(rb_obj_class(self));
 
@@ -636,7 +824,7 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
 
     cumo_na_alloc_shape((cumo_narray_t*)na2, ndim_new);
 
-    na2->stridx = ALLOC_N(cumo_stridx_t,ndim_new);
+    na2->stridx = ZALLOC_N(cumo_stridx_t,ndim_new);
 
     elmsz = cumo_na_element_stride(self);
 
@@ -647,7 +835,11 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
             na2->offset = data->pos;
             na2->base.size = 1;
         } else {
-            cumo_na_index_aref_nadata((cumo_narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            if (at_mode) {
+                cumo_na_index_at_nadata((cumo_narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            } else {
+                cumo_na_index_aref_nadata((cumo_narray_data_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            }
         }
         na2->data = self;
         break;
@@ -659,7 +851,11 @@ VALUE cumo_na_aref_md_protected(VALUE data_value)
         } else {
             na2->offset = ((cumo_narray_view_t *)na1)->offset;
             na2->data = ((cumo_narray_view_t *)na1)->data;
-            cumo_na_index_aref_naview((cumo_narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            if (at_mode) {
+               cumo_na_index_at_naview((cumo_narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            } else {
+               cumo_na_index_aref_naview((cumo_narray_view_t *)na1,na2,q,elmsz,ndim,keep_dim);
+            }
         }
         break;
     }
@@ -684,7 +880,7 @@ cumo_na_aref_md_ensure(VALUE data_value)
 }
 
 static VALUE
-cumo_na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd, size_t pos)
+cumo_na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd, size_t pos, int at_mode)
 {
     VALUE args; // should be GC protected
     cumo_narray_t *na1;
@@ -696,6 +892,9 @@ cumo_na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd,
     CumoGetNArray(self,na1);
 
     args = rb_ary_new4(argc,argv);
+    if (at_mode && na1->ndim == 0) {
+        rb_raise(cumo_na_eDimensionError,"argument length does not match dimension size");
+    }
 
     if (argc == 1 && result_nd == 1) {
         idx = argv[0];
@@ -724,6 +923,7 @@ cumo_na_aref_md(int argc, VALUE *argv, VALUE self, int keep_dim, int result_nd,
     data.q = cumo_na_allocate_index_args(result_nd);
     data.na1 = na1;
     data.keep_dim = keep_dim;
+    data.at_mode = at_mode;
 
     switch(na1->type) {
     case CUMO_NARRAY_DATA_T:
@@ -760,7 +960,15 @@ cumo_na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result_nd,
             return rb_funcall(*idx,cumo_id_mask,1,self);
         }
     }
-    return cumo_na_aref_md(nidx, idx, self, keep_dim, result_nd, pos);
+    return cumo_na_aref_md(nidx, idx, self, keep_dim, result_nd, pos, 0);
+}
+
+/* method: at([idx1,idx2,...,idxN], [idx1,idx2,...,idxN]) */
+VALUE
+cumo_na_at_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result_nd, size_t pos)
+{
+    cumo_na_index_arg_to_internal_order(nidx, idx, self);
+    return cumo_na_aref_md(nidx, idx, self, keep_dim, result_nd, pos, 1);
 }
 
 
@@ -782,16 +990,18 @@ check_index_count(int argc, int cumo_na_ndim, int count_new, int count_rest)
 
     switch(count_rest) {
     case 0:
-        if (count_new == 0 && argc == 1) return 1;
+        if (argc == 1 && count_new == 0) return 1;
         if (argc == result_nd) return result_nd;
         rb_raise(rb_eIndexError,"# of index(=%i) should be "
-                 "equal to ndim(=%i)",argc,cumo_na_ndim);
+                 "equal to ndim(=%i) or 1", argc,cumo_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,cumo_na_ndim);
         break;
+    default:
+        rb_raise(rb_eIndexError,"multiple rest-dimension is not allowd");
     }
     return -1;
 }
@@ -802,7 +1012,6 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
     int i, j;
     int count_new=0;
     int count_rest=0;
-    int count_else=0;
     ssize_t x, s, m, pos, *idx;
     cumo_narray_t *na;
     cumo_narray_view_t *nv;
@@ -811,8 +1020,7 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
 
     CumoGetNArray(self,na);
     if (na->size == 0) {
-        rb_raise(rb_eRuntimeError, "cannot get index of empty array");
-        return -1;
+        rb_raise(cumo_na_eShapeError, "cannot get element of empty array");
     }
     idx = ALLOCA_N(ssize_t, argc);
     for (i=j=0; i<argc; i++) {
@@ -835,16 +1043,10 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
                 argv[i] = cumo_sym_new;
                 count_new++;
             }
-            // not break
-        default:
-            count_else++;
         }
     }
 
-    if (count_rest > 1) {
-        rb_raise(rb_eIndexError,"multiple rest-dimension is not allowd");
-    }
-    if (count_else != 0) {
+    if (j != argc) {
         return check_index_count(argc, na->ndim, count_new, count_rest);
     }
 
@@ -865,8 +1067,9 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
                 }
             }
             *pos_idx = pos;
+            return 0;
         }
-        else if (argc==1 && j==1) {
+        if (j == 1) {
             x = cumo_na_range_check(idx[0], na->size, 0);
             for (i=na->ndim-1; i>=0; i--) {
                 s = na->shape[i];
@@ -882,19 +1085,19 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
                 }
             }
             *pos_idx = pos;
-        } else {
-            return check_index_count(argc, na->ndim, count_new, count_rest);
+            return 0;
         }
         break;
     default:
         if (!stride) {
             stride = cumo_na_element_stride(self);
         }
-        if (argc==1 && j==1) {
+        if (j == 1) {
             x = cumo_na_range_check(idx[0], na->size, 0);
             *pos_idx = stride * x;
+            return 0;
         }
-        else if (j == na->ndim) {
+        if (j == na->ndim) {
             pos = 0;
             for (i=j-1; i>=0; i--) {
                 x = cumo_na_range_check(idx[i], na->shape[i], i);
@@ -902,11 +1105,12 @@ cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride,
                 stride *= na->shape[i];
             }
             *pos_idx = pos;
-        } else {
-            return check_index_count(argc, na->ndim, count_new, count_rest);
+            return 0;
         }
     }
-    return 0;
+    rb_raise(rb_eIndexError,"# of index(=%i) should be "
+             "equal to ndim(=%i) or 1", argc,na->ndim);
+    return -1;
 }
 
 

data/ext/cumo/narray/index_kernel.cu

@@ -42,6 +42,48 @@ __global__ void cumo_na_index_aref_naview_index_index_beg_step_kernel(size_t *id
     }
 }
 
+__global__ void cumo_na_index_at_nadata_index_beg_step_stride_kernel(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] = (beg + step * i) * s1;
+    }
+}
+
+__global__ void cumo_na_index_at_nadata_index_beg_step_stride_add_kernel(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] += (beg + step * i) * s1;
+    }
+}
+
+__global__ void cumo_na_index_at_nadata_index_stride_add_kernel(size_t *idx, size_t *idx1, ssize_t s1, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] += idx1[i] * s1;
+    }
+}
+
+__global__ void cumo_na_index_at_naview_index_index_index_add_kernel(size_t *idx, size_t *idx1, size_t *idx2, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] += idx1[idx2[i]];
+    }
+}
+
+__global__ void cumo_na_index_at_naview_index_index_beg_step_add_kernel(size_t *idx, size_t *idx1, size_t beg, ssize_t step, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] += idx1[beg + step * i];
+    }
+}
+
+__global__ void cumo_na_index_at_naview_index_stride_last_add_kernel(size_t *idx, ssize_t s1, size_t last, uint64_t n)
+{
+    for (uint64_t i = blockIdx.x * blockDim.x + threadIdx.x; i < n; i += blockDim.x * gridDim.x) {
+        idx[i] += (last - idx[i]) * s1;
+    }
+}
+
 void cumo_na_index_aref_nadata_index_stride_kernel_launch(size_t *idx, ssize_t s1, uint64_t n)
 {
     size_t grid_dim = cumo_get_grid_dim(n);
@@ -77,6 +119,48 @@ void cumo_na_index_aref_naview_index_index_beg_step_kernel_launch(size_t *idx, s
     cumo_na_index_aref_naview_index_index_beg_step_kernel<<<grid_dim, block_dim>>>(idx, idx1, beg, step, n);
 }
 
+void cumo_na_index_at_nadata_index_stride_add_kernel_launch(size_t *idx, size_t *idx1, ssize_t s1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_at_nadata_index_stride_add_kernel<<<grid_dim, block_dim>>>(idx, idx1, s1, n);
+}
+
+void cumo_na_index_at_nadata_index_beg_step_stride_kernel_launch(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_at_nadata_index_beg_step_stride_kernel<<<grid_dim, block_dim>>>(idx, beg, step, s1, n);
+}
+
+void cumo_na_index_at_nadata_index_beg_step_stride_add_kernel_launch(size_t *idx, size_t beg, ssize_t step, ssize_t s1, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_at_nadata_index_beg_step_stride_add_kernel<<<grid_dim, block_dim>>>(idx, beg, step, s1, n);
+}
+
+void cumo_na_index_at_naview_index_index_index_add_kernel_launch(size_t *idx, size_t *idx1, size_t *idx2, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_at_naview_index_index_index_add_kernel<<<grid_dim, block_dim>>>(idx, idx1, idx2, n);
+}
+
+void cumo_na_index_at_naview_index_index_beg_step_add_kernel_launch(size_t *idx, size_t *idx1, size_t beg, ssize_t step, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_at_naview_index_index_beg_step_add_kernel<<<grid_dim, block_dim>>>(idx, idx1, beg, step, n);
+}
+
+void cumo_na_index_at_naview_index_stride_last_add_kernel_launch(size_t *idx, ssize_t s1, size_t last, uint64_t n)
+{
+    size_t grid_dim = cumo_get_grid_dim(n);
+    size_t block_dim = cumo_get_block_dim(n);
+    cumo_na_index_at_naview_index_stride_last_add_kernel<<<grid_dim, block_dim>>>(idx, s1, last, n);
+}
+
 #if defined(__cplusplus)
 #if 0
 { /* satisfy cc-mode */

data/ext/cumo/narray/narray.c

@@ -889,6 +889,39 @@ cumo_na_check_contiguous(VALUE self)
     return Qfalse;
 }
 
+VALUE
+cumo_na_check_fortran_contiguous(VALUE self)
+{
+    int i;
+    ssize_t st0;
+    cumo_narray_t *na;
+
+    switch(CUMO_RNARRAY_TYPE(self)) {
+    case CUMO_NARRAY_DATA_T:
+    case CUMO_NARRAY_FILEMAP_T:
+        return Qfalse;
+    case CUMO_NARRAY_VIEW_T:
+        CumoGetNArray(self,na);
+
+        // not contiguous if it has index
+        for (i=0; i < CUMO_NA_NDIM(na); i++) {
+            if (CUMO_NA_IS_INDEX_AT(na,i))
+                return Qfalse;
+        }
+
+        // check f-contiguous
+        st0 = cumo_na_element_stride(self); // elmsz
+        for (i=0; i < CUMO_NA_NDIM(na); i++) {
+            if (CUMO_NA_SHAPE(na)[i] == 1)
+                continue;
+            if (CUMO_NA_STRIDE_AT(na, i) != st0)
+                return Qfalse;
+            st0 *= CUMO_NA_SHAPE(na)[i];
+        }
+    }
+    return Qtrue;
+}
+
 VALUE
 cumo_na_as_contiguous_array(VALUE a)
 {
@@ -1388,7 +1421,7 @@ static VALUE cumo_na_inplace( VALUE self );
 /*
   Load marshal data.
   @overload marshal_load(data)
-  @params [Array] Array containing marshal data.
+  @param [Array] Array containing marshal data.
   @return [nil]
  */
 static VALUE
@@ -1833,6 +1866,9 @@ cumo_na_equal(VALUE self, volatile VALUE other)
             return Qfalse;
         }
     }
+    if (na1->size == 0) {
+      return Qtrue;
+    }
     vbool = rb_funcall(self, cumo_id_eq, 1, other);
     return (rb_funcall(vbool, cumo_id_count_false_cpu, 0)==INT2FIX(0)) ? Qtrue : Qfalse;
 }
@@ -1929,6 +1965,7 @@ Init_cumo_narray()
     rb_define_method(cNArray, "debug_info", cumo_na_debug_info, 0);
 
     rb_define_method(cNArray, "contiguous?", cumo_na_check_contiguous, 0);
+    rb_define_method(cNArray, "fortran_contiguous?", cumo_na_check_fortran_contiguous, 0);
 
     rb_define_method(cNArray, "view", cumo_na_make_view, 0);
     rb_define_method(cNArray, "expand_dims", cumo_na_expand_dims, 1);

data/ext/cumo/narray/ndloop.c

@@ -56,7 +56,7 @@ typedef struct CUMO_NA_MD_LOOP {
                               // [2,3,4], 111b for sum(), 010b for sum(axis: 1), 110b for sum(axis: [1,2])
     VALUE  loop_opt;
     cumo_ndfunc_t  *ndfunc;
-    void (*loop_func)();
+    void (*loop_func)(cumo_ndfunc_t *, struct CUMO_NA_MD_LOOP *);
 } cumo_na_md_loop_t;
 
 #define LARG(lp,iarg) ((lp)->user.args[iarg])