cumo 0.1.0 → 0.1.1

data/ext/cumo/narray/data.c

@@ -2,11 +2,11 @@
 #include "cumo/narray.h"
 #include "cumo/template.h"
 
-static VALUE sym_mulsum;
-static ID id_mulsum;
-static ID id_respond_to_p;
-static ID id_store;
-static ID id_swap_byte;
+static VALUE cumo_sym_mulsum;
+static ID cumo_id_mulsum;
+static ID cumo_id_respond_to_p;
+static ID cumo_id_store;
+static ID cumo_id_swap_byte;
 
 // ---------------------------------------------------------------------
 
@@ -16,9 +16,9 @@ static ID id_swap_byte;
     ssize_t s1, s2;                                \
     char   *p1, *p2;                               \
     size_t *idx1, *idx2;                           \
-    INIT_COUNTER(lp, i);                           \
-    INIT_PTR_IDX(lp, 0, p1, s1, idx1);             \
-    INIT_PTR_IDX(lp, 1, p2, s2, idx2);             \
+    CUMO_INIT_COUNTER(lp, i);                           \
+    CUMO_INIT_PTR_IDX(lp, 0, p1, s1, idx1);             \
+    CUMO_INIT_PTR_IDX(lp, 1, p2, s2, idx2);             \
     if (idx1) {                                    \
         if (idx2) {                                \
             for (; i--;) {                         \
@@ -52,7 +52,7 @@ static ID id_swap_byte;
 
 #define m_memcpy(src,dst) memcpy(dst,src,e)
 static void
-iter_copy_bytes(na_loop_t *const lp)
+iter_copy_bytes(cumo_na_loop_t *const lp)
 {
     size_t e;
     e = lp->args[0].elmsz;
@@ -61,21 +61,21 @@ iter_copy_bytes(na_loop_t *const lp)
 }
 
 VALUE
-na_copy(VALUE self)
+cumo_na_copy(VALUE self)
 {
     VALUE v;
-    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
-    ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
-    ndfunc_t ndf = { iter_copy_bytes, FULL_LOOP, 1, 1, ain, aout };
+    cumo_ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
+    cumo_ndfunc_t ndf = { iter_copy_bytes, CUMO_FULL_LOOP, 1, 1, ain, aout };
 
-    v = na_ndloop(&ndf, 1, self);
+    v = cumo_na_ndloop(&ndf, 1, self);
     return v;
 }
 
 VALUE
-na_store(VALUE self, VALUE src)
+cumo_na_store(VALUE self, VALUE src)
 {
-    return rb_funcall(self,id_store,1,src);
+    return rb_funcall(self,cumo_id_store,1,src);
 }
 
 // ---------------------------------------------------------------------
@@ -91,7 +91,7 @@ na_store(VALUE self, VALUE src)
     }
 
 static void
-iter_swap_byte(na_loop_t *const lp)
+iter_swap_byte(cumo_na_loop_t *const lp)
 {
     char   *b1, *b2;
     size_t  e;
@@ -103,57 +103,57 @@ iter_swap_byte(na_loop_t *const lp)
 }
 
 static VALUE
-nary_swap_byte(VALUE self)
+cumo_na_swap_byte(VALUE self)
 {
     VALUE v;
-    ndfunc_arg_in_t ain[1] = {{Qnil,0}};
-    ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
-    ndfunc_t ndf = { iter_swap_byte, FULL_LOOP|NDF_ACCEPT_BYTESWAP,
+    cumo_ndfunc_arg_in_t ain[1] = {{Qnil,0}};
+    cumo_ndfunc_arg_out_t aout[1] = {{INT2FIX(0),0}};
+    cumo_ndfunc_t ndf = { iter_swap_byte, CUMO_FULL_LOOP|CUMO_NDF_ACCEPT_BYTESWAP,
                      1, 1, ain, aout };
 
-    v = na_ndloop(&ndf, 1, self);
+    v = cumo_na_ndloop(&ndf, 1, self);
     if (self!=v) {
-        na_copy_flags(self, v);
+        cumo_na_copy_flags(self, v);
     }
-    REVERSE_ENDIAN(v);
+    CUMO_REVERSE_ENDIAN(v);
     return v;
 }
 
 
 static VALUE
-nary_to_network(VALUE self)
+cumo_na_to_network(VALUE self)
 {
-    if (TEST_BIG_ENDIAN(self)) {
+    if (CUMO_TEST_BIG_ENDIAN(self)) {
         return self;
     }
-    return rb_funcall(self, id_swap_byte, 0);
+    return rb_funcall(self, cumo_id_swap_byte, 0);
 }
 
 static VALUE
-nary_to_vacs(VALUE self)
+cumo_na_to_vacs(VALUE self)
 {
-    if (TEST_LITTLE_ENDIAN(self)) {
+    if (CUMO_TEST_LITTLE_ENDIAN(self)) {
         return self;
     }
-    return rb_funcall(self, id_swap_byte, 0);
+    return rb_funcall(self, cumo_id_swap_byte, 0);
 }
 
 static VALUE
-nary_to_host(VALUE self)
+cumo_na_to_host(VALUE self)
 {
-    if (TEST_HOST_ORDER(self)) {
+    if (CUMO_TEST_HOST_ORDER(self)) {
         return self;
     }
-    return rb_funcall(self, id_swap_byte, 0);
+    return rb_funcall(self, cumo_id_swap_byte, 0);
 }
 
 static VALUE
-nary_to_swapped(VALUE self)
+cumo_na_to_swapped(VALUE self)
 {
-    if (TEST_BYTE_SWAPPED(self)) {
+    if (CUMO_TEST_BYTE_SWAPPED(self)) {
         return self;
     }
-    return rb_funcall(self, id_swap_byte, 0);
+    return rb_funcall(self, cumo_id_swap_byte, 0);
 }
 
 
@@ -163,7 +163,7 @@ static inline int
 check_axis(int axis, int ndim)
 {
     if (axis < -ndim || axis >= ndim) {
-        rb_raise(nary_eDimensionError,"invalid axis (%d for %d-dimension)",
+        rb_raise(cumo_na_eDimensionError,"invalid axis (%d for %d-dimension)",
                  axis, ndim);
     }
     if (axis < 0) {
@@ -202,16 +202,16 @@ check_axis(int axis, int ndim)
     #   [3, 7]]]
 */
 static VALUE
-na_swapaxes(VALUE self, VALUE a1, VALUE a2)
+cumo_na_swapaxes(VALUE self, VALUE a1, VALUE a2)
 {
     int  i, j, ndim;
     size_t tmp_shape;
-    stridx_t tmp_stridx;
-    narray_view_t *na;
+    cumo_stridx_t tmp_stridx;
+    cumo_narray_view_t *na;
     volatile VALUE view;
 
-    view = na_make_view(self);
-    GetNArrayView(view,na);
+    view = cumo_na_make_view(self);
+    CumoGetNArrayView(view,na);
 
     ndim = na->base.ndim;
     i = check_axis(NUM2INT(a1), ndim);
@@ -228,20 +228,20 @@ na_swapaxes(VALUE self, VALUE a1, VALUE a2)
 }
 
 static VALUE
-na_transpose_map(VALUE self, int *map)
+cumo_na_transpose_map(VALUE self, int *map)
 {
     int  i, ndim;
     size_t *shape;
-    stridx_t *stridx;
-    narray_view_t *na;
+    cumo_stridx_t *stridx;
+    cumo_narray_view_t *na;
     volatile VALUE view;
 
-    view = na_make_view(self);
-    GetNArrayView(view,na);
+    view = cumo_na_make_view(self);
+    CumoGetNArrayView(view,na);
 
     ndim = na->base.ndim;
     shape = ALLOCA_N(size_t,ndim);
-    stridx = ALLOCA_N(stridx_t,ndim);
+    stridx = ALLOCA_N(cumo_stridx_t,ndim);
 
     for (i=0; i<ndim; i++) {
 	shape[i] = na->base.shape[i];
@@ -258,27 +258,27 @@ na_transpose_map(VALUE self, int *map)
 #define SWAP(a,b,tmp) {tmp=a;a=b;b=tmp;}
 
 static VALUE
-na_transpose(int argc, VALUE *argv, VALUE self)
+cumo_na_transpose(int argc, VALUE *argv, VALUE self)
 {
     int ndim, *map, *permute;
     int i, d;
     bool is_positive, is_negative;
-    narray_t *na1;
+    cumo_narray_t *na1;
 
-    GetNArray(self,na1);
+    CumoGetNArray(self,na1);
     ndim = na1->ndim;
     if (ndim < 2) {
         if (argc > 0) {
             rb_raise(rb_eArgError, "unnecessary argument for 1-d array");
         }
-        return na_make_view(self);
+        return cumo_na_make_view(self);
     }
     map = ALLOCA_N(int,ndim);
     if (argc == 0) {
         for (i=0; i < ndim; i++) {
             map[i] = ndim-1-i;
         }
-        return na_transpose_map(self,map);
+        return cumo_na_transpose_map(self,map);
     }
     // with argument
     if (argc > ndim) {
@@ -325,23 +325,23 @@ na_transpose(int argc, VALUE *argv, VALUE self)
             is_negative = 1;
         }
     }
-    return na_transpose_map(self,map);
+    return cumo_na_transpose_map(self,map);
 }
 
 //----------------------------------------------------------------------
 
 static void
-na_check_reshape(int argc, VALUE *argv, VALUE self, size_t *shape)
+cumo_na_check_reshape(int argc, VALUE *argv, VALUE self, size_t *shape)
 {
     int    i, unfixed=-1;
     size_t total=1;
-    narray_t *na;
+    cumo_narray_t *na;
 
     if (argc == 0) {
         rb_raise(rb_eArgError, "No argrument");
     }
-    GetNArray(self,na);
-    if (NA_SIZE(na) == 0) {
+    CumoGetNArray(self,na);
+    if (CUMO_NA_SIZE(na) == 0) {
         rb_raise(rb_eRuntimeError, "cannot reshape empty array");
     }
 
@@ -364,12 +364,12 @@ na_check_reshape(int argc, VALUE *argv, VALUE self, size_t *shape)
     }
 
     if (unfixed>=0) {
-        if (NA_SIZE(na) % total != 0) {
+        if (CUMO_NA_SIZE(na) % total != 0) {
             rb_raise(rb_eArgError, "Total size size must be divisor");
         }
-        shape[unfixed] = NA_SIZE(na) / total;
+        shape[unfixed] = CUMO_NA_SIZE(na) / total;
     }
-    else if (total !=  NA_SIZE(na)) {
+    else if (total !=  CUMO_NA_SIZE(na)) {
         rb_raise(rb_eArgError, "Total size must be same");
     }
 }
@@ -384,19 +384,19 @@ na_check_reshape(int argc, VALUE *argv, VALUE self, size_t *shape)
   @example
 */
 static VALUE
-na_reshape_bang(int argc, VALUE *argv, VALUE self)
+cumo_na_reshape_bang(int argc, VALUE *argv, VALUE self)
 {
     size_t *shape;
-    narray_t *na;
+    cumo_narray_t *na;
 
-    if (na_check_contiguous(self)==Qfalse) {
+    if (cumo_na_check_contiguous(self)==Qfalse) {
         rb_raise(rb_eStandardError, "cannot change shape of non-contiguous NArray");
     }
     shape = ALLOCA_N(size_t, argc);
-    na_check_reshape(argc, argv, self, shape);
+    cumo_na_check_reshape(argc, argv, self, shape);
 
-    GetNArray(self, na);
-    na_setup_shape(na, argc, shape);
+    CumoGetNArray(self, na);
+    cumo_na_setup_shape(na, argc, shape);
     return self;
 }
 
@@ -410,44 +410,44 @@ na_reshape_bang(int argc, VALUE *argv, VALUE self)
   @example
 */
 static VALUE
-na_reshape(int argc, VALUE *argv, VALUE self)
+cumo_na_reshape(int argc, VALUE *argv, VALUE self)
 {
     size_t *shape;
-    narray_t *na;
+    cumo_narray_t *na;
     VALUE    copy;
 
     shape = ALLOCA_N(size_t, argc);
-    na_check_reshape(argc, argv, self, shape);
+    cumo_na_check_reshape(argc, argv, self, shape);
 
     copy = rb_funcall(self, rb_intern("dup"), 0);
-    GetNArray(copy, na);
-    na_setup_shape(na, argc, shape);
+    CumoGetNArray(copy, na);
+    cumo_na_setup_shape(na, argc, shape);
     return copy;
 }
 
 //----------------------------------------------------------------------
 
 VALUE
-na_flatten_dim(VALUE self, int sd)
+cumo_na_flatten_dim(VALUE self, int sd)
 {
     int i, nd, fd;
     size_t j;
     size_t *c, *pos, *idx1, *idx2;
     size_t stride;
     size_t  *shape, size;
-    stridx_t sdx;
-    narray_t *na;
-    narray_view_t *na1, *na2;
+    cumo_stridx_t sdx;
+    cumo_narray_t *na;
+    cumo_narray_view_t *na1, *na2;
     volatile VALUE view;
 
-    GetNArray(self,na);
+    CumoGetNArray(self,na);
     nd = na->ndim;
 
     if (nd==0) {
-        return na_make_view(self);
+        return cumo_na_make_view(self);
     }
     if (sd<0 || sd>=nd) {
-        rb_bug("na_flaten_dim: start_dim (%d) out of range",sd);
+        rb_bug("cumo_na_flaten_dim: start_dim (%d) out of range",sd);
     }
 
     // new shape
@@ -462,51 +462,51 @@ na_flatten_dim(VALUE self, int sd)
     shape[sd] = size;
 
     // new object
-    view = na_s_allocate_view(CLASS_OF(self));
-    na_copy_flags(self, view);
-    GetNArrayView(view, na2);
+    view = cumo_na_s_allocate_view(rb_obj_class(self));
+    cumo_na_copy_flags(self, view);
+    CumoGetNArrayView(view, na2);
 
     // new stride
-    na_setup_shape((narray_t*)na2, sd+1, shape);
-    na2->stridx = ALLOC_N(stridx_t,sd+1);
+    cumo_na_setup_shape((cumo_narray_t*)na2, sd+1, shape);
+    na2->stridx = ALLOC_N(cumo_stridx_t,sd+1);
 
     switch(na->type) {
-    case NARRAY_DATA_T:
-    case NARRAY_FILEMAP_T:
-        stride = nary_element_stride(self);
+    case CUMO_NARRAY_DATA_T:
+    case CUMO_NARRAY_FILEMAP_T:
+        stride = cumo_na_element_stride(self);
         for (i=sd+1; i--; ) {
             //printf("data: i=%d shpae[i]=%ld stride=%ld\n",i,shape[i],stride);
-            SDX_SET_STRIDE(na2->stridx[i],stride);
+            CUMO_SDX_SET_STRIDE(na2->stridx[i],stride);
             stride *= shape[i];
         }
         na2->offset = 0;
         na2->data = self;
         break;
-    case NARRAY_VIEW_T:
-        GetNArrayView(self, na1);
+    case CUMO_NARRAY_VIEW_T:
+        CumoGetNArrayView(self, na1);
         na2->data = na1->data;
         na2->offset = na1->offset;
         for (i=0; i<sd; i++) {
-            if (SDX_IS_INDEX(na1->stridx[i])) {
-                idx1 = SDX_GET_INDEX(na1->stridx[i]);
+            if (CUMO_SDX_IS_INDEX(na1->stridx[i])) {
+                idx1 = CUMO_SDX_GET_INDEX(na1->stridx[i]);
                 idx2 = ALLOC_N(size_t, shape[i]);
                 for (j=0; j<shape[i]; j++) {
                     idx2[j] = idx1[j];
                 }
-                SDX_SET_INDEX(na2->stridx[i],idx2);
+                CUMO_SDX_SET_INDEX(na2->stridx[i],idx2);
             } else {
                 na2->stridx[i] = na1->stridx[i];
-                //printf("view: i=%d stridx=%d\n",i,SDX_GET_STRIDE(sdx));
+                //printf("view: i=%d stridx=%d\n",i,CUMO_SDX_GET_STRIDE(sdx));
             }
         }
         // flat dimenion == last dimension
-        if (RTEST(na_check_ladder(self,sd))) {
+        if (RTEST(cumo_na_check_ladder(self,sd))) {
         //if (0) {
             na2->stridx[sd] = na1->stridx[nd-1];
         } else {
             // set index
             idx2 = ALLOC_N(size_t, shape[sd]);
-            SDX_SET_INDEX(na2->stridx[sd],idx2);
+            CUMO_SDX_SET_INDEX(na2->stridx[sd],idx2);
             // init for md-loop
             fd = nd-sd;
             c = ALLOC_N(size_t, fd);
@@ -517,10 +517,10 @@ na_flatten_dim(VALUE self, int sd)
             for (i=j=0;;) {
                 for (; i<fd; i++) {
                     sdx = na1->stridx[i+sd];
-                    if (SDX_IS_INDEX(sdx)) {
-                        pos[i+1] = pos[i] + SDX_GET_INDEX(sdx)[c[i]];
+                    if (CUMO_SDX_IS_INDEX(sdx)) {
+                        pos[i+1] = pos[i] + CUMO_SDX_GET_INDEX(sdx)[c[i]];
                     } else {
-                        pos[i+1] = pos[i] + SDX_GET_STRIDE(sdx)*c[i];
+                        pos[i+1] = pos[i] + CUMO_SDX_GET_STRIDE(sdx)*c[i];
                     }
                 }
                 idx2[j++] = pos[i];
@@ -542,9 +542,9 @@ na_flatten_dim(VALUE self, int sd)
 }
 
 VALUE
-na_flatten(VALUE self)
+cumo_na_flatten(VALUE self)
 {
-    return na_flatten_dim(self,0);
+    return cumo_na_flatten_dim(self,0);
 }
 
 //----------------------------------------------------------------------
@@ -587,7 +587,7 @@ na_flatten(VALUE self)
      [15, 16, 17, 18, 4]]
  */
 static VALUE
-na_diagonal(int argc, VALUE *argv, VALUE self)
+cumo_na_diagonal(int argc, VALUE *argv, VALUE self)
 {
     int  i, k, nd;
     size_t  j;
@@ -595,8 +595,8 @@ na_diagonal(int argc, VALUE *argv, VALUE self)
     size_t *shape;
     size_t  diag_size;
     ssize_t stride, stride0, stride1;
-    narray_t *na;
-    narray_view_t *na1, *na2;
+    cumo_narray_t *na;
+    cumo_narray_view_t *na1, *na2;
     VALUE view;
     VALUE vofs=0, vaxes=0;
     ssize_t kofs;
@@ -631,10 +631,10 @@ na_diagonal(int argc, VALUE *argv, VALUE self)
         kofs = 0;
     }
 
-    GetNArray(self,na);
+    CumoGetNArray(self,na);
     nd = na->ndim;
     if (nd < 2) {
-        rb_raise(nary_eDimensionError,"less than 2-d array");
+        rb_raise(cumo_na_eDimensionError,"less than 2-d array");
     }
 
     if (vaxes) {
@@ -685,20 +685,20 @@ na_diagonal(int argc, VALUE *argv, VALUE self)
     shape[k] = diag_size;
 
     // new object
-    view = na_s_allocate_view(CLASS_OF(self));
-    na_copy_flags(self, view);
-    GetNArrayView(view, na2);
+    view = cumo_na_s_allocate_view(rb_obj_class(self));
+    cumo_na_copy_flags(self, view);
+    CumoGetNArrayView(view, na2);
 
     // new stride
-    na_setup_shape((narray_t*)na2, nd-1, shape);
-    na2->stridx = ALLOC_N(stridx_t, nd-1);
+    cumo_na_setup_shape((cumo_narray_t*)na2, nd-1, shape);
+    na2->stridx = ALLOC_N(cumo_stridx_t, nd-1);
 
     switch(na->type) {
-    case NARRAY_DATA_T:
-    case NARRAY_FILEMAP_T:
+    case CUMO_NARRAY_DATA_T:
+    case CUMO_NARRAY_FILEMAP_T:
         na2->offset = 0;
         na2->data = self;
-        stride = stride0 = stride1 = nary_element_stride(self);
+        stride = stride0 = stride1 = cumo_na_element_stride(self);
         for (i=nd,k=nd-2; i--; ) {
             if (i==ax[1]) {
                 stride1 = stride;
@@ -711,60 +711,60 @@ na_diagonal(int argc, VALUE *argv, VALUE self)
                     na2->offset = (-kofs)*stride;
                 }
             } else {
-                SDX_SET_STRIDE(na2->stridx[--k],stride);
+                CUMO_SDX_SET_STRIDE(na2->stridx[--k],stride);
             }
             stride *= na->shape[i];
         }
-        SDX_SET_STRIDE(na2->stridx[nd-2],stride0+stride1);
+        CUMO_SDX_SET_STRIDE(na2->stridx[nd-2],stride0+stride1);
         break;
 
-    case NARRAY_VIEW_T:
-        GetNArrayView(self, na1);
+    case CUMO_NARRAY_VIEW_T:
+        CumoGetNArrayView(self, na1);
         na2->data = na1->data;
         na2->offset = na1->offset;
         for (i=k=0; i<nd; i++) {
             if (i != ax[0] && i != ax[1]) {
-                if (SDX_IS_INDEX(na1->stridx[i])) {
-                    idx0 = SDX_GET_INDEX(na1->stridx[i]);
+                if (CUMO_SDX_IS_INDEX(na1->stridx[i])) {
+                    idx0 = CUMO_SDX_GET_INDEX(na1->stridx[i]);
                     idx1 = ALLOC_N(size_t, na->shape[i]);
                     for (j=0; j<na->shape[i]; j++) {
                         idx1[j] = idx0[j];
                     }
-                    SDX_SET_INDEX(na2->stridx[k],idx1);
+                    CUMO_SDX_SET_INDEX(na2->stridx[k],idx1);
                 } else {
                     na2->stridx[k] = na1->stridx[i];
                 }
                 k++;
             }
         }
-        if (SDX_IS_INDEX(na1->stridx[ax[0]])) {
-            idx0 = SDX_GET_INDEX(na1->stridx[ax[0]]);
+        if (CUMO_SDX_IS_INDEX(na1->stridx[ax[0]])) {
+            idx0 = CUMO_SDX_GET_INDEX(na1->stridx[ax[0]]);
             diag_idx = ALLOC_N(size_t, diag_size);
-            if (SDX_IS_INDEX(na1->stridx[ax[1]])) {
-                idx1 = SDX_GET_INDEX(na1->stridx[ax[1]]);
+            if (CUMO_SDX_IS_INDEX(na1->stridx[ax[1]])) {
+                idx1 = CUMO_SDX_GET_INDEX(na1->stridx[ax[1]]);
                 for (j=0; j<diag_size; j++) {
                     diag_idx[j] = idx0[j+k0] + idx1[j+k1];
                 }
             } else {
-                stride1 = SDX_GET_STRIDE(na1->stridx[ax[1]]);
+                stride1 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[1]]);
                 for (j=0; j<diag_size; j++) {
                     diag_idx[j] = idx0[j+k0] + stride1*(j+k1);
                 }
             }
-            SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
+            CUMO_SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
         } else {
-            stride0 = SDX_GET_STRIDE(na1->stridx[ax[0]]);
-            if (SDX_IS_INDEX(na1->stridx[ax[1]])) {
-                idx1 = SDX_GET_INDEX(na1->stridx[ax[1]]);
+            stride0 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[0]]);
+            if (CUMO_SDX_IS_INDEX(na1->stridx[ax[1]])) {
+                idx1 = CUMO_SDX_GET_INDEX(na1->stridx[ax[1]]);
                 diag_idx = ALLOC_N(size_t, diag_size);
                 for (j=0; j<diag_size; j++) {
                     diag_idx[j] = stride0*(j+k0) + idx1[j+k1];
                 }
-                SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
+                CUMO_SDX_SET_INDEX(na2->stridx[nd-2],diag_idx);
             } else {
-                stride1 = SDX_GET_STRIDE(na1->stridx[ax[1]]);
+                stride1 = CUMO_SDX_GET_STRIDE(na1->stridx[ax[1]]);
                 na2->offset += stride0*k0 + stride1*k1;
-                SDX_SET_STRIDE(na2->stridx[nd-2],stride0+stride1);
+                CUMO_SDX_SET_STRIDE(na2->stridx[nd-2],stride0+stride1);
             }
         }
         break;
@@ -782,26 +782,26 @@ na_diagonal(int argc, VALUE *argv, VALUE self)
 #define SWAP(a,b,t) {t=a;a=b;b=t;}
 
 static VALUE
-na_new_dimension_for_dot(VALUE self, int pos, int len, bool transpose)
+cumo_na_new_dimension_for_dot(VALUE self, int pos, int len, bool transpose)
 {
     int i, k, l, nd;
     size_t  j;
     size_t *idx1, *idx2;
     size_t *shape;
     ssize_t stride;
-    narray_t *na;
-    narray_view_t *na1, *na2;
+    cumo_narray_t *na;
+    cumo_narray_view_t *na1, *na2;
     size_t shape_n;
-    stridx_t stridx_n;
+    cumo_stridx_t stridx_n;
     volatile VALUE view;
 
-    GetNArray(self,na);
+    CumoGetNArray(self,na);
     nd = na->ndim;
 
-    view = na_s_allocate_view(CLASS_OF(self));
+    view = cumo_na_s_allocate_view(rb_obj_class(self));
 
-    na_copy_flags(self, view);
-    GetNArrayView(view, na2);
+    cumo_na_copy_flags(self, view);
+    CumoGetNArrayView(view, na2);
 
     // new dimension
     if (pos < 0) pos += nd;
@@ -810,11 +810,11 @@ na_new_dimension_for_dot(VALUE self, int pos, int len, bool transpose)
     }
     nd += len;
     shape = ALLOCA_N(size_t,nd);
-    na2->stridx = ALLOC_N(stridx_t,nd);
+    na2->stridx = ALLOC_N(cumo_stridx_t,nd);
 
     switch(na->type) {
-    case NARRAY_DATA_T:
-    case NARRAY_FILEMAP_T:
+    case CUMO_NARRAY_DATA_T:
+    case CUMO_NARRAY_FILEMAP_T:
         i = k = 0;
         while (i < nd) {
             if (i == pos && len > 0) {
@@ -825,46 +825,46 @@ na_new_dimension_for_dot(VALUE self, int pos, int len, bool transpose)
                 shape[i++] = na->shape[k++];
             }
         }
-        na_setup_shape((narray_t*)na2, nd, shape);
-        stride = nary_element_stride(self);
+        cumo_na_setup_shape((cumo_narray_t*)na2, nd, shape);
+        stride = cumo_na_element_stride(self);
         for (i=nd; i--;) {
-            SDX_SET_STRIDE(na2->stridx[i], stride);
+            CUMO_SDX_SET_STRIDE(na2->stridx[i], stride);
             stride *= shape[i];
         }
         na2->offset = 0;
         na2->data = self;
         break;
-    case NARRAY_VIEW_T:
-        GetNArrayView(self, na1);
+    case CUMO_NARRAY_VIEW_T:
+        CumoGetNArrayView(self, na1);
         i = k = 0;
         while (i < nd) {
             if (i == pos && len > 0) {
-                if (SDX_IS_INDEX(na1->stridx[k])) {
-                    stride = SDX_GET_INDEX(na1->stridx[k])[0];
+                if (CUMO_SDX_IS_INDEX(na1->stridx[k])) {
+                    stride = CUMO_SDX_GET_INDEX(na1->stridx[k])[0];
                 } else {
-                    stride = SDX_GET_STRIDE(na1->stridx[k]);
+                    stride = CUMO_SDX_GET_STRIDE(na1->stridx[k]);
                 }
                 for (l=0; l<len; l++) {
                     shape[i] = 1;
-                    SDX_SET_STRIDE(na2->stridx[i], stride);
+                    CUMO_SDX_SET_STRIDE(na2->stridx[i], stride);
                     i++;
                 }
             } else {
                 shape[i] = na1->base.shape[k];
-                if (SDX_IS_INDEX(na1->stridx[k])) {
-                    idx1 = SDX_GET_INDEX(na1->stridx[k]);
+                if (CUMO_SDX_IS_INDEX(na1->stridx[k])) {
+                    idx1 = CUMO_SDX_GET_INDEX(na1->stridx[k]);
                     idx2 = ALLOC_N(size_t,na1->base.shape[k]);
                     for (j=0; j<na1->base.shape[k]; j++) {
                         idx2[j] = idx1[j];
                     }
-                    SDX_SET_INDEX(na2->stridx[i], idx2);
+                    CUMO_SDX_SET_INDEX(na2->stridx[i], idx2);
                 } else {
                     na2->stridx[i] = na1->stridx[k];
                 }
                 i++; k++;
             }
         }
-        na_setup_shape((narray_t*)na2, nd, shape);
+        cumo_na_setup_shape((cumo_narray_t*)na2, nd, shape);
         na2->offset = na1->offset;
         na2->data = na1->data;
         break;
@@ -894,48 +894,48 @@ cumo_na_dot(VALUE self, VALUE other)
 {
     VALUE test;
     volatile VALUE a1=self, a2=other;
-    narray_t *na1, *na2;
+    cumo_narray_t *na1, *na2;
 
-    test = rb_funcall(a1, id_respond_to_p, 1, sym_mulsum);
+    test = rb_funcall(a1, cumo_id_respond_to_p, 1, cumo_sym_mulsum);
     if (!RTEST(test)) {
         rb_raise(rb_eNoMethodError,"requires mulsum method for dot method");
     }
-    GetNArray(a1,na1);
-    GetNArray(a2,na2);
+    CumoGetNArray(a1,na1);
+    CumoGetNArray(a2,na2);
     if (na1->ndim==0 || na2->ndim==0) {
-        rb_raise(nary_eDimensionError,"zero dimensional narray");
+        rb_raise(cumo_na_eDimensionError,"zero dimensional narray");
     }
     if (na2->ndim > 1) {
         if (na1->shape[na1->ndim-1] != na2->shape[na2->ndim-2]) {
-            rb_raise(nary_eShapeError,"shape mismatch: self.shape[-1](=%"SZF"d) != other.shape[-2](=%"SZF"d)",
+            rb_raise(cumo_na_eShapeError,"shape mismatch: self.shape[-1](=%"SZF"d) != other.shape[-2](=%"SZF"d)",
                      na1->shape[na1->ndim-1], na2->shape[na2->ndim-2]);
         }
         // insert new axis [ ..., last-1-dim, newaxis*other.ndim, last-dim ]
-        a1 = na_new_dimension_for_dot(a1, na1->ndim-1, na2->ndim-1, 0);
+        a1 = cumo_na_new_dimension_for_dot(a1, na1->ndim-1, na2->ndim-1, 0);
         // insert & transpose [ newaxis*self.ndim, ..., last-dim, last-1-dim ]
-        a2 = na_new_dimension_for_dot(a2, 0, na1->ndim-1, 1);
+        a2 = cumo_na_new_dimension_for_dot(a2, 0, na1->ndim-1, 1);
     }
-    return rb_funcall(a1,id_mulsum,2,a2,INT2FIX(-1));
+    return rb_funcall(a1,cumo_id_mulsum,2,a2,INT2FIX(-1));
 }
 #endif
 
 void
-Init_cumo_nary_data()
+Init_cumo_na_data()
 {
-    rb_define_method(cNArray, "copy", na_copy, 0); // deprecated
+    rb_define_method(cNArray, "copy", cumo_na_copy, 0); // deprecated
 
-    rb_define_method(cNArray, "flatten", na_flatten, 0);
-    rb_define_method(cNArray, "swapaxes", na_swapaxes, 2);
-    rb_define_method(cNArray, "transpose", na_transpose, -1);
+    rb_define_method(cNArray, "flatten", cumo_na_flatten, 0);
+    rb_define_method(cNArray, "swapaxes", cumo_na_swapaxes, 2);
+    rb_define_method(cNArray, "transpose", cumo_na_transpose, -1);
 
-    rb_define_method(cNArray, "reshape", na_reshape,-1);
-    rb_define_method(cNArray, "reshape!", na_reshape_bang,-1);
+    rb_define_method(cNArray, "reshape", cumo_na_reshape,-1);
+    rb_define_method(cNArray, "reshape!", cumo_na_reshape_bang,-1);
     /*
     rb_define_alias(cNArray,  "shape=","reshape!");
     */
-    rb_define_method(cNArray, "diagonal", na_diagonal,-1);
+    rb_define_method(cNArray, "diagonal", cumo_na_diagonal,-1);
 
-    rb_define_method(cNArray, "swap_byte", nary_swap_byte, 0);
+    rb_define_method(cNArray, "swap_byte", cumo_na_swap_byte, 0);
 #ifdef DYNAMIC_ENDIAN
 #else
 #ifdef WORDS_BIGENDIAN
@@ -946,16 +946,16 @@ Init_cumo_nary_data()
     rb_define_alias(cNArray, "vacs_order?", "host_order?");
 #endif
 #endif
-    rb_define_method(cNArray, "to_network", nary_to_network, 0);
-    rb_define_method(cNArray, "to_vacs", nary_to_vacs, 0);
-    rb_define_method(cNArray, "to_host", nary_to_host, 0);
-    rb_define_method(cNArray, "to_swapped", nary_to_swapped, 0);
+    rb_define_method(cNArray, "to_network", cumo_na_to_network, 0);
+    rb_define_method(cNArray, "to_vacs", cumo_na_to_vacs, 0);
+    rb_define_method(cNArray, "to_host", cumo_na_to_host, 0);
+    rb_define_method(cNArray, "to_swapped", cumo_na_to_swapped, 0);
 
     //rb_define_method(cNArray, "dot", cumo_na_dot, 1);
 
-    id_mulsum       = rb_intern("mulsum");
-    sym_mulsum      = ID2SYM(id_mulsum);
-    id_respond_to_p = rb_intern("respond_to?");
-    id_store        = rb_intern("store");
-    id_swap_byte    = rb_intern("swap_byte");
+    cumo_id_mulsum       = rb_intern("mulsum");
+    cumo_sym_mulsum      = ID2SYM(cumo_id_mulsum);
+    cumo_id_respond_to_p = rb_intern("respond_to?");
+    cumo_id_store        = rb_intern("store");
+    cumo_id_swap_byte    = rb_intern("swap_byte");
 }