cumo 0.1.0 → 0.1.1

data/ext/cumo/include/cumo.h

@@ -10,8 +10,8 @@ extern "C" {
 #endif
 #endif
 
-#define CUMO_VERSION "0.1.0"
-#define CUMO_VERSION_CODE 10
+#define CUMO_VERSION "0.1.1"
+#define CUMO_VERSION_CODE 11
 
 bool cumo_compatible_mode_enabled_p();
 

data/ext/cumo/include/cumo/cuda/cublas.h

@@ -11,137 +11,14 @@ extern "C" {
 #endif
 #endif
 
-#define option_value cumo_cublas_option_value
-extern VALUE cumo_cublas_option_value(VALUE value, VALUE default_value);
+void
+cumo_cuda_cublas_check_status(cublasStatus_t status);
 
-//#define option_order cumo_cublas_option_order
-//extern enum CBLAS_ORDER cumo_cublas_option_order(VALUE order);
+cublasHandle_t
+cumo_cuda_cublas_handle();
 
-#define option_trans cumo_cublas_option_trans
-extern cublasOperation_t cumo_cublas_option_trans(VALUE trans);
-
-#define option_uplo cumo_cublas_option_uplo
-extern cublasFillMode_t cumo_cublas_option_uplo(VALUE uplo);
-
-#define option_diag cumo_cublas_option_diag
-extern cublasDiagType_t cumo_cublas_option_diag(VALUE diag);
-
-#define option_side cumo_cublas_option_side
-extern cublasSideMode_t cumo_cublas_option_side(VALUE side);
-
-//#define check_func cumo_cublas_check_func
-//extern void cumo_cublas_check_func(void **func, const char *name);
-
-// TODO: Check if a and b are row_major?
-#define SWAP_IFROW(a,b,tmp)                                       \
-    {(tmp)=(a);(a)=(b);(b)=(tmp);}
-
-#define SWAP_IFTR(trans,a,b,tmp)                                  \
-    { if ((trans)!=CUBLAS_OP_N)                                   \
-            {(tmp)=(a);(a)=(b);(b)=(tmp);}                        \
-    }
-
-/*
-//#define SWAP_IFCOLTR(order,trans,a,b,tmp)                       \
-//    { if (((order)==CblasRowMajor && (trans)!=CblasNoTrans) ||  \
-//          ((order)!=CblasRowMajor && (trans)==CblasNoTrans))    \
-//            {(tmp)=(a);(a)=(b);(b)=(tmp);}                      \
-//    }
-
-//#define SWAP_IFCOL(order,a,b,tmp)                               \
-//    { if ((order)==CblasColMajor) {(tmp)=(a);(a)=(b);(b)=(tmp);} }
-//
-//#define SWAP_IFROW(order,a,b,tmp)                               \
-//    { if ((order)==CblasRowMajor) {(tmp)=(a);(a)=(b);(b)=(tmp);} }
-//
-//#define SWAP_IFCOLTR(order,trans,a,b,tmp)                       \
-//    { if (((order)==CblasRowMajor && (trans)!=CblasNoTrans) ||  \
-//          ((order)!=CblasRowMajor && (trans)==CblasNoTrans))    \
-//            {(tmp)=(a);(a)=(b);(b)=(tmp);}                      \
-//    }
-//
-//#define CHECK_FUNC(fptr, fname)                                 \
-//    { if ((fptr)==0) { check_func((void*)(&(fptr)),fname); } }
-*/
-
-#define ROW_SIZE(na) ((na)->shape[(na)->ndim-2])
-#define COL_SIZE(na) ((na)->shape[(na)->ndim-1])
-
-#define CHECK_NARRAY_TYPE(x,t)                                 \
-    if (CLASS_OF(x)!=(t)) {                                    \
-        rb_raise(rb_eTypeError,"invalid NArray type (class)"); \
-    }
-
-// Error Class ??
-#define CHECK_DIM_GE(na,nd)                                     \
-    if ((na)->ndim<(nd)) {                                      \
-        rb_raise(nary_eShapeError,                              \
-                 "n-dimension=%d, but >=%d is expected",        \
-                 (na)->ndim, (nd));                             \
-    }
-
-#define CHECK_DIM_EQ(na1,nd)                                    \
-    if ((na1)->ndim != (nd)) {                                  \
-        rb_raise(nary_eShapeError,                              \
-                 "dimention mismatch: %d != %d",                \
-                 (na1)->ndim, (nd));                            \
-    }
-
-#define CHECK_SQUARE(name,na)                                           \
-    if ((na)->shape[(na)->ndim-1] != (na)->shape[(na)->ndim-2]) {       \
-        rb_raise(nary_eShapeError,"%s is not square matrix",name);      \
-    }
-
-#define CHECK_SIZE_GE(na,sz)                                    \
-    if ((na)->size < (size_t)(sz)) {                            \
-        rb_raise(nary_eShapeError,                              \
-                 "NArray size must be >= %"SZF"u",(size_t)(sz));\
-    }
-#define CHECK_NON_EMPTY(na)                                     \
-    if ((na)->size==0) {                                        \
-        rb_raise(nary_eShapeError,"empty NArray");              \
-    }
-
-#define CHECK_SIZE_EQ(n,m)                                      \
-    if ((n)!=(m)) {                                             \
-        rb_raise(nary_eShapeError,                              \
-                 "size mismatch: %"SZF"d != %"SZF"d",           \
-                 (size_t)(n),(size_t)(m));                      \
-    }
-
-#define CHECK_SAME_SHAPE(na1,na2)                                \
-    {   int i;                                                   \
-        CHECK_DIM_EQ(na1,na2->ndim);                             \
-        for (i=0; i<na1->ndim; i++) {                            \
-            CHECK_SIZE_EQ(na1->shape[i],na2->shape[i]);          \
-        }                                                        \
-    }
-
-#define CHECK_INT_EQ(sm,m,sn,n)                          \
-    if ((m) != (n)) {                                    \
-        rb_raise(nary_eShapeError,                       \
-                 "%s must be == %s: %s=%d %s=%d",        \
-                 sm,sn,sm,m,sn,n);                       \
-    }
-
-// Error Class ??
-#define CHECK_LEADING_GE(sld,ld,sn,n)                    \
-    if ((ld) < (n)) {                                    \
-        rb_raise(nary_eShapeError,                       \
-                 "%s must be >= max(%s,1): %s=%d %s=%d", \
-                 sld,sn,sld,ld,sn,n);                    \
-    }
-
-#define COPY_OR_CAST_TO(a,T)                            \
-    {                                                   \
-        if (CLASS_OF(a) == (T)) {                       \
-            if (!TEST_INPLACE(a)) {                     \
-                a = na_copy(a);                         \
-            }                                           \
-        } else {                                        \
-            a = rb_funcall(T,rb_intern("cast"),1,a);    \
-        }                                               \
-    }
+VALUE
+cumo_cuda_cublas_option_value(VALUE value, VALUE default_value);
 
 #if defined(__cplusplus)
 #if 0

data/ext/cumo/include/cumo/cuda/runtime.h

@@ -21,6 +21,22 @@ cumo_cuda_runtime_check_status(cudaError_t status)
     }
 }
 
+static inline int
+cumo_cuda_runtime_get_device_count()
+{
+    int device_count;
+    cumo_cuda_runtime_check_status(cudaGetDeviceCount(&device_count));
+    return device_count;
+}
+
+static inline int
+cumo_cuda_runtime_get_device()
+{
+    int device;
+    cumo_cuda_runtime_check_status(cudaGetDevice(&device));
+    return device;
+}
+
 static inline bool
 cumo_cuda_runtime_is_device_memory(void* ptr)
 {

data/ext/cumo/include/cumo/indexer.h

@@ -1,11 +1,6 @@
 #ifndef CUMO_INDEXER_H
 #define CUMO_INDEXER_H
 
-/* Add cumo_ prefix */
-#define na_indexer_t cumo_na_indexer_t
-#define na_iarray_t cumo_na_iarray_t
-#define na_reduction_arg_t cumo_na_reduction_arg_t
-
 #ifndef __CUDACC__
 #include "cumo/narray.h"
 #include "cumo/ndloop.h"
@@ -21,10 +16,10 @@
 typedef struct {
     unsigned char ndim;               // # of dimensions
     size_t total_size;                // # of total elements
-    size_t shape[NA_MAX_DIMENSION];   // # of elements for each dimension
-    uint64_t index[NA_MAX_DIMENSION]; // indicies for each dimension
+    size_t shape[CUMO_NA_MAX_DIMENSION];   // # of elements for each dimension
+    uint64_t index[CUMO_NA_MAX_DIMENSION]; // indicies for each dimension
     uint64_t raw_index;
-} na_indexer_t;
+} cumo_na_indexer_t;
 
 /* A structure to get data address with indexer.
  *
@@ -32,24 +27,23 @@ typedef struct {
  */
 typedef struct {
     char* ptr;
-    ssize_t step[NA_MAX_DIMENSION]; // or strides
-} na_iarray_t;
+    ssize_t step[CUMO_NA_MAX_DIMENSION]; // or strides
+} cumo_na_iarray_t;
 
 typedef struct {
-    na_iarray_t in;
-    na_iarray_t out;
-    na_indexer_t in_indexer;
-    na_indexer_t out_indexer;
-    na_indexer_t reduce_indexer;
-} na_reduction_arg_t;
+    cumo_na_iarray_t in;
+    cumo_na_iarray_t out;
+    cumo_na_indexer_t in_indexer;
+    cumo_na_indexer_t out_indexer;
+} cumo_na_reduction_arg_t;
 
 #ifndef __CUDACC__
-extern int na_debug_flag;  // narray.c
+extern int cumo_na_debug_flag;  // narray.c
 
 static void
-print_na_indexer_t(na_indexer_t* indexer)
+print_cumo_na_indexer_t(cumo_na_indexer_t* indexer)
 {
-    printf("na_indexer_t = 0x%"SZF"x {\n", (size_t)indexer);
+    printf("cumo_na_indexer_t = 0x%"SZF"x {\n", (size_t)indexer);
     printf("  ndim = %d\n", indexer->ndim);
     printf("  total_size = %ld\n", indexer->total_size);
     printf("  shape = 0x%"SZF"x\n", (size_t)indexer->shape);
@@ -60,9 +54,9 @@ print_na_indexer_t(na_indexer_t* indexer)
 }
 
 static void
-print_na_iarray_t(na_iarray_t* iarray, unsigned char ndim)
+print_cumo_na_iarray_t(cumo_na_iarray_t* iarray, unsigned char ndim)
 {
-    printf("na_iarray_t = 0x%"SZF"x {\n", (size_t)iarray);
+    printf("cumo_na_iarray_t = 0x%"SZF"x {\n", (size_t)iarray);
     printf("  ptr = 0x%"SZF"x\n", (size_t)iarray->ptr);
     printf("  step = 0x%"SZF"x\n", (size_t)iarray->step);
     for (int i = 0; i < ndim; ++i) {
@@ -72,27 +66,25 @@ print_na_iarray_t(na_iarray_t* iarray, unsigned char ndim)
 }
 
 static void
-print_na_reduction_arg_t(na_reduction_arg_t* arg)
+print_cumo_na_reduction_arg_t(cumo_na_reduction_arg_t* arg)
 {
-    printf("na_reduction_arg_t = 0x%"SZF"x {\n", (size_t)arg);
+    printf("cumo_na_reduction_arg_t = 0x%"SZF"x {\n", (size_t)arg);
     printf("--in--\n");
-    print_na_iarray_t(&arg->in, arg->in_indexer.ndim);
+    print_cumo_na_iarray_t(&arg->in, arg->in_indexer.ndim);
     printf("--out--\n");
-    print_na_iarray_t(&arg->out, arg->out_indexer.ndim);
+    print_cumo_na_iarray_t(&arg->out, arg->out_indexer.ndim);
     printf("--in_indexer--\n");
-    print_na_indexer_t(&arg->in_indexer);
+    print_cumo_na_indexer_t(&arg->in_indexer);
     printf("--out_indexer--\n");
-    print_na_indexer_t(&arg->out_indexer);
-    printf("--reduce_indexer--\n");
-    print_na_indexer_t(&arg->reduce_indexer);
+    print_cumo_na_indexer_t(&arg->out_indexer);
     printf("}\n");
 }
 
-// Note that you, then, have to call na_indexer_set to create index[]
-static na_indexer_t
-na_make_indexer(na_loop_args_t* arg)
+// Note that you, then, have to call cumo_na_indexer_set to create index[]
+static cumo_na_indexer_t
+cumo_na_make_indexer(cumo_na_loop_args_t* arg)
 {
-    na_indexer_t indexer;
+    cumo_na_indexer_t indexer;
     indexer.ndim = arg->ndim;
     indexer.total_size = 1;
     for (int i = 0; i < arg->ndim; ++i) {
@@ -102,10 +94,10 @@ na_make_indexer(na_loop_args_t* arg)
     return indexer;
 }
 
-static na_iarray_t
-na_make_iarray_given_ndim(na_loop_args_t* arg, int ndim)
+static cumo_na_iarray_t
+cumo_na_make_iarray_given_ndim(cumo_na_loop_args_t* arg, int ndim)
 {
-    na_iarray_t iarray;
+    cumo_na_iarray_t iarray;
     iarray.ptr = arg->ptr + arg->iter[0].pos;
     for (int idim = ndim; --idim >= 0;) {
         iarray.step[idim] = arg->iter[idim].step;
@@ -113,16 +105,16 @@ na_make_iarray_given_ndim(na_loop_args_t* arg, int ndim)
     return iarray;
 }
 
-static na_iarray_t
-na_make_iarray(na_loop_args_t* arg)
+static cumo_na_iarray_t
+cumo_na_make_iarray(cumo_na_loop_args_t* arg)
 {
-    return na_make_iarray_given_ndim(arg, arg->ndim);
+    return cumo_na_make_iarray_given_ndim(arg, arg->ndim);
 }
 
-static na_reduction_arg_t
-na_make_reduction_arg(na_loop_t* lp_user)
+static cumo_na_reduction_arg_t
+cumo_na_make_reduction_arg(cumo_na_loop_t* lp_user)
 {
-    na_reduction_arg_t arg;
+    cumo_na_reduction_arg_t arg;
     int i;
     int in_ndim = lp_user->args[0].ndim;
 
@@ -131,33 +123,24 @@ na_make_reduction_arg(na_loop_t* lp_user)
     // out shape = (2, 4, 6)
     // reduce shape = (3, 5)
 
-    arg.in = na_make_iarray(&lp_user->args[0]);
-    arg.in_indexer = na_make_indexer(&lp_user->args[0]);
+    arg.in = cumo_na_make_iarray(&lp_user->args[0]);
+    arg.in_indexer = cumo_na_make_indexer(&lp_user->args[0]);
 
-    arg.reduce_indexer.ndim = 0;
-    arg.reduce_indexer.total_size = 1;
     arg.out_indexer.ndim = 0;
     arg.out_indexer.total_size = 1;
     for (i = 0; i < in_ndim; ++i) {
-        if (na_test_reduce(lp_user->reduce, i)) {
-            arg.reduce_indexer.shape[arg.reduce_indexer.ndim] = arg.in_indexer.shape[i];
-            arg.reduce_indexer.total_size *= arg.in_indexer.shape[i];
-            ++arg.reduce_indexer.ndim;
-        } else {
+        if (!cumo_na_test_reduce(lp_user->reduce, i)) {
             arg.out_indexer.shape[arg.out_indexer.ndim] = arg.in_indexer.shape[i];
             arg.out_indexer.total_size *= arg.in_indexer.shape[i];
             ++arg.out_indexer.ndim;
         }
     }
-    arg.out = na_make_iarray_given_ndim(&lp_user->args[1], arg.out_indexer.ndim);
+    arg.out = cumo_na_make_iarray_given_ndim(&lp_user->args[1], arg.out_indexer.ndim);
 
-    if (na_debug_flag) {
-        print_na_reduction_arg_t(&arg);
+    if (cumo_na_debug_flag) {
+        print_cumo_na_reduction_arg_t(&arg);
     }
 
-    assert(arg.reduce_indexer.ndim == lp_user->reduce_dim);
-    assert(arg.in_indexer.ndim == arg.reduce_indexer.ndim + arg.out_indexer.ndim);
-
     return arg;
 }
 
@@ -169,7 +152,7 @@ na_make_reduction_arg(na_loop_t* lp_user)
 
 __host__ __device__
 static inline void
-cumo_na_indexer_set_dim(na_indexer_t* indexer, uint64_t i) {
+cumo_na_indexer_set_dim(cumo_na_indexer_t* indexer, uint64_t i) {
     indexer->raw_index = i;
     for (int j = indexer->ndim; --j >= 0;) {
         indexer->index[j] = i % indexer->shape[j];
@@ -181,7 +164,7 @@ cumo_na_indexer_set_dim(na_indexer_t* indexer, uint64_t i) {
 #define CUMO_NA_INDEXER_SET(NDIM) \
 __host__ __device__ \
 static inline void \
-cumo_na_indexer_set_dim##NDIM(na_indexer_t* indexer, uint64_t i) { \
+cumo_na_indexer_set_dim##NDIM(cumo_na_indexer_t* indexer, uint64_t i) { \
     indexer->raw_index = i; \
     for (int j = NDIM; --j >= 0;) { \
         indexer->index[j] = i % indexer->shape[j]; \
@@ -196,13 +179,13 @@ CUMO_NA_INDEXER_SET(0)
 
 __host__ __device__
 static inline void
-cumo_na_indexer_set_dim1(na_indexer_t* indexer, uint64_t i) {
+cumo_na_indexer_set_dim1(cumo_na_indexer_t* indexer, uint64_t i) {
     indexer->raw_index = i;
 }
 
 __host__ __device__
 static inline char*
-cumo_na_iarray_at_dim(na_iarray_t* iarray, na_indexer_t* indexer) {
+cumo_na_iarray_at_dim(cumo_na_iarray_t* iarray, cumo_na_indexer_t* indexer) {
     char* ptr = iarray->ptr;
     for (int idim = 0; idim < indexer->ndim; ++idim) {
         ptr += iarray->step[idim] * indexer->index[idim];
@@ -214,7 +197,7 @@ cumo_na_iarray_at_dim(na_iarray_t* iarray, na_indexer_t* indexer) {
 #define CUMO_NA_IARRAY_AT(NDIM) \
 __host__ __device__ \
 static inline char* \
-cumo_na_iarray_at_dim##NDIM(na_iarray_t* iarray, na_indexer_t* indexer) { \
+cumo_na_iarray_at_dim##NDIM(cumo_na_iarray_t* iarray, cumo_na_indexer_t* indexer) { \
     char* ptr = iarray->ptr; \
     for (int idim = 0; idim < NDIM; ++idim) { \
         ptr += iarray->step[idim] * indexer->index[idim]; \
@@ -229,7 +212,7 @@ CUMO_NA_IARRAY_AT(0)
 
 __host__ __device__
 static inline char*
-cumo_na_iarray_at_dim1(na_iarray_t* iarray, na_indexer_t* indexer) {
+cumo_na_iarray_at_dim1(cumo_na_iarray_t* iarray, cumo_na_indexer_t* indexer) {
     return iarray->ptr + iarray->step[0] * indexer->raw_index;
 }
 

data/ext/cumo/include/cumo/intern.h

@@ -3,132 +3,78 @@
 
 void cumo_debug_breakpoint(void);
 
-/* Add cumo_ prefix to avoid C symbol collisions with Numo without modifying C implementations */
-
-#define rb_narray_new cumo_nary_new
-#define nary_new cumo_nary_new
-VALUE cumo_nary_new(VALUE elem, int ndim, size_t *shape);
-#define rb_narray_view_new cumo_nary_view_new
-#define nary_view_new cumo_nary_view_new
-VALUE cumo_nary_view_new(VALUE elem, int ndim, size_t *shape);
-#define rb_narray_debug_info cumo_nary_debug_info
-#define nary_debug_info cumo_nary_debug_info
-VALUE cumo_nary_debug_info(VALUE);
-
-#define na_make_view cumo_nary_make_view
-VALUE cumo_nary_make_view(VALUE self);
-
-#define na_s_allocate cumo_nary_s_allocate
-VALUE cumo_nary_s_allocate(VALUE klass);
-#define na_s_allocate_view cumo_nary_s_allocate_view
-VALUE cumo_nary_s_allocate_view(VALUE klass);
-#define na_s_new_like cumo_nary_s_new_like
-VALUE cumo_nary_s_new_like(VALUE type, VALUE obj);
-
-#define na_alloc_shape cumo_na_alloc_shape
-void cumo_na_alloc_shape(narray_t *na, int ndim);
-#define na_array_to_internal_shape cumo_na_array_to_internal_shape
+VALUE cumo_na_new(VALUE elem, int ndim, size_t *shape);
+VALUE cumo_na_view_new(VALUE elem, int ndim, size_t *shape);
+VALUE cumo_na_debug_info(VALUE);
+
+VALUE cumo_na_make_view(VALUE self);
+
+VALUE cumo_na_s_allocate(VALUE klass);
+VALUE cumo_na_s_allocate_view(VALUE klass);
+VALUE cumo_na_s_new_like(VALUE type, VALUE obj);
+
+void cumo_na_alloc_shape(cumo_narray_t *na, int ndim);
 void cumo_na_array_to_internal_shape(VALUE self, VALUE ary, size_t *shape);
-#define na_index_arg_to_internal_order cumo_na_index_arg_to_internal_order
 void cumo_na_index_arg_to_internal_order(int argc, VALUE *argv, VALUE self);
-#define na_setup_shape cumo_na_setup_shape
-void cumo_na_setup_shape(narray_t *na, int ndim, size_t *shape);
-
-#define na_get_elmsz cumo_nary_element_stride
-#define nary_element_stride cumo_nary_element_stride
-//#define na_element_stride cumo_nary_element_stride
-unsigned int cumo_nary_element_stride(VALUE nary);
-#define na_dtype_elmsz cumo_nary_dtype_element_stride
-size_t cumo_nary_dtype_element_stride(VALUE klass);
-
-#define na_get_pointer cumo_nary_get_pointer
-char *cumo_nary_get_pointer(VALUE);
-#define na_get_pointer_for_write cumo_nary_get_pointer_for_write
-char *cumo_nary_get_pointer_for_write(VALUE);
-#define na_get_pointer_for_read cumo_nary_get_pointer_for_read
-char *cumo_nary_get_pointer_for_read(VALUE);
-#define na_get_pointer_for_read_write cumo_nary_get_pointer_for_read_write
-char *cumo_nary_get_pointer_for_read_write(VALUE);
-#define na_get_offset cumo_nary_get_offset
-size_t cumo_nary_get_offset(VALUE self);
-
-#define na_copy_flags cumo_nary_copy_flags
-void cumo_nary_copy_flags(VALUE src, VALUE dst);
-
-#define na_check_ladder cumo_nary_check_ladder
-VALUE cumo_nary_check_ladder(VALUE self, int start_dim);
-#define na_check_contiguous cumo_nary_check_contiguous
-VALUE cumo_nary_check_contiguous(VALUE self);
-
-#define na_flatten_dim cumo_nary_flatten_dim
-VALUE cumo_nary_flatten_dim(VALUE self, int sd);
-
-#define na_flatten cumo_nary_flatten
-VALUE cumo_nary_flatten(VALUE);
-
-#define na_copy cumo_nary_dup
-VALUE cumo_nary_dup(VALUE);
-
-#define na_store cumo_nary_store
-VALUE cumo_nary_store(VALUE self, VALUE src);
-
-#define na_upcast cumo_na_upcast
+void cumo_na_setup_shape(cumo_narray_t *na, int ndim, size_t *shape);
+
+unsigned int cumo_na_element_stride(VALUE nary);
+size_t cumo_na_dtype_element_stride(VALUE klass);
+
+char *cumo_na_get_pointer(VALUE);
+char *cumo_na_get_pointer_for_write(VALUE);
+char *cumo_na_get_pointer_for_read(VALUE);
+char *cumo_na_get_pointer_for_read_write(VALUE);
+size_t cumo_na_get_offset(VALUE self);
+
+void cumo_na_copy_flags(VALUE src, VALUE dst);
+
+VALUE cumo_na_check_ladder(VALUE self, int start_dim);
+VALUE cumo_na_check_contiguous(VALUE self);
+
+VALUE cumo_na_flatten_dim(VALUE self, int sd);
+
+VALUE cumo_na_flatten(VALUE);
+
+VALUE cumo_na_copy(VALUE);
+
+VALUE cumo_na_store(VALUE self, VALUE src);
+
 VALUE cumo_na_upcast(VALUE type1, VALUE type2);
 
-#define na_release_lock cumo_na_release_lock
 void cumo_na_release_lock(VALUE); // currently do nothing
 
 // used in reduce methods
-#define nary_reduce_dimension cumo_nary_reduce_dimension
-#define na_reduce_dimension cumo_nary_reduce_dimension
-VALUE cumo_nary_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
-                            ndfunc_t *ndf, na_iter_func_t nan_iter);
+VALUE cumo_na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
+                            cumo_ndfunc_t *ndf, cumo_na_iter_func_t nan_iter);
 
-#define nary_reduce_options cumo_nary_reduce_options
-#define na_reduce_options cumo_nary_reduce_options
-VALUE cumo_nary_reduce_options(VALUE axes, VALUE *opts, int naryc, VALUE *naryv,
-                          ndfunc_t *ndf);
+VALUE cumo_na_reduce_options(VALUE axes, VALUE *opts, int naryc, VALUE *naryv,
+                          cumo_ndfunc_t *ndf);
 
 // ndloop
-#define na_ndloop cumo_na_ndloop
-VALUE cumo_na_ndloop(ndfunc_t *nf, int argc, ...);
-#define na_ndloop2 cumo_na_ndloop2
-VALUE cumo_na_ndloop2(ndfunc_t *nf, VALUE args);
-#define na_ndloop3 cumo_na_ndloop3
-VALUE cumo_na_ndloop3(ndfunc_t *nf, void *ptr, int argc, ...);
-#define na_ndloop4 cumo_na_ndloop4
-VALUE cumo_na_ndloop4(ndfunc_t *nf, void *ptr, VALUE args);
-
-#define na_ndloop_cast_narray_to_rarray cumo_na_ndloop_cast_narray_to_rarray
-VALUE cumo_na_ndloop_cast_narray_to_rarray(ndfunc_t *nf, VALUE nary, VALUE fmt);
-#define na_ndloop_store_rarray cumo_na_ndloop_store_rarray
-VALUE cumo_na_ndloop_store_rarray(ndfunc_t *nf, VALUE nary, VALUE rary);
-#define na_ndloop_store_rarray2 cumo_na_ndloop_store_rarray2
-VALUE cumo_na_ndloop_store_rarray2(ndfunc_t *nf, VALUE nary, VALUE rary, VALUE opt);
-#define na_ndloop_inspect cumo_na_ndloop_inspect
-VALUE cumo_na_ndloop_inspect(VALUE nary, na_text_func_t func, VALUE opt);
-#define na_ndloop_with_index cumo_na_ndloop_with_index
-VALUE cumo_na_ndloop_with_index(ndfunc_t *nf, int argc, ...);
-
-#define na_info_str cumo_nary_info_str
-VALUE cumo_nary_info_str(VALUE);
-
-#define na_test_reduce cumo_nary_test_reduce
-bool cumo_nary_test_reduce(VALUE reduce, int dim);
-
-#define nary_step_array_index cumo_nary_step_array_index
-void cumo_nary_step_array_index(VALUE self, size_t ary_size, size_t *plen, ssize_t *pbeg, ssize_t *pstep);
-#define nary_step_sequence cumo_nary_step_sequence
-void cumo_nary_step_sequence(VALUE self, size_t *plen, double *pbeg, double *pstep);
+VALUE cumo_na_ndloop(cumo_ndfunc_t *nf, int argc, ...);
+VALUE cumo_na_ndloop2(cumo_ndfunc_t *nf, VALUE args);
+VALUE cumo_na_ndloop3(cumo_ndfunc_t *nf, void *ptr, int argc, ...);
+VALUE cumo_na_ndloop4(cumo_ndfunc_t *nf, void *ptr, VALUE args);
+
+VALUE cumo_na_ndloop_cast_narray_to_rarray(cumo_ndfunc_t *nf, VALUE nary, VALUE fmt);
+VALUE cumo_na_ndloop_store_rarray(cumo_ndfunc_t *nf, VALUE nary, VALUE rary);
+VALUE cumo_na_ndloop_store_rarray2(cumo_ndfunc_t *nf, VALUE nary, VALUE rary, VALUE opt);
+VALUE cumo_na_ndloop_inspect(VALUE nary, cumo_na_text_func_t func, VALUE opt);
+VALUE cumo_na_ndloop_with_index(cumo_ndfunc_t *nf, int argc, ...);
+
+VALUE cumo_na_info_str(VALUE);
+
+bool cumo_na_test_reduce(VALUE reduce, int dim);
+
+void cumo_na_step_array_index(VALUE self, size_t ary_size, size_t *plen, ssize_t *pbeg, ssize_t *pstep);
+void cumo_na_step_sequence(VALUE self, size_t *plen, double *pbeg, double *pstep);
 
 // used in aref, aset
-#define na_get_result_dimension cumo_nary_get_result_dimension
-int cumo_nary_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx);
-#define na_aref_main cumo_nary_aref_main
-VALUE cumo_nary_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result_nd, size_t pos);
+int cumo_na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx);
+VALUE cumo_na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int result_nd, size_t pos);
 
 // defined in array, used in math
-#define na_ary_composition_dtype cumo_na_ary_composition_dtype
 VALUE cumo_na_ary_composition_dtype(VALUE ary);
 
 #include "ruby/version.h"