cumo 0.1.0 → 0.1.1

data/ext/cumo/include/cumo/types/complex_macro.h

@@ -19,17 +19,17 @@ extern double exp10(double);
 
 #include "complex.h"
 
-static inline dtype c_from_scomplex(scomplex x) {
+static inline dtype c_from_scomplex(cumo_scomplex x) {
     dtype z;
-    REAL(z) = REAL(x);
-    IMAG(z) = IMAG(x);
+    CUMO_REAL(z) = CUMO_REAL(x);
+    CUMO_IMAG(z) = CUMO_IMAG(x);
     return z;
 }
 
-static inline dtype c_from_dcomplex(dcomplex x) {
+static inline dtype c_from_dcomplex(cumo_dcomplex x) {
     dtype z;
-    REAL(z) = REAL(x);
-    IMAG(z) = IMAG(x);
+    CUMO_REAL(z) = CUMO_REAL(x);
+    CUMO_IMAG(z) = CUMO_IMAG(x);
     return z;
 }
 
@@ -53,8 +53,8 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 
 #define m_extract(x) COMP2NUM(*(dtype*)x)
 
-#define m_real(x)  REAL(x)
-#define m_imag(x)  IMAG(x)
+#define m_real(x)  CUMO_REAL(x)
+#define m_imag(x)  CUMO_IMAG(x)
 #define m_set_real(x,y)  c_set_real(x,y)
 #define m_set_imag(x,y)  c_set_imag(x,y)
 
@@ -70,19 +70,19 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_minus(x) c_minus(x)
 #define m_reciprocal(x) c_reciprocal(x)
 #define m_square(x) c_square(x)
-#define m_floor(x) c_new(floor(REAL(x)),floor(IMAG(x)))
-#define m_round(x) c_new(round(REAL(x)),round(IMAG(x)))
-#define m_ceil(x)  c_new(ceil(REAL(x)),ceil(IMAG(x)))
-#define m_trunc(x) c_new(trunc(REAL(x)),trunc(IMAG(x)))
-#define m_rint(x)  c_new(rint(REAL(x)),rint(IMAG(x)))
+#define m_floor(x) c_new(floor(CUMO_REAL(x)),floor(CUMO_IMAG(x)))
+#define m_round(x) c_new(round(CUMO_REAL(x)),round(CUMO_IMAG(x)))
+#define m_ceil(x)  c_new(ceil(CUMO_REAL(x)),ceil(CUMO_IMAG(x)))
+#define m_trunc(x) c_new(trunc(CUMO_REAL(x)),trunc(CUMO_IMAG(x)))
+#define m_rint(x)  c_new(rint(CUMO_REAL(x)),rint(CUMO_IMAG(x)))
 #define m_sign(x)  c_new( \
- ((REAL(x)==0) ? 0.0:((REAL(x)>0) ? 1.0:((REAL(x)<0) ? -1.0:REAL(x)))), \
- ((IMAG(x)==0) ? 0.0:((IMAG(x)>0) ? 1.0:((IMAG(x)<0) ? -1.0:IMAG(x)))))
-#define m_copysign(x,y) c_new(copysign(REAL(x),REAL(y)),copysign(IMAG(x),IMAG(y)))
+ ((CUMO_REAL(x)==0) ? 0.0:((CUMO_REAL(x)>0) ? 1.0:((CUMO_REAL(x)<0) ? -1.0:CUMO_REAL(x)))), \
+ ((CUMO_IMAG(x)==0) ? 0.0:((CUMO_IMAG(x)>0) ? 1.0:((CUMO_IMAG(x)<0) ? -1.0:CUMO_IMAG(x)))))
+#define m_copysign(x,y) c_new(copysign(CUMO_REAL(x),CUMO_REAL(y)),copysign(CUMO_IMAG(x),CUMO_IMAG(y)))
 
 #define m_im(x)    c_im(x)
-#define m_conj(x)  c_new(REAL(x),-IMAG(x))
-#define m_arg(x)   atan2(IMAG(x),REAL(x))
+#define m_conj(x)  c_new(CUMO_REAL(x),-CUMO_IMAG(x))
+#define m_arg(x)   atan2(CUMO_IMAG(x),CUMO_REAL(x))
 
 #define m_eq(x,y) c_eq(x,y)
 #define m_ne(x,y) c_ne(x,y)
@@ -94,7 +94,7 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_isneginf(x) c_isneginf(x)
 #define m_isfinite(x) c_isfinite(x)
 
-#define m_sprintf(s,x) sprintf(s,"%g%+gi",REAL(x),IMAG(x))
+#define m_sprintf(s,x) sprintf(s,"%g%+gi",CUMO_REAL(x),CUMO_IMAG(x))
 
 #define m_sqrt(x)    c_sqrt(x)
 #define m_cbrt(x)    c_cbrt(x)
@@ -122,7 +122,7 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_sum_init INT2FIX(0)
 #define m_mulsum_init INT2FIX(0)
 
-#define not_nan(x) (REAL(x)==REAL(x) && IMAG(x)==IMAG(x))
+#define not_nan(x) (CUMO_REAL(x)==CUMO_REAL(x) && CUMO_IMAG(x)==CUMO_IMAG(x))
 
 #define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
 #define m_mulsum_nan(x,y,z) {          \
@@ -186,11 +186,11 @@ static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
     r = c_zero();
     for (; i--;) {
         x = *(dtype*)p;
-        if (fabs(REAL(x)) > fabs(REAL(y))) {
-            double z=REAL(x); REAL(x)=REAL(y); REAL(y)=z;
+        if (fabs(CUMO_REAL(x)) > fabs(CUMO_REAL(y))) {
+            double z=CUMO_REAL(x); CUMO_REAL(x)=CUMO_REAL(y); CUMO_REAL(y)=z;
         }
-        if (fabs(IMAG(x)) > fabs(IMAG(y))) {
-            double z=IMAG(x); IMAG(x)=IMAG(y); IMAG(y)=z;
+        if (fabs(CUMO_IMAG(x)) > fabs(CUMO_IMAG(y))) {
+            double z=CUMO_IMAG(x); CUMO_IMAG(x)=CUMO_IMAG(y); CUMO_IMAG(y)=z;
         }
         r = c_add(x, r);
         t = y;
@@ -213,11 +213,11 @@ static inline dtype f_kahan_sum_nan(size_t n, char *p, ssize_t stride)
     for (; i--;) {
         x = *(dtype*)p;
         if (not_nan(x)) {
-            if (fabs(REAL(x)) > fabs(REAL(y))) {
-                double z=REAL(x); REAL(x)=REAL(y); REAL(y)=z;
+            if (fabs(CUMO_REAL(x)) > fabs(CUMO_REAL(y))) {
+                double z=CUMO_REAL(x); CUMO_REAL(x)=CUMO_REAL(y); CUMO_REAL(y)=z;
             }
-            if (fabs(IMAG(x)) > fabs(IMAG(y))) {
-                double z=IMAG(x); IMAG(x)=IMAG(y); IMAG(y)=z;
+            if (fabs(CUMO_IMAG(x)) > fabs(CUMO_IMAG(y))) {
+                double z=CUMO_IMAG(x); CUMO_IMAG(x)=CUMO_IMAG(y); CUMO_IMAG(y)=z;
             }
             r = c_add(x, r);
             t = y;

data/ext/cumo/include/cumo/types/complex_macro_kernel.h

@@ -22,17 +22,17 @@ extern double exp10(double);
 
 #include "complex_kernel.h"
 
-__host__ __device__ static inline dtype c_from_scomplex(scomplex x) {
+__host__ __device__ static inline dtype c_from_scomplex(cumo_scomplex x) {
     dtype z;
-    REAL(z) = REAL(x);
-    IMAG(z) = IMAG(x);
+    CUMO_REAL(z) = CUMO_REAL(x);
+    CUMO_IMAG(z) = CUMO_IMAG(x);
     return z;
 }
 
-__host__ __device__ static inline dtype c_from_dcomplex(dcomplex x) {
+__host__ __device__ static inline dtype c_from_dcomplex(cumo_dcomplex x) {
     dtype z;
-    REAL(z) = REAL(x);
-    IMAG(z) = IMAG(x);
+    CUMO_REAL(z) = CUMO_REAL(x);
+    CUMO_IMAG(z) = CUMO_IMAG(x);
     return z;
 }
 
@@ -56,8 +56,8 @@ __host__ __device__ static inline dtype c_from_dcomplex(dcomplex x) {
 
 //#define m_extract(x) COMP2NUM(*(dtype*)x)
 
-#define m_real(x)  REAL(x)
-#define m_imag(x)  IMAG(x)
+#define m_real(x)  CUMO_REAL(x)
+#define m_imag(x)  CUMO_IMAG(x)
 #define m_set_real(x,y)  c_set_real(x,y)
 #define m_set_imag(x,y)  c_set_imag(x,y)
 
@@ -73,19 +73,19 @@ __host__ __device__ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_minus(x) c_minus(x)
 #define m_reciprocal(x) c_reciprocal(x)
 #define m_square(x) c_square(x)
-#define m_floor(x) c_new(floor(REAL(x)),floor(IMAG(x)))
-#define m_round(x) c_new(round(REAL(x)),round(IMAG(x)))
-#define m_ceil(x)  c_new(ceil(REAL(x)),ceil(IMAG(x)))
-#define m_trunc(x) c_new(trunc(REAL(x)),trunc(IMAG(x)))
-#define m_rint(x)  c_new(rint(REAL(x)),rint(IMAG(x)))
+#define m_floor(x) c_new(floor(CUMO_REAL(x)),floor(CUMO_IMAG(x)))
+#define m_round(x) c_new(round(CUMO_REAL(x)),round(CUMO_IMAG(x)))
+#define m_ceil(x)  c_new(ceil(CUMO_REAL(x)),ceil(CUMO_IMAG(x)))
+#define m_trunc(x) c_new(trunc(CUMO_REAL(x)),trunc(CUMO_IMAG(x)))
+#define m_rint(x)  c_new(rint(CUMO_REAL(x)),rint(CUMO_IMAG(x)))
 #define m_sign(x)  c_new( \
- ((REAL(x)==0) ? 0.0:((REAL(x)>0) ? 1.0:((REAL(x)<0) ? -1.0:REAL(x)))), \
- ((IMAG(x)==0) ? 0.0:((IMAG(x)>0) ? 1.0:((IMAG(x)<0) ? -1.0:IMAG(x)))))
-#define m_copysign(x,y) c_new(copysign(REAL(x),REAL(y)),copysign(IMAG(x),IMAG(y)))
+ ((CUMO_REAL(x)==0) ? 0.0:((CUMO_REAL(x)>0) ? 1.0:((CUMO_REAL(x)<0) ? -1.0:CUMO_REAL(x)))), \
+ ((CUMO_IMAG(x)==0) ? 0.0:((CUMO_IMAG(x)>0) ? 1.0:((CUMO_IMAG(x)<0) ? -1.0:CUMO_IMAG(x)))))
+#define m_copysign(x,y) c_new(copysign(CUMO_REAL(x),CUMO_REAL(y)),copysign(CUMO_IMAG(x),CUMO_IMAG(y)))
 
 #define m_im(x)    c_im(x)
-#define m_conj(x)  c_new(REAL(x),-IMAG(x))
-#define m_arg(x)   atan2(IMAG(x),REAL(x))
+#define m_conj(x)  c_new(CUMO_REAL(x),-CUMO_IMAG(x))
+#define m_arg(x)   atan2(CUMO_IMAG(x),CUMO_REAL(x))
 
 #define m_eq(x,y) c_eq(x,y)
 #define m_ne(x,y) c_ne(x,y)
@@ -97,7 +97,7 @@ __host__ __device__ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_isneginf(x) c_isneginf(x)
 #define m_isfinite(x) c_isfinite(x)
 
-#define m_sprintf(s,x) sprintf(s,"%g%+gi",REAL(x),IMAG(x))
+#define m_sprintf(s,x) sprintf(s,"%g%+gi",CUMO_REAL(x),CUMO_IMAG(x))
 
 #define m_sqrt(x)    c_sqrt(x)
 #define m_cbrt(x)    c_cbrt(x)
@@ -125,7 +125,7 @@ __host__ __device__ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_sum_init 0
 #define m_mulsum_init 0
 
-#define not_nan(x) (REAL(x)==REAL(x) && IMAG(x)==IMAG(x))
+#define not_nan(x) (CUMO_REAL(x)==CUMO_REAL(x) && CUMO_IMAG(x)==CUMO_IMAG(x))
 
 #define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
 #define m_mulsum_nan(x,y,z) {          \

data/ext/cumo/include/cumo/types/dcomplex.h

@@ -1,4 +1,4 @@
-typedef dcomplex dtype;
+typedef cumo_dcomplex dtype;
 typedef double rtype;
 #define cT  cumo_cDComplex
 #define cRT cumo_cDFloat
@@ -17,8 +17,8 @@ static inline bool c_nearly_eq(dtype x, dtype y) {
 inline static dtype m_rand(dtype max)
 {
     dtype z;
-    REAL(z) = genrand_res53_mix() * REAL(max);
-    IMAG(z) = genrand_res53_mix() * IMAG(max);
+    CUMO_REAL(z) = genrand_res53_mix() * CUMO_REAL(max);
+    CUMO_IMAG(z) = genrand_res53_mix() * CUMO_IMAG(max);
     return z;
 }
 
@@ -36,8 +36,8 @@ inline static void m_rand_norm(dtype mu, rtype sigma, dtype *a0)
 	w = x1 * x1 + x2 * x2;
     } while (w>=1);
     w = sqrt( (-2*log(w)) / w );
-    REAL(*a0) = x1*w * sigma + REAL(mu);
-    IMAG(*a0) = x2*w * sigma + IMAG(mu);
+    CUMO_REAL(*a0) = x1*w * sigma + CUMO_REAL(mu);
+    CUMO_IMAG(*a0) = x2*w * sigma + CUMO_IMAG(mu);
 }
 #endif
 

data/ext/cumo/include/cumo/types/dcomplex_kernel.h

@@ -1,7 +1,7 @@
 #ifndef CUMO_DCOMPLEX_KERNEL_H
 #define CUMO_DCOMPLEX_KERNEL_H
 
-typedef dcomplex dtype;
+typedef cumo_dcomplex dtype;
 typedef double rtype;
 
 #include "complex_macro_kernel.h"

data/ext/cumo/include/cumo/types/int_macro.h

@@ -4,7 +4,7 @@
 
 static inline dtype m_abs(dtype x) {
     if (x==DATA_MIN) {
-        rb_raise(nary_eValueError, "cannot convert the minimum integer");
+        rb_raise(cumo_na_eValueError, "cannot convert the minimum integer");
     }
     return (x<0)?-x:x;
 }

data/ext/cumo/include/cumo/types/int_macro_kernel.h

@@ -8,7 +8,7 @@
 __host__ __device__ static inline dtype m_abs(dtype x) {
     // TODO(sonots): How to handle in CUDA kernel?
     // if (x==DATA_MIN) {
-    //     rb_raise(nary_eValueError, "cannot convert the minimum integer");
+    //     rb_raise(cumo_na_eValueError, "cannot convert the minimum integer");
     // }
     return (x<0)?-x:x;
 }

data/ext/cumo/include/cumo/types/robj_macro.h

@@ -18,45 +18,45 @@
 #define m_div(x,y)     rb_funcall(x,'/',1,y)
 #define m_mod(x,y)     rb_funcall(x,'%',1,y)
 #define m_divmod(x,y,a,b)                               \
-    {x = rb_funcall(x,id_divmod,1,y);                   \
+    {x = rb_funcall(x,cumo_id_divmod,1,y);                   \
      a = RARRAY_PTR(x)[0]; b = RARRAY_PTR(x)[0];}
-#define m_pow(x,y)     rb_funcall(x,id_pow,1,y)
-#define m_pow_int(x,y) rb_funcall(x,id_pow,1,y)
+#define m_pow(x,y)     rb_funcall(x,cumo_id_pow,1,y)
+#define m_pow_int(x,y) rb_funcall(x,cumo_id_pow,1,y)
 
-#define m_abs(x)       rb_funcall(x,id_abs,0)
-#define m_minus(x)     rb_funcall(x,id_minus,0)
-#define m_reciprocal(x)   rb_funcall(x,id_reciprocal,0)
+#define m_abs(x)       rb_funcall(x,cumo_id_abs,0)
+#define m_minus(x)     rb_funcall(x,cumo_id_minus,0)
+#define m_reciprocal(x)   rb_funcall(x,cumo_id_reciprocal,0)
 #define m_square(x)    rb_funcall(x,'*',1,x)
-#define m_floor(x)     rb_funcall(x,id_floor,0)
-#define m_round(x)     rb_funcall(x,id_round,0)
-#define m_ceil(x)      rb_funcall(x,id_ceil,0)
-#define m_trunc(x)     rb_funcall(x,id_truncate,0)
-#define m_sign(x)      rb_funcall(x,id_ufo,1,INT2FIX(0))
+#define m_floor(x)     rb_funcall(x,cumo_id_floor,0)
+#define m_round(x)     rb_funcall(x,cumo_id_round,0)
+#define m_ceil(x)      rb_funcall(x,cumo_id_ceil,0)
+#define m_trunc(x)     rb_funcall(x,cumo_id_truncate,0)
+#define m_sign(x)      rb_funcall(x,cumo_id_ufo,1,INT2FIX(0))
 
-#define m_eq(x,y)      RTEST(rb_funcall(x,id_eq,1,y))
-#define m_ne(x,y)      RTEST(rb_funcall(x,id_ne,1,y))
-#define m_gt(x,y)      RTEST(rb_funcall(x,id_gt,1,y))
-#define m_ge(x,y)      RTEST(rb_funcall(x,id_ge,1,y))
-#define m_lt(x,y)      RTEST(rb_funcall(x,id_lt,1,y))
-#define m_le(x,y)      RTEST(rb_funcall(x,id_le,1,y))
+#define m_eq(x,y)      RTEST(rb_funcall(x,cumo_id_eq,1,y))
+#define m_ne(x,y)      RTEST(rb_funcall(x,cumo_id_ne,1,y))
+#define m_gt(x,y)      RTEST(rb_funcall(x,cumo_id_gt,1,y))
+#define m_ge(x,y)      RTEST(rb_funcall(x,cumo_id_ge,1,y))
+#define m_lt(x,y)      RTEST(rb_funcall(x,cumo_id_lt,1,y))
+#define m_le(x,y)      RTEST(rb_funcall(x,cumo_id_le,1,y))
 
-#define m_bit_and(x,y) rb_funcall(x,id_bit_and,1,y)
-#define m_bit_or(x,y)  rb_funcall(x,id_bit_or, 1,y)
-#define m_bit_xor(x,y) rb_funcall(x,id_bit_xor,1,y)
-#define m_bit_not(x)   rb_funcall(x,id_bit_not,0)
+#define m_bit_and(x,y) rb_funcall(x,cumo_id_bit_and,1,y)
+#define m_bit_or(x,y)  rb_funcall(x,cumo_id_bit_or, 1,y)
+#define m_bit_xor(x,y) rb_funcall(x,cumo_id_bit_xor,1,y)
+#define m_bit_not(x)   rb_funcall(x,cumo_id_bit_not,0)
 
-#define m_left_shift(x,y) rb_funcall(x,id_left_shift,1,y)
-#define m_right_shift(x,y) rb_funcall(x,id_right_shift,1,y)
+#define m_left_shift(x,y) rb_funcall(x,cumo_id_left_shift,1,y)
+#define m_right_shift(x,y) rb_funcall(x,cumo_id_right_shift,1,y)
 
-#define m_isnan(x)     ((rb_respond_to(x,id_nan_p)) ? RTEST(rb_funcall(x,id_nan_p,0)) : 0)
-#define m_isinf(x)     ((rb_respond_to(x,id_infinite_p)) ? RTEST(rb_funcall(x,id_infinite_p,0)) : 0)
-#define m_isposinf(x)  ((rb_respond_to(x,id_infinite_p)) ?        \
-                        ((RTEST(rb_funcall(x,id_infinite_p,0))) ? \
+#define m_isnan(x)     ((rb_respond_to(x,cumo_id_nan_p)) ? RTEST(rb_funcall(x,cumo_id_nan_p,0)) : 0)
+#define m_isinf(x)     ((rb_respond_to(x,cumo_id_infinite_p)) ? RTEST(rb_funcall(x,cumo_id_infinite_p,0)) : 0)
+#define m_isposinf(x)  ((rb_respond_to(x,cumo_id_infinite_p)) ?        \
+                        ((RTEST(rb_funcall(x,cumo_id_infinite_p,0))) ? \
                          m_gt(x,INT2FIX(0)) : 0) : 0)
-#define m_isneginf(x)  ((rb_respond_to(x,id_infinite_p)) ?              \
-                        ((RTEST(rb_funcall(x,id_infinite_p,0))) ?       \
+#define m_isneginf(x)  ((rb_respond_to(x,cumo_id_infinite_p)) ?              \
+                        ((RTEST(rb_funcall(x,cumo_id_infinite_p,0))) ?       \
                          m_lt(x,INT2FIX(0)) : 0) : 0)
-#define m_isfinite(x)  ((rb_respond_to(x,id_finite_p)) ? RTEST(rb_funcall(x,id_finite_p,0)) : 0)
+#define m_isfinite(x)  ((rb_respond_to(x,cumo_id_finite_p)) ? RTEST(rb_funcall(x,cumo_id_finite_p,0)) : 0)
 
 #define m_mulsum_init INT2FIX(0)
 

data/ext/cumo/include/cumo/types/scomplex.h

@@ -1,4 +1,4 @@
-typedef scomplex dtype;
+typedef cumo_scomplex dtype;
 typedef float rtype;
 #define cT  cumo_cSComplex
 #define cRT cumo_cSFloat
@@ -17,8 +17,8 @@ static inline bool c_nearly_eq(dtype x, dtype y) {
 inline static dtype m_rand(dtype max)
 {
     dtype z;
-    REAL(z) = to_real2(gen_rand32()) * REAL(max);
-    IMAG(z) = to_real2(gen_rand32()) * IMAG(max);
+    CUMO_REAL(z) = to_real2(gen_rand32()) * CUMO_REAL(max);
+    CUMO_IMAG(z) = to_real2(gen_rand32()) * CUMO_IMAG(max);
     return z;
 }
 
@@ -36,8 +36,8 @@ inline static void m_rand_norm(dtype mu, rtype sigma, dtype *a0)
 	w = x1 * x1 + x2 * x2;
     } while (w>=1);
     w = sqrt( (-2*log(w)) / w );
-    REAL(*a0) = x1*w * sigma + REAL(mu);
-    IMAG(*a0) = x2*w * sigma + IMAG(mu);
+    CUMO_REAL(*a0) = x1*w * sigma + CUMO_REAL(mu);
+    CUMO_IMAG(*a0) = x2*w * sigma + CUMO_IMAG(mu);
 }
 #endif
 

data/ext/cumo/include/cumo/types/scomplex_kernel.h

@@ -1,7 +1,7 @@
 #ifndef CUMO_SCOMPLEX_KERNEL_H
 #define CUMO_SCOMPLEX_KERNEL_H
 
-typedef scomplex dtype;
+typedef cumo_scomplex dtype;
 typedef float rtype;
 
 #include "complex_macro_kernel.h"

data/ext/cumo/narray/array.c

@@ -5,31 +5,31 @@
 typedef struct {
   size_t shape;
   VALUE  val;
-} na_mdai_item_t;
+} cumo_na_mdai_item_t;
 
 typedef struct {
     int   capa;
-    na_mdai_item_t *item;
+    cumo_na_mdai_item_t *item;
     int   type;    // Ruby numeric type - investigated separately
     VALUE na_type;  // NArray type
     VALUE int_max;
-} na_mdai_t;
+} cumo_na_mdai_t;
 
 // Order of Ruby object.
-enum { NA_NONE, NA_BIT, NA_INT32, NA_INT64, NA_RATIONAL,
-       NA_DFLOAT, NA_DCOMPLEX, NA_ROBJ, NA_NTYPES };
+enum { CUMO_NA_NONE, CUMO_NA_BIT, CUMO_NA_INT32, CUMO_NA_INT64, CUMO_NA_RATIONAL,
+       CUMO_NA_DFLOAT, CUMO_NA_DCOMPLEX, CUMO_NA_ROBJ, CUMO_NA_NTYPES };
 
-static ID id_begin;
-static ID id_end;
-static ID id_step;
-static ID id_abs;
-static ID id_cast;
-static ID id_le;
-static ID id_Complex;
+static ID cumo_id_begin;
+static ID cumo_id_end;
+static ID cumo_id_step;
+static ID cumo_id_abs;
+static ID cumo_id_cast;
+static ID cumo_id_le;
+static ID cumo_id_Complex;
 
 
 static VALUE
- na_object_type(int type, VALUE v)
+ cumo_na_object_type(int type, VALUE v)
 {
     static VALUE int32_max = Qnil;
     if (NIL_P(int32_max))
@@ -39,124 +39,124 @@ static VALUE
 
     case T_TRUE:
     case T_FALSE:
-        if (type<NA_BIT)
-            return NA_BIT;
+        if (type<CUMO_NA_BIT)
+            return CUMO_NA_BIT;
         return type;
 
 #if SIZEOF_LONG == 4
     case T_FIXNUM:
-        if (type<NA_INT32)
-            return NA_INT32;
+        if (type<CUMO_NA_INT32)
+            return CUMO_NA_INT32;
         return type;
     case T_BIGNUM:
-        if (type<NA_INT64) {
-            v = rb_funcall(v,id_abs,0);
-            if (RTEST(rb_funcall(v,id_le,1,int32_max))) {
-                if (type<NA_INT32)
-                    return NA_INT32;
+        if (type<CUMO_NA_INT64) {
+            v = rb_funcall(v,cumo_id_abs,0);
+            if (RTEST(rb_funcall(v,cumo_id_le,1,int32_max))) {
+                if (type<CUMO_NA_INT32)
+                    return CUMO_NA_INT32;
             } else {
-                return NA_INT64;
+                return CUMO_NA_INT64;
             }
         }
         return type;
 
 #elif SIZEOF_LONG == 8
     case T_FIXNUM:
-        if (type<NA_INT64) {
+        if (type<CUMO_NA_INT64) {
             long x = NUM2LONG(v);
             if (x<0) x=-x;
             if (x<=2147483647) {
-                if (type<NA_INT32)
-                    return NA_INT32;
+                if (type<CUMO_NA_INT32)
+                    return CUMO_NA_INT32;
             } else {
-                return NA_INT64;
+                return CUMO_NA_INT64;
             }
         }
         return type;
     case T_BIGNUM:
-        if (type<NA_INT64)
-            return NA_INT64;
+        if (type<CUMO_NA_INT64)
+            return CUMO_NA_INT64;
         return type;
 #else
     case T_FIXNUM:
     case T_BIGNUM:
-        if (type<NA_INT64) {
-            v = rb_funcall(v,id_abs,0);
-            if (RTEST(rb_funcall(v,id_le,1,int32_max))) {
-                if (type<NA_INT32)
-                    return NA_INT32;
+        if (type<CUMO_NA_INT64) {
+            v = rb_funcall(v,cumo_id_abs,0);
+            if (RTEST(rb_funcall(v,cumo_id_le,1,int32_max))) {
+                if (type<CUMO_NA_INT32)
+                    return CUMO_NA_INT32;
             } else {
-                return NA_INT64;
+                return CUMO_NA_INT64;
             }
         }
         return type;
 #endif
 
     case T_FLOAT:
-        if (type<NA_DFLOAT)
-            return NA_DFLOAT;
+        if (type<CUMO_NA_DFLOAT)
+            return CUMO_NA_DFLOAT;
         return type;
 
     case T_NIL:
         return type;
 
     default:
-        if (CLASS_OF(v) == rb_const_get( rb_cObject, id_Complex )) {
-            return NA_DCOMPLEX;
+        if (rb_obj_class(v) == rb_const_get( rb_cObject, cumo_id_Complex )) {
+            return CUMO_NA_DCOMPLEX;
         }
     }
-    return NA_ROBJ;
+    return CUMO_NA_ROBJ;
 }
 
 
 #define MDAI_ATTR_TYPE(tp,v,attr)                               \
-    {tp = na_object_type(tp,rb_funcall(v,id_##attr,0));}
+    {tp = cumo_na_object_type(tp,rb_funcall(v,cumo_id_##attr,0));}
 
-static int na_mdai_object_type(int type, VALUE v)
+static int cumo_na_mdai_object_type(int type, VALUE v)
 {
     if (rb_obj_is_kind_of(v, rb_cRange)) {
         MDAI_ATTR_TYPE(type,v,begin);
         MDAI_ATTR_TYPE(type,v,end);
-    } else if (rb_obj_is_kind_of(v, na_cStep)) {
+    } else if (rb_obj_is_kind_of(v, cumo_na_cStep)) {
         MDAI_ATTR_TYPE(type,v,begin);
         MDAI_ATTR_TYPE(type,v,end);
         MDAI_ATTR_TYPE(type,v,step);
     } else {
-        type = na_object_type(type,v);
+        type = cumo_na_object_type(type,v);
     }
     return type;
 }
 
 
-static na_mdai_t *
-na_mdai_alloc(VALUE ary)
+static cumo_na_mdai_t *
+cumo_na_mdai_alloc(VALUE ary)
 {
     int i, n=4;
-    na_mdai_t *mdai;
+    cumo_na_mdai_t *mdai;
 
-    mdai = ALLOC(na_mdai_t);
+    mdai = ALLOC(cumo_na_mdai_t);
     mdai->capa = n;
-    mdai->item = ALLOC_N( na_mdai_item_t, n );
+    mdai->item = ALLOC_N( cumo_na_mdai_item_t, n );
     for (i=0; i<n; i++) {
         mdai->item[i].shape = 0;
         mdai->item[i].val = Qnil;
     }
     mdai->item[0].val = ary;
-    mdai->type = NA_NONE;
+    mdai->type = CUMO_NA_NONE;
     mdai->na_type = Qnil;
 
     return mdai;
 }
 
 static void
-na_mdai_realloc(na_mdai_t *mdai, int n_extra)
+cumo_na_mdai_realloc(cumo_na_mdai_t *mdai, int n_extra)
 {
     int i, n;
 
     i = mdai->capa;
     mdai->capa += n_extra;
     n = mdai->capa;
-    REALLOC_N( mdai->item, na_mdai_item_t, n );
+    REALLOC_N( mdai->item, cumo_na_mdai_item_t, n );
     for (; i<n; i++) {
         mdai->item[i].shape = 0;
         mdai->item[i].val = Qnil;
@@ -164,9 +164,9 @@ na_mdai_realloc(na_mdai_t *mdai, int n_extra)
 }
 
 static void
-na_mdai_free(void *ptr)
+cumo_na_mdai_free(void *ptr)
 {
-    na_mdai_t *mdai = (na_mdai_t*)ptr;
+    cumo_na_mdai_t *mdai = (cumo_na_mdai_t*)ptr;
     xfree(mdai->item);
     xfree(mdai);
 }
@@ -174,7 +174,7 @@ na_mdai_free(void *ptr)
 
 /* investigate ndim, shape, type of Array */
 static int
-na_mdai_investigate(na_mdai_t *mdai, int ndim)
+cumo_na_mdai_investigate(cumo_na_mdai_t *mdai, int ndim)
 {
     ssize_t i;
     int j;
@@ -197,28 +197,28 @@ na_mdai_investigate(na_mdai_t *mdai, int ndim)
                              "cannot convert from a recursive Array to NArray");
             }
             if ( ndim >= mdai->capa ) {
-                na_mdai_realloc(mdai,4);
+                cumo_na_mdai_realloc(mdai,4);
             }
             mdai->item[ndim].val = v;
-            if ( na_mdai_investigate(mdai,ndim+1) ) {
+            if ( cumo_na_mdai_investigate(mdai,ndim+1) ) {
                 len--; /* Array is empty */
             }
         }
         else
-        if (rb_obj_is_kind_of(v, rb_cRange) || rb_obj_is_kind_of(v, na_cStep)) {
-            nary_step_sequence(v,&length,&dbeg,&dstep);
+        if (rb_obj_is_kind_of(v, rb_cRange) || rb_obj_is_kind_of(v, cumo_na_cStep)) {
+            cumo_na_step_sequence(v,&length,&dbeg,&dstep);
             len += length-1;
-            mdai->type = na_mdai_object_type(mdai->type, v);
+            mdai->type = cumo_na_mdai_object_type(mdai->type, v);
         }
-        else if (IsNArray(v)) {
+        else if (CumoIsNArray(v)) {
             int r;
-            narray_t *na;
-            GetNArray(v,na);
+            cumo_narray_t *na;
+            CumoGetNArray(v,na);
             if ( na->ndim == 0 ) {
                 len--; /* NArray is empty */
             } else {
                 if ( ndim+na->ndim > mdai->capa ) {
-                    na_mdai_realloc(mdai,((na->ndim-1)/4+1)*4);
+                    cumo_na_mdai_realloc(mdai,((na->ndim-1)/4+1)*4);
                 }
                 for ( j=0,r=ndim; j < na->ndim  ; j++,r++ ) {
                     if ( mdai->item[r].shape < na->shape[j] )
@@ -227,12 +227,12 @@ na_mdai_investigate(na_mdai_t *mdai, int ndim)
             }
             // type
             if (NIL_P(mdai->na_type)) {
-                mdai->na_type = CLASS_OF(v);
+                mdai->na_type = rb_obj_class(v);
             } else {
-                mdai->na_type = na_upcast(CLASS_OF(v), mdai->na_type);
+                mdai->na_type = cumo_na_upcast(rb_obj_class(v), mdai->na_type);
             }
         } else {
-            mdai->type = na_mdai_object_type(mdai->type, v);
+            mdai->type = cumo_na_mdai_object_type(mdai->type, v);
         }
     }
 
@@ -245,7 +245,7 @@ na_mdai_investigate(na_mdai_t *mdai, int ndim)
 
 
 static inline int
-na_mdai_ndim(na_mdai_t *mdai)
+cumo_na_mdai_ndim(cumo_na_mdai_t *mdai)
 {
     int i;
     // Dimension
@@ -254,7 +254,7 @@ na_mdai_ndim(na_mdai_t *mdai)
 }
 
 static inline void
-na_mdai_shape(na_mdai_t *mdai, int ndim, size_t *shape)
+cumo_na_mdai_shape(cumo_na_mdai_t *mdai, int ndim, size_t *shape)
 {
     int i;
     for (i=0; i<ndim; i++) {
@@ -263,27 +263,27 @@ na_mdai_shape(na_mdai_t *mdai, int ndim, size_t *shape)
 }
 
 static VALUE
-na_mdai_dtype_numeric(int type)
+cumo_na_mdai_dtype_numeric(int type)
 {
     VALUE tp;
     // DataType
     switch(type) {
-    case NA_BIT:
+    case CUMO_NA_BIT:
         tp = cumo_cBit;
         break;
-    case NA_INT32:
+    case CUMO_NA_INT32:
         tp = cumo_cInt32;
         break;
-    case NA_INT64:
+    case CUMO_NA_INT64:
         tp = cumo_cInt64;
         break;
-    case NA_DFLOAT:
+    case CUMO_NA_DFLOAT:
         tp = cumo_cDFloat;
         break;
-    case NA_DCOMPLEX:
+    case CUMO_NA_DCOMPLEX:
         tp = cumo_cDComplex;
         break;
-    case NA_ROBJ:
+    case CUMO_NA_ROBJ:
         tp = cumo_cRObject;
         break;
     default:
@@ -293,17 +293,17 @@ na_mdai_dtype_numeric(int type)
 }
 
 static VALUE
-na_mdai_dtype(na_mdai_t *mdai)
+cumo_na_mdai_dtype(cumo_na_mdai_t *mdai)
 {
     VALUE tp;
 
-    tp = na_mdai_dtype_numeric(mdai->type);
+    tp = cumo_na_mdai_dtype_numeric(mdai->type);
 
     if (!NIL_P(mdai->na_type)) {
         if (NIL_P(tp)) {
             tp = mdai->na_type;
         } else {
-            tp = na_upcast(mdai->na_type,tp);
+            tp = cumo_na_upcast(mdai->na_type,tp);
         }
     }
     return tp;
@@ -327,41 +327,41 @@ static inline void
 check_subclass_of_narray(VALUE dtype)
 {
     if (RTEST(rb_obj_is_kind_of(dtype, rb_cClass))) {
-        if (RTEST(rb_funcall(dtype, id_le, 1, cNArray))) {
+        if (RTEST(rb_funcall(dtype, cumo_id_le, 1, cNArray))) {
             return;
         }
     }
-    rb_raise(nary_eCastError, "cannot convert to NArray");
+    rb_raise(cumo_na_eCastError, "cannot convert to NArray");
 }
 
 
 static size_t
-na_mdai_memsize(const void *ptr)
+cumo_na_mdai_memsize(const void *ptr)
 {
-    const na_mdai_t *mdai = (const na_mdai_t*)ptr;
+    const cumo_na_mdai_t *mdai = (const cumo_na_mdai_t*)ptr;
 
-    return sizeof(na_mdai_t) + mdai->capa * sizeof(na_mdai_item_t);
+    return sizeof(cumo_na_mdai_t) + mdai->capa * sizeof(cumo_na_mdai_item_t);
 }
 
 static const rb_data_type_t mdai_data_type = {
     "Cumo::NArray/mdai",
-    {NULL, na_mdai_free, na_mdai_memsize,},
+    {NULL, cumo_na_mdai_free, cumo_na_mdai_memsize,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
 };
 
 
 static void
-na_composition3_ary(VALUE ary, VALUE *ptype, VALUE *pshape, VALUE *pnary)
+cumo_na_composition3_ary(VALUE ary, VALUE *ptype, VALUE *pshape, VALUE *pnary)
 {
     VALUE vmdai;
-    na_mdai_t *mdai;
+    cumo_na_mdai_t *mdai;
     int i, ndim;
     size_t *shape;
     VALUE dtype, dshape;
 
-    mdai = na_mdai_alloc(ary);
+    mdai = cumo_na_mdai_alloc(ary);
     vmdai = TypedData_Wrap_Struct(rb_cData, &mdai_data_type, (void*)mdai);
-    if ( na_mdai_investigate(mdai, 1) ) {
+    if ( cumo_na_mdai_investigate(mdai, 1) ) {
         // empty
         dtype = update_type(ptype, cumo_cInt32);
         if (pshape) {
@@ -371,13 +371,13 @@ na_composition3_ary(VALUE ary, VALUE *ptype, VALUE *pshape, VALUE *pnary)
             check_subclass_of_narray(dtype);
             shape = ALLOCA_N(size_t, 1);
             shape[0] = 0;
-            *pnary = nary_new(dtype, 1, shape);
+            *pnary = cumo_na_new(dtype, 1, shape);
         }
     } else {
-        ndim = na_mdai_ndim(mdai);
+        ndim = cumo_na_mdai_ndim(mdai);
         shape = ALLOCA_N(size_t, ndim);
-        na_mdai_shape(mdai, ndim, shape);
-        dtype = update_type(ptype, na_mdai_dtype(mdai));
+        cumo_na_mdai_shape(mdai, ndim, shape);
+        dtype = update_type(ptype, cumo_na_mdai_dtype(mdai));
         if (pshape) {
             dshape = rb_ary_new2(ndim);
             for (i=0; i<ndim; i++) {
@@ -387,7 +387,7 @@ na_composition3_ary(VALUE ary, VALUE *ptype, VALUE *pshape, VALUE *pnary)
         }
         if (pnary) {
             check_subclass_of_narray(dtype);
-            *pnary = nary_new(dtype, ndim, shape);
+            *pnary = cumo_na_new(dtype, ndim, shape);
         }
     }
     RB_GC_GUARD(vmdai);
@@ -395,30 +395,30 @@ na_composition3_ary(VALUE ary, VALUE *ptype, VALUE *pshape, VALUE *pnary)
 
 
 static void
-na_composition3(VALUE obj, VALUE *ptype, VALUE *pshape, VALUE *pnary)
+cumo_na_composition3(VALUE obj, VALUE *ptype, VALUE *pshape, VALUE *pnary)
 {
     VALUE dtype, dshape;
 
     if (TYPE(obj) == T_ARRAY) {
-        na_composition3_ary(obj, ptype, pshape, pnary);
+        cumo_na_composition3_ary(obj, ptype, pshape, pnary);
     }
     else if (RTEST(rb_obj_is_kind_of(obj,rb_cNumeric))) {
-        dtype = na_mdai_dtype_numeric(na_mdai_object_type(NA_NONE, obj));
+        dtype = cumo_na_mdai_dtype_numeric(cumo_na_mdai_object_type(CUMO_NA_NONE, obj));
         dtype = update_type(ptype, dtype);
         if (pshape) {
             *pshape = rb_ary_new();
         }
         if (pnary) {
             check_subclass_of_narray(dtype);
-            *pnary = nary_new(dtype, 0, 0);
+            *pnary = cumo_na_new(dtype, 0, 0);
         }
     }
-    else if (IsNArray(obj)) {
+    else if (CumoIsNArray(obj)) {
         int i, ndim;
-        narray_t *na;
-        GetNArray(obj,na);
+        cumo_narray_t *na;
+        CumoGetNArray(obj,na);
         ndim = na->ndim;
-        dtype = update_type(ptype, CLASS_OF(obj));
+        dtype = update_type(ptype, rb_obj_class(obj));
         if (pshape) {
             dshape = rb_ary_new2(ndim);
             for (i=0; i<ndim; i++) {
@@ -427,17 +427,17 @@ na_composition3(VALUE obj, VALUE *ptype, VALUE *pshape, VALUE *pnary)
             *pshape = dshape;
         }
         if (pnary) {
-            *pnary = nary_new(dtype, ndim, na->shape);
+            *pnary = cumo_na_new(dtype, ndim, na->shape);
         }
     } else {
         rb_raise(rb_eTypeError,"invalid type for NArray: %s",
-                 rb_class2name(CLASS_OF(obj)));
+                 rb_class2name(rb_obj_class(obj)));
     }
 }
 
 
 static VALUE
-na_s_array_shape(VALUE mod, VALUE ary)
+cumo_na_s_array_shape(VALUE mod, VALUE ary)
 {
     VALUE shape;
 
@@ -445,7 +445,7 @@ na_s_array_shape(VALUE mod, VALUE ary)
         // 0-dimension
         return rb_ary_new();
     }
-    na_composition3(ary, 0, &shape, 0);
+    cumo_na_composition3(ary, 0, &shape, 0);
     return shape;
 }
 
@@ -467,28 +467,28 @@ na_s_array_shape(VALUE mod, VALUE ary)
     => Cumo::DComplex#shape=[3](empty)
 */
 VALUE
-na_s_new_like(VALUE type, VALUE obj)
+cumo_na_s_new_like(VALUE type, VALUE obj)
 {
     VALUE newary;
 
-    na_composition3(obj, &type, 0, &newary);
+    cumo_na_composition3(obj, &type, 0, &newary);
     return newary;
 }
 
 
 VALUE
-na_ary_composition_dtype(VALUE ary)
+cumo_na_ary_composition_dtype(VALUE ary)
 {
     VALUE type = Qnil;
 
-    na_composition3(ary, &type, 0, 0);
+    cumo_na_composition3(ary, &type, 0, 0);
     return type;
 }
 
 static VALUE
-na_s_array_type(VALUE mod, VALUE ary)
+cumo_na_s_array_type(VALUE mod, VALUE ary)
 {
-    return na_ary_composition_dtype(ary);
+    return cumo_na_ary_composition_dtype(ary);
 }
 
 
@@ -499,16 +499,16 @@ na_s_array_type(VALUE mod, VALUE ary)
   @return [NArray]
 */
 static VALUE
-nary_s_bracket(VALUE klass, VALUE ary)
+cumo_na_s_bracket(VALUE klass, VALUE ary)
 {
     VALUE dtype=Qnil;
 
     if (TYPE(ary)!=T_ARRAY) {
         rb_bug("Argument is not array");
     }
-    dtype = na_ary_composition_dtype(ary);
+    dtype = cumo_na_ary_composition_dtype(ary);
     check_subclass_of_narray(dtype);
-    return rb_funcall(dtype, id_cast, 1, ary);
+    return rb_funcall(dtype, cumo_id_cast, 1, ary);
 }
 
 
@@ -519,14 +519,14 @@ nary_s_bracket(VALUE klass, VALUE ary)
 /* investigate ndim, shape, type of Array */
 /*
 static int
-na_mdai_for_struct(na_mdai_t *mdai, int ndim)
+cumo_na_mdai_for_struct(cumo_na_mdai_t *mdai, int ndim)
 {
     size_t i;
     int j, r;
     size_t len;
     VALUE  v;
     VALUE  val;
-    narray_t *na;
+    cumo_narray_t *na;
 
     //fprintf(stderr,"ndim=%d\n",ndim);    rb_p(mdai->na_type);
     if (ndim>4) { abort(); }
@@ -534,11 +534,11 @@ na_mdai_for_struct(na_mdai_t *mdai, int ndim)
 
     //fpintf(stderr,"val = ");    rb_p(val);
 
-    if (CLASS_OF(val) == mdai->na_type) {
-        GetNArray(val,na);
+    if (rb_obj_class(val) == mdai->na_type) {
+        CumoGetNArray(val,na);
         if ( ndim+na->ndim > mdai->capa ) {
             abort();
-            na_mdai_realloc(mdai,((na->ndim-1)/4+1)*4);
+            cumo_na_mdai_realloc(mdai,((na->ndim-1)/4+1)*4);
         }
         for ( j=0,r=ndim; j < na->ndim; j++,r++ ) {
             if ( mdai->item[r].shape < na->shape[j] )
@@ -563,7 +563,7 @@ na_mdai_for_struct(na_mdai_t *mdai, int ndim)
         // otherwise, multi-dimention
         if (ndim >= mdai->capa) {
             //fprintf(stderr,"exeed capa\n");            abort();
-            na_mdai_realloc(mdai,4);
+            cumo_na_mdai_realloc(mdai,4);
         }
         // finally, multidimension-check
         len = RARRAY_LEN(val);
@@ -578,7 +578,7 @@ na_mdai_for_struct(na_mdai_t *mdai, int ndim)
             v = RARRAY_AREF(val,i);
             //fprintf(stderr,"check:");            rb_p(v);
             mdai->item[ndim+1].val = v;
-            if ( na_mdai_for_struct( mdai, ndim+1 ) == 0 ) {
+            if ( cumo_na_mdai_for_struct( mdai, ndim+1 ) == 0 ) {
                 //fprintf(stderr,"not struct:");                rb_p(v);
                 //abort();
                 return 0;
@@ -598,19 +598,19 @@ na_mdai_for_struct(na_mdai_t *mdai, int ndim)
 
 /*
 VALUE
-na_ary_composition_for_struct(VALUE nstruct, VALUE ary)
+cumo_na_ary_composition_for_struct(VALUE nstruct, VALUE ary)
 {
     volatile VALUE vmdai, vnc;
-    na_mdai_t *mdai;
-    na_compose_t *nc;
+    cumo_na_mdai_t *mdai;
+    cumo_na_compose_t *nc;
 
-    mdai = na_mdai_alloc(ary);
+    mdai = cumo_na_mdai_alloc(ary);
     mdai->na_type = nstruct;
     vmdai = TypedData_Wrap_Struct(rb_cData, &mdai_data_type, (void*)mdai);
-    na_mdai_for_struct(mdai, 0);
-    nc = na_compose_alloc();
+    cumo_na_mdai_for_struct(mdai, 0);
+    nc = cumo_na_compose_alloc();
     vnc = WrapCompose(nc);
-    na_mdai_result(mdai, nc);
+    cumo_na_mdai_result(mdai, nc);
     //fprintf(stderr,"nc->ndim=%d\n",nc->ndim);
     rb_gc_force_recycle(vmdai);
     return vnc;
@@ -620,19 +620,19 @@ na_ary_composition_for_struct(VALUE nstruct, VALUE ary)
 
 
 void
-Init_cumo_nary_array()
+Init_cumo_na_array()
 {
-    rb_define_singleton_method(cNArray, "array_shape", na_s_array_shape, 1);
-    rb_define_singleton_method(cNArray, "array_type", na_s_array_type, 1);
-    rb_define_singleton_method(cNArray, "new_like", na_s_new_like, 1);
-
-    rb_define_singleton_method(cNArray, "[]", nary_s_bracket, -2);
-
-    id_begin   = rb_intern("begin");
-    id_end     = rb_intern("end");
-    id_step    = rb_intern("step");
-    id_cast    = rb_intern("cast");
-    id_abs     = rb_intern("abs");
-    id_le      = rb_intern("<=");
-    id_Complex = rb_intern("Complex");
+    rb_define_singleton_method(cNArray, "array_shape", cumo_na_s_array_shape, 1);
+    rb_define_singleton_method(cNArray, "array_type", cumo_na_s_array_type, 1);
+    rb_define_singleton_method(cNArray, "new_like", cumo_na_s_new_like, 1);
+
+    rb_define_singleton_method(cNArray, "[]", cumo_na_s_bracket, -2);
+
+    cumo_id_begin   = rb_intern("begin");
+    cumo_id_end     = rb_intern("end");
+    cumo_id_step    = rb_intern("step");
+    cumo_id_cast    = rb_intern("cast");
+    cumo_id_abs     = rb_intern("abs");
+    cumo_id_le      = rb_intern("<=");
+    cumo_id_Complex = rb_intern("Complex");
 }