numo-narray-alt 0.9.13 → 0.10.0

data/ext/numo/narray/src/t_uint8.c

@@ -43,12 +43,22 @@ static ID id_to_a;
 VALUE cT;
 extern VALUE cRT;
 
+#include "mh/store.h"
+#include "mh/s_cast.h"
+#include "mh/extract.h"
+#include "mh/aref.h"
+#include "mh/aset.h"
 #include "mh/coerce_cast.h"
 #include "mh/to_a.h"
 #include "mh/fill.h"
 #include "mh/format.h"
 #include "mh/format_to_a.h"
 #include "mh/inspect.h"
+#include "mh/each.h"
+#include "mh/map.h"
+#include "mh/each_with_index.h"
+#include "mh/map_with_index.h"
+#include "mh/abs.h"
 #include "mh/op/add.h"
 #include "mh/op/sub.h"
 #include "mh/op/mul.h"
@@ -92,6 +102,9 @@ extern VALUE cRT;
 #include "mh/seq.h"
 #include "mh/eye.h"
 #include "mh/rand.h"
+#include "mh/poly.h"
+#include "mh/sort.h"
+#include "mh/median.h"
 #include "mh/mean.h"
 #include "mh/var.h"
 #include "mh/stddev.h"
@@ -99,12 +112,23 @@ extern VALUE cRT;
 
 typedef u_int8_t uint8; // Type aliases for shorter notation
                         // following the codebase naming convention.
+DEF_NARRAY_STORE_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_S_CAST_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_EXTRACT_METHOD_FUNC(uint8)
+DEF_NARRAY_AREF_METHOD_FUNC(uint8)
+DEF_EXTRACT_DATA_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_ASET_METHOD_FUNC(uint8)
 DEF_NARRAY_COERCE_CAST_METHOD_FUNC(uint8)
 DEF_NARRAY_TO_A_METHOD_FUNC(uint8)
 DEF_NARRAY_FILL_METHOD_FUNC(uint8)
 DEF_NARRAY_FORMAT_METHOD_FUNC(uint8)
 DEF_NARRAY_FORMAT_TO_A_METHOD_FUNC(uint8)
 DEF_NARRAY_INSPECT_METHOD_FUNC(uint8)
+DEF_NARRAY_EACH_METHOD_FUNC(uint8)
+DEF_NARRAY_MAP_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_EACH_WITH_INDEX_METHOD_FUNC(uint8)
+DEF_NARRAY_MAP_WITH_INDEX_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_ABS_METHOD_FUNC(uint8, numo_cUInt8, uint8, numo_cUInt8)
 DEF_NARRAY_INT8_ADD_METHOD_FUNC(uint8, numo_cUInt8)
 DEF_NARRAY_INT8_SUB_METHOD_FUNC(uint8, numo_cUInt8)
 DEF_NARRAY_INT8_MUL_METHOD_FUNC(uint8, numo_cUInt8)
@@ -148,2025 +172,122 @@ DEF_NARRAY_INT_MULSUM_METHOD_FUNC(uint8, numo_cUInt8)
 DEF_NARRAY_INT_SEQ_METHOD_FUNC(uint8)
 DEF_NARRAY_EYE_METHOD_FUNC(uint8)
 DEF_NARRAY_INT_RAND_METHOD_FUNC(uint8)
-DEF_NARRAY_INT_MEAN_METHOD_FUNC(uint8, numo_cUInt8)
-DEF_NARRAY_INT_VAR_METHOD_FUNC(uint8, numo_cUInt8)
-DEF_NARRAY_INT_STDDEV_METHOD_FUNC(uint8, numo_cUInt8)
-DEF_NARRAY_INT_RMS_METHOD_FUNC(uint8, numo_cUInt8)
-
-static VALUE uint8_store(VALUE, VALUE);
-
-static size_t uint8_memsize(const void* ptr) {
-  size_t size = sizeof(narray_data_t);
-  const narray_data_t* na = (const narray_data_t*)ptr;
-
-  assert(na->base.type == NARRAY_DATA_T);
-
-  if (na->ptr != NULL) {
-
-    size += na->base.size * sizeof(dtype);
-  }
-  if (na->base.size > 0) {
-    if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
-      size += sizeof(size_t) * na->base.ndim;
-    }
-  }
-  return size;
-}
-
-static void uint8_free(void* ptr) {
-  narray_data_t* na = (narray_data_t*)ptr;
-
-  assert(na->base.type == NARRAY_DATA_T);
-
-  if (na->ptr != NULL) {
-    if (na->owned) {
-      xfree(na->ptr);
-    }
-    na->ptr = NULL;
-  }
-  if (na->base.size > 0) {
-    if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
-      xfree(na->base.shape);
-      na->base.shape = NULL;
-    }
-  }
-  xfree(na);
-}
-
-static narray_type_info_t uint8_info = {
-
-  0,             // element_bits
-  sizeof(dtype), // element_bytes
-  sizeof(dtype), // element_stride (in bytes)
-
-};
-
-static const rb_data_type_t uint8_data_type = {
-  "Numo::UInt8",
-  {
-    0,
-    uint8_free,
-    uint8_memsize,
-  },
-  &na_data_type,
-  &uint8_info,
-  RUBY_TYPED_FROZEN_SHAREABLE, // flags
-};
-
-static VALUE uint8_s_alloc_func(VALUE klass) {
-  narray_data_t* na = ALLOC(narray_data_t);
-
-  na->base.ndim = 0;
-  na->base.type = NARRAY_DATA_T;
-  na->base.flag[0] = NA_FL0_INIT;
-  na->base.flag[1] = NA_FL1_INIT;
-  na->base.size = 0;
-  na->base.shape = NULL;
-  na->base.reduce = INT2FIX(0);
-  na->ptr = NULL;
-  na->owned = FALSE;
-  return TypedData_Wrap_Struct(klass, &uint8_data_type, (void*)na);
-}
-
-static VALUE uint8_allocate(VALUE self) {
-  narray_t* na;
-  char* ptr;
-
-  GetNArray(self, na);
-
-  switch (NA_TYPE(na)) {
-  case NARRAY_DATA_T:
-    ptr = NA_DATA_PTR(na);
-    if (na->size > 0 && ptr == NULL) {
-      ptr = xmalloc(sizeof(dtype) * na->size);
-
-      NA_DATA_PTR(na) = ptr;
-      NA_DATA_OWNED(na) = TRUE;
-    }
-    break;
-  case NARRAY_VIEW_T:
-    rb_funcall(NA_VIEW_DATA(na), rb_intern("allocate"), 0);
-    break;
-  case NARRAY_FILEMAP_T:
-    // ptr = ((narray_filemap_t*)na)->ptr;
-    //  to be implemented
-  default:
-    rb_bug("invalid narray type : %d", NA_TYPE(na));
-  }
-  return self;
-}
-
-/*
-  Extract an element only if self is a dimensionless NArray.
-  @overload extract
-    @return [Numeric,Numo::NArray]
-    --- Extract element value as Ruby Object if self is a dimensionless NArray,
-    otherwise returns self.
-*/
-static VALUE uint8_extract(VALUE self) {
-  volatile VALUE v;
-  char* ptr;
-  narray_t* na;
-  GetNArray(self, na);
-
-  if (na->ndim == 0) {
-    ptr = na_get_pointer_for_read(self) + na_get_offset(self);
-    v = m_extract(ptr);
-    na_release_lock(self);
-    return v;
-  }
-  return self;
-}
-
-static VALUE uint8_new_dim0(dtype x) {
-  VALUE v;
-  dtype* ptr;
-
-  v = nary_new(cT, 0, NULL);
-  ptr = (dtype*)(char*)na_get_pointer_for_write(v);
-  *ptr = x;
-  na_release_lock(v);
-  return v;
-}
-
-static VALUE uint8_store_numeric(VALUE self, VALUE obj) {
-  dtype x;
-  x = m_num_to_data(obj);
-  obj = uint8_new_dim0(x);
-  uint8_store(self, obj);
-  return self;
-}
-
-static void iter_uint8_store_bit(na_loop_t* const lp) {
-  size_t i;
-  char* p1;
-  size_t p2;
-  ssize_t s1, s2;
-  size_t *idx1, *idx2;
-  BIT_DIGIT *a2, x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_BIT_IDX(lp, 1, a2, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        LOAD_BIT(a2, p2 + *idx2, x);
-        idx2++;
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        LOAD_BIT(a2, p2 + *idx2, x);
-        idx2++;
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        LOAD_BIT(a2, p2, x);
-        p2 += s2;
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        LOAD_BIT(a2, p2, x);
-        p2 += s2;
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_bit(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_bit, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_dfloat(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  double x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, double, x);
-        y = m_from_real(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, double, x);
-        y = m_from_real(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, double, x);
-        y = m_from_real(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, double, x);
-        y = m_from_real(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_dfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_dfloat, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_sfloat(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  float x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, float, x);
-        y = m_from_real(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, float, x);
-        y = m_from_real(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, float, x);
-        y = m_from_real(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, float, x);
-        y = m_from_real(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_sfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_sfloat, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_int64(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  int64_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int64_t, x);
-        y = m_from_int64(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int64_t, x);
-        y = m_from_int64(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int64_t, x);
-        y = m_from_int64(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int64_t, x);
-        y = m_from_int64(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_int64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_int64, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_int32(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  int32_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int32_t, x);
-        y = m_from_int32(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int32_t, x);
-        y = m_from_int32(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int32_t, x);
-        y = m_from_int32(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int32_t, x);
-        y = m_from_int32(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_int32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_int32, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_int16(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  int16_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_int16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_int16, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_int8(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  int8_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_int8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_int8, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_uint64(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  u_int64_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int64_t, x);
-        y = m_from_uint64(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int64_t, x);
-        y = m_from_uint64(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int64_t, x);
-        y = m_from_uint64(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int64_t, x);
-        y = m_from_uint64(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_uint64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_uint64, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_uint32(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  u_int32_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int32_t, x);
-        y = m_from_uint32(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int32_t, x);
-        y = m_from_uint32(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int32_t, x);
-        y = m_from_uint32(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int32_t, x);
-        y = m_from_uint32(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_uint32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_uint32, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_uint16(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  u_int16_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int16_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_uint16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_uint16, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_uint8(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  u_int8_t x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, u_int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, u_int8_t, x);
-        y = m_from_sint(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_uint8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_uint8, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_robject(na_loop_t* const lp) {
-  size_t i, s1, s2;
-  char *p1, *p2;
-  size_t *idx1, *idx2;
-  VALUE x;
-  dtype y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx2) {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, VALUE, x);
-        y = m_num_to_data(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p2, idx2, VALUE, x);
-        y = m_num_to_data(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  } else {
-    if (idx1) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, VALUE, x);
-        y = m_num_to_data(x);
-        SET_DATA_INDEX(p1, idx1, dtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p2, s2, VALUE, x);
-        y = m_num_to_data(x);
-        SET_DATA_STRIDE(p1, s1, dtype, y);
-      }
-    }
-  }
-}
-
-static VALUE uint8_store_robject(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_robject, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_uint8_store_array(na_loop_t* const lp) {
-  size_t i, n;
-  size_t i1, n1;
-  VALUE v1, *ptr;
-  char* p1;
-  size_t s1, *idx1;
-  VALUE x;
-  double y;
-  dtype z;
-  size_t len, c;
-  double beg, step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  v1 = lp->args[1].value;
-  i = 0;
-
-  if (lp->args[1].ptr) {
-    if (v1 == Qtrue) {
-      iter_uint8_store_uint8(lp);
-      i = lp->args[1].shape[0];
-      if (idx1) {
-        idx1 += i;
-      } else {
-        p1 += s1 * i;
-      }
-    }
-    goto loop_end;
-  }
-
-  ptr = &v1;
-
-  switch (TYPE(v1)) {
-  case T_ARRAY:
-    n1 = RARRAY_LEN(v1);
-    ptr = RARRAY_PTR(v1);
-    break;
-  case T_NIL:
-    n1 = 0;
-    break;
-  default:
-    n1 = 1;
-  }
-
-  if (idx1) {
-    for (i = i1 = 0; i1 < n1 && i < n; i++, i1++) {
-      x = ptr[i1];
-      if (rb_obj_is_kind_of(x, rb_cRange)
-#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
-          || rb_obj_is_kind_of(x, rb_cArithSeq)
-#else
-          || rb_obj_is_kind_of(x, rb_cEnumerator)
-#endif
-      ) {
-        nary_step_sequence(x, &len, &beg, &step);
-        for (c = 0; c < len && i < n; c++, i++) {
-          y = beg + step * c;
-          z = m_from_double(y);
-          SET_DATA_INDEX(p1, idx1, dtype, z);
-        }
-      } else if (TYPE(x) != T_ARRAY) {
-        z = m_num_to_data(x);
-        SET_DATA_INDEX(p1, idx1, dtype, z);
-      }
-    }
-  } else {
-    for (i = i1 = 0; i1 < n1 && i < n; i++, i1++) {
-      x = ptr[i1];
-      if (rb_obj_is_kind_of(x, rb_cRange)
-#ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
-          || rb_obj_is_kind_of(x, rb_cArithSeq)
-#else
-          || rb_obj_is_kind_of(x, rb_cEnumerator)
-#endif
-      ) {
-        nary_step_sequence(x, &len, &beg, &step);
-        for (c = 0; c < len && i < n; c++, i++) {
-          y = beg + step * c;
-          z = m_from_double(y);
-          SET_DATA_STRIDE(p1, s1, dtype, z);
-        }
-      } else if (TYPE(x) != T_ARRAY) {
-        z = m_num_to_data(x);
-        SET_DATA_STRIDE(p1, s1, dtype, z);
-      }
-    }
-  }
-
-loop_end:
-  z = m_zero;
-  if (idx1) {
-    for (; i < n; i++) {
-      SET_DATA_INDEX(p1, idx1, dtype, z);
-    }
-  } else {
-    for (; i < n; i++) {
-      SET_DATA_STRIDE(p1, s1, dtype, z);
-    }
-  }
-}
-
-static VALUE uint8_store_array(VALUE self, VALUE rary) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { rb_cArray, 0 } };
-  ndfunc_t ndf = { iter_uint8_store_array, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop_store_rarray(&ndf, self, rary);
-  return self;
-}
-
-/*
-  Store elements to Numo::UInt8 from other.
-  @overload store(other)
-    @param [Object] other
-    @return [Numo::UInt8] self
-*/
-static VALUE uint8_store(VALUE self, VALUE obj) {
-  VALUE r, klass;
-
-  klass = rb_obj_class(obj);
-
-  if (klass == numo_cUInt8) {
-    uint8_store_uint8(self, obj);
-    return self;
-  }
-
-  if (IS_INTEGER_CLASS(klass) || klass == rb_cFloat || klass == rb_cComplex) {
-    uint8_store_numeric(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cBit) {
-    uint8_store_bit(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cDFloat) {
-    uint8_store_dfloat(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cSFloat) {
-    uint8_store_sfloat(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt64) {
-    uint8_store_int64(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt32) {
-    uint8_store_int32(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt16) {
-    uint8_store_int16(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt8) {
-    uint8_store_int8(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cUInt64) {
-    uint8_store_uint64(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cUInt32) {
-    uint8_store_uint32(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cUInt16) {
-    uint8_store_uint16(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cRObject) {
-    uint8_store_robject(self, obj);
-    return self;
-  }
-
-  if (klass == rb_cArray) {
-    uint8_store_array(self, obj);
-    return self;
-  }
-
-  if (IsNArray(obj)) {
-    r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
-    if (rb_obj_class(r) == cT) {
-      uint8_store(self, r);
-      return self;
-    }
-  }
-
-  rb_raise(
-    nary_eCastError, "unknown conversion from %s to %s", rb_class2name(rb_obj_class(obj)),
-    rb_class2name(rb_obj_class(self))
-  );
-
-  return self;
-}
-
-/*
-  Convert a data value of obj (with a single element) to dtype.
-*/
-static dtype uint8_extract_data(VALUE obj) {
-  narray_t* na;
-  dtype x;
-  char* ptr;
-  size_t pos;
-  VALUE r, klass;
-
-  if (IsNArray(obj)) {
-    GetNArray(obj, na);
-    if (na->size != 1) {
-      rb_raise(nary_eShapeError, "narray size should be 1");
-    }
-    klass = rb_obj_class(obj);
-    ptr = na_get_pointer_for_read(obj);
-    pos = na_get_offset(obj);
-
-    if (klass == numo_cUInt8) {
-      x = m_from_sint(*(u_int8_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cBit) {
-      {
-        BIT_DIGIT b;
-        LOAD_BIT(ptr, pos, b);
-        x = m_from_sint(b);
-      };
-      return x;
-    }
-
-    if (klass == numo_cDFloat) {
-      x = m_from_real(*(double*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cSFloat) {
-      x = m_from_real(*(float*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cInt64) {
-      x = m_from_int64(*(int64_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cInt32) {
-      x = m_from_int32(*(int32_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cInt16) {
-      x = m_from_sint(*(int16_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cInt8) {
-      x = m_from_sint(*(int8_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cUInt64) {
-      x = m_from_uint64(*(u_int64_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cUInt32) {
-      x = m_from_uint32(*(u_int32_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cUInt16) {
-      x = m_from_sint(*(u_int16_t*)(ptr + pos));
-      return x;
-    }
-
-    if (klass == numo_cRObject) {
-      x = m_num_to_data(*(VALUE*)(ptr + pos));
-      return x;
-    }
-
-    // coerce
-    r = rb_funcall(obj, rb_intern("coerce_cast"), 1, cT);
-    if (rb_obj_class(r) == cT) {
-      return uint8_extract_data(r);
-    }
-
-    rb_raise(
-      nary_eCastError, "unknown conversion from %s to %s", rb_class2name(rb_obj_class(obj)),
-      rb_class2name(cT)
-    );
-  }
-  if (TYPE(obj) == T_ARRAY) {
-    if (RARRAY_LEN(obj) != 1) {
-      rb_raise(nary_eShapeError, "array size should be 1");
-    }
-    return m_num_to_data(RARRAY_AREF(obj, 0));
-  }
-  return m_num_to_data(obj);
-}
-
-static VALUE uint8_cast_array(VALUE rary) {
-  VALUE nary;
-  narray_t* na;
-
-  nary = na_s_new_like(cT, rary);
-  GetNArray(nary, na);
-  if (na->size > 0) {
-    uint8_store_array(nary, rary);
-  }
-  return nary;
-}
-
-/*
-  Cast object to Numo::UInt8.
-  @overload [](elements)
-  @overload cast(array)
-    @param [Numeric,Array] elements
-    @param [Array] array
-    @return [Numo::UInt8]
-*/
-static VALUE uint8_s_cast(VALUE type, VALUE obj) {
-  VALUE v;
-  narray_t* na;
-  dtype x;
-
-  if (rb_obj_class(obj) == cT) {
-    return obj;
-  }
-  if (RTEST(rb_obj_is_kind_of(obj, rb_cNumeric))) {
-    x = m_num_to_data(obj);
-    return uint8_new_dim0(x);
-  }
-  if (RTEST(rb_obj_is_kind_of(obj, rb_cArray))) {
-    return uint8_cast_array(obj);
-  }
-  if (IsNArray(obj)) {
-    GetNArray(obj, na);
-    v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
-    if (NA_SIZE(na) > 0) {
-      uint8_store(v, obj);
-    }
-    return v;
-  }
-  if (rb_respond_to(obj, id_to_a)) {
-    obj = rb_funcall(obj, id_to_a, 0);
-    if (TYPE(obj) != T_ARRAY) {
-      rb_raise(rb_eTypeError, "`to_a' did not return Array");
-    }
-    return uint8_cast_array(obj);
-  }
-
-  rb_raise(nary_eCastError, "cannot cast to %s", rb_class2name(type));
-  return Qnil;
-}
-
-/*
-  Multi-dimensional element reference.
-  @overload [](dim0,...,dimL)
-    @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,Symbol]
-    dim0,...,dimL  multi-dimensional indices.
-    @return [Numeric,Numo::UInt8] an element or NArray view.
-  @see Numo::NArray#[]
-  @see #[]=
- */
-static VALUE uint8_aref(int argc, VALUE* argv, VALUE self) {
-  int nd;
-  size_t pos;
-  char* ptr;
-
-  nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
-  if (nd) {
-    return na_aref_main(argc, argv, self, 0, nd);
-  } else {
-    ptr = na_get_pointer_for_read(self) + pos;
-    return m_extract(ptr);
-  }
-}
-
-/*
-  Multi-dimensional element assignment.
-  @overload []=(dim0,...,dimL,val)
-    @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,Symbol]
-    dim0,...,dimL  multi-dimensional indices.
-    @param [Numeric,Numo::NArray,Array] val  Value(s) to be set to self.
-    @return [Numeric,Numo::NArray,Array] returns `val` (last argument).
-  @see Numo::NArray#[]=
-  @see #[]
-*/
-static VALUE uint8_aset(int argc, VALUE* argv, VALUE self) {
-  int nd;
-  size_t pos;
-  char* ptr;
-  VALUE a;
-  dtype x;
-
-  argc--;
-  if (argc == 0) {
-    uint8_store(self, argv[argc]);
-  } else {
-    nd = na_get_result_dimension(self, argc, argv, sizeof(dtype), &pos);
-    if (nd) {
-      a = na_aref_main(argc, argv, self, 0, nd);
-      uint8_store(a, argv[argc]);
-    } else {
-      x = uint8_extract_data(argv[argc]);
-      ptr = na_get_pointer_for_read_write(self) + pos;
-      *(dtype*)ptr = x;
-    }
-  }
-  return argv[argc];
-}
-
-static void iter_uint8_each(na_loop_t* const lp) {
-  size_t i, s1;
-  char* p1;
-  size_t* idx1;
-  dtype x;
-  VALUE y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  if (idx1) {
-    for (; i--;) {
-      GET_DATA_INDEX(p1, idx1, dtype, x);
-      y = m_data_to_num(x);
-      rb_yield(y);
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      y = m_data_to_num(x);
-      rb_yield(y);
-    }
-  }
-}
-
-/*
-  Calls the given block once for each element in self,
-  passing that element as a parameter.
-  @overload each
-    @return [Numo::NArray] self
-    For a block `{|x| ... }`,
-    @yieldparam [Numeric] x  an element of NArray.
-  @see #each_with_index
-  @see #map
-*/
-static VALUE uint8_each(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_each, FULL_LOOP_NIP, 1, 0, ain, 0 };
-
-  na_ndloop(&ndf, 1, self);
-  return self;
-}
-
-static void iter_uint8_map(na_loop_t* const lp) {
-  size_t i, n;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  size_t *idx1, *idx2;
-  dtype x;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-
-  if (idx1) {
-    if (idx2) {
-      for (i = 0; i < n; i++) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = m_map(x);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-      }
-    } else {
-      for (i = 0; i < n; i++) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = m_map(x);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-      }
-    }
-  } else {
-    if (idx2) {
-      for (i = 0; i < n; i++) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = m_map(x);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-      }
-    } else {
-      //
-      for (i = 0; i < n; i++) {
-        *(dtype*)p2 = m_map(*(dtype*)p1);
-        p1 += s1;
-        p2 += s2;
-      }
-      return;
-      //
-    }
-  }
-}
-
-/*
-  Unary map.
-  @overload map
-    @return [Numo::UInt8] map of self.
-*/
-static VALUE uint8_map(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_uint8_map, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static inline void yield_each_with_index(dtype x, size_t* c, VALUE* a, int nd, int md) {
-  int j;
-
-  a[0] = m_data_to_num(x);
-  for (j = 0; j <= nd; j++) {
-    a[j + 1] = SIZET2NUM(c[j]);
-  }
-  rb_yield(rb_ary_new4(md, a));
-}
-
-static void iter_uint8_each_with_index(na_loop_t* const lp) {
-  size_t i, s1;
-  char* p1;
-  size_t* idx1;
-  dtype x;
-  VALUE* a;
-  size_t* c;
-  int nd, md;
-
-  c = (size_t*)(lp->opt_ptr);
-  nd = lp->ndim;
-  if (nd > 0) {
-    nd--;
-  }
-  md = nd + 2;
-  a = ALLOCA_N(VALUE, md);
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  c[nd] = 0;
-  if (idx1) {
-    for (; i--;) {
-      GET_DATA_INDEX(p1, idx1, dtype, x);
-      yield_each_with_index(x, c, a, nd, md);
-      c[nd]++;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      yield_each_with_index(x, c, a, nd, md);
-      c[nd]++;
-    }
-  }
-}
-
-/*
-  Invokes the given block once for each element of self,
-  passing that element and indices along each axis as parameters.
-  @overload each_with_index
-    For a block `{|x,i,j,...| ... }`,
-    @yieldparam [Numeric] x  an element
-    @yieldparam [Integer] i,j,...  multitimensional indices
-    @return [Numo::NArray] self
-  @see #each
-  @see #map_with_index
-*/
-static VALUE uint8_each_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_uint8_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0 };
-
-  na_ndloop_with_index(&ndf, 1, self);
-  return self;
-}
-
-static inline dtype yield_map_with_index(dtype x, size_t* c, VALUE* a, int nd, int md) {
-  int j;
-  VALUE y;
-
-  a[0] = m_data_to_num(x);
-  for (j = 0; j <= nd; j++) {
-    a[j + 1] = SIZET2NUM(c[j]);
-  }
-  y = rb_yield(rb_ary_new4(md, a));
-  return m_num_to_data(y);
-}
-
-static void iter_uint8_map_with_index(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  size_t *idx1, *idx2;
-  dtype x;
-  VALUE* a;
-  size_t* c;
-  int nd, md;
-
-  c = (size_t*)(lp->opt_ptr);
-  nd = lp->ndim;
-  if (nd > 0) {
-    nd--;
-  }
-  md = nd + 2;
-  a = ALLOCA_N(VALUE, md);
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-
-  c[nd] = 0;
-  if (idx1) {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-        c[nd]++;
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-        c[nd]++;
-      }
-    }
-  } else {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_INDEX(p2, idx2, dtype, x);
-        c[nd]++;
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = yield_map_with_index(x, c, a, nd, md);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-        c[nd]++;
-      }
-    }
-  }
-}
-
-/*
-  Invokes the given block once for each element of self,
-  passing that element and indices along each axis as parameters.
-  Creates a new NArray containing the values returned by the block.
-  Inplace option is allowed, i.e., `nary.inplace.map` overwrites `nary`.
-  @overload map_with_index
-    For a block `{|x,i,j,...| ... }`,
-    @yieldparam [Numeric] x  an element
-    @yieldparam [Integer] i,j,...  multitimensional indices
-    @return [Numo::NArray] mapped array
-  @see #map
-  @see #each_with_index
-*/
-static VALUE uint8_map_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_uint8_map_with_index, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop_with_index(&ndf, 1, self);
-}
-
-static void iter_uint8_abs(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  size_t *idx1, *idx2;
-  dtype x;
-  rtype y;
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_IDX(lp, 1, p2, s2, idx2);
-  if (idx1) {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_INDEX(p2, idx2, rtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_INDEX(p1, idx1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_STRIDE(p2, s2, rtype, y);
-      }
-    }
-  } else {
-    if (idx2) {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_INDEX(p2, idx2, rtype, y);
-      }
-    } else {
-      for (; i--;) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        y = m_abs(x);
-        SET_DATA_STRIDE(p2, s2, rtype, y);
-      }
-    }
-  }
-}
-
-/*
-  abs of self.
-  @overload abs
-    @return [Numo::UInt8] abs of self.
-*/
-static VALUE uint8_abs(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cRT, 0 } };
-  ndfunc_t ndf = { iter_uint8_abs, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_uint8_poly(na_loop_t* const lp) {
-  size_t i;
-  dtype x, y, a;
-
-  x = *(dtype*)(lp->args[0].ptr + lp->args[0].iter[0].pos);
-  i = lp->narg - 2;
-  y = *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos);
-  for (; --i;) {
-    y = m_mul(x, y);
-    a = *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos);
-    y = m_add(y, a);
-  }
-  i = lp->narg - 1;
-  *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos) = y;
-}
-
-/*
-  Calculate polynomial.
-    `x.poly(a0,a1,a2,...,an) = a0 + a1*x + a2*x**2 + ... + an*x**n`
-  @overload poly a0, a1, ..., an
-    @param [Numo::NArray,Numeric] a0,a1,...,an
-    @return [Numo::UInt8]
-*/
-static VALUE uint8_poly(VALUE self, VALUE args) {
-  int argc, i;
-  VALUE* argv;
-  volatile VALUE v, a;
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_uint8_poly, NO_LOOP, 0, 1, 0, aout };
-
-  argc = (int)RARRAY_LEN(args);
-  ndf.nin = argc + 1;
-  ndf.ain = ALLOCA_N(ndfunc_arg_in_t, argc + 1);
-  for (i = 0; i < argc + 1; i++) {
-    ndf.ain[i].type = cT;
-  }
-  argv = ALLOCA_N(VALUE, argc + 1);
-  argv[0] = self;
-  for (i = 0; i < argc; i++) {
-    argv[i + 1] = RARRAY_PTR(args)[i];
-  }
-  a = rb_ary_new4(argc + 1, argv);
-  v = na_ndloop2(&ndf, a);
-  return uint8_extract(v);
-}
-
-/*
-  qsort.c
-  Ruby/Numo::NArray - Numerical Array class for Ruby
-    modified by Masahiro TANAKA
-*/
-
-/*
- *      qsort.c: standard quicksort algorithm
- *
- *      Modifications from vanilla NetBSD source:
- *        Add do ... while() macro fix
- *        Remove __inline, _DIAGASSERTs, __P
- *        Remove ill-considered "swap_cnt" switch to insertion sort,
- *        in favor of a simple check for presorted input.
- *
- *      CAUTION: if you change this file, see also qsort_arg.c
- *
- *      $PostgreSQL: pgsql/src/port/qsort.c,v 1.12 2006/10/19 20:56:22 tgl Exp $
- */
-
-/*      $NetBSD: qsort.c,v 1.13 2003/08/07 16:43:42 agc Exp $   */
-
-/*-
- * Copyright (c) 1992, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *        notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *        notice, this list of conditions and the following disclaimer in the
- *        documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *        may be used to endorse or promote products derived from this software
- *        without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.      IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#ifndef QSORT_INCL
-#define QSORT_INCL
-#define Min(x, y) ((x) < (y) ? (x) : (y))
-
-/*
- * Qsort routine based on J. L. Bentley and M. D. McIlroy,
- * "Engineering a sort function",
- * Software--Practice and Experience 23 (1993) 1249-1265.
- * We have modified their original by adding a check for already-sorted input,
- * which seems to be a win per discussions on pgsql-hackers around 2006-03-21.
- */
-#define swapcode(TYPE, parmi, parmj, n)                                                        \
-  do {                                                                                         \
-    size_t i = (n) / sizeof(TYPE);                                                             \
-    TYPE* pi = (TYPE*)(void*)(parmi);                                                          \
-    TYPE* pj = (TYPE*)(void*)(parmj);                                                          \
-    do {                                                                                       \
-      TYPE t = *pi;                                                                            \
-      *pi++ = *pj;                                                                             \
-      *pj++ = t;                                                                               \
-    } while (--i > 0);                                                                         \
-  } while (0)
-
-#ifdef HAVE_STDINT_H
-#define SWAPINIT(a, es)                                                                        \
-  swaptype = (uintptr_t)(a) % sizeof(long) || (es) % sizeof(long) ? 2                          \
-             : (es) == sizeof(long)                               ? 0                          \
-                                                                  : 1;
-#else
-#define SWAPINIT(a, es)                                                                        \
-  swaptype = ((char*)(a) - (char*)0) % sizeof(long) || (es) % sizeof(long) ? 2                 \
-             : (es) == sizeof(long)                                        ? 0                 \
-                                                                           : 1;
-#endif
-
-static inline void swapfunc(char* a, char* b, size_t n, int swaptype) {
-  if (swaptype <= 1)
-    swapcode(long, a, b, n);
-  else
-    swapcode(char, a, b, n);
-}
-
-#define swap(a, b)                                                                             \
-  if (swaptype == 0) {                                                                         \
-    long t = *(long*)(void*)(a);                                                               \
-    *(long*)(void*)(a) = *(long*)(void*)(b);                                                   \
-    *(long*)(void*)(b) = t;                                                                    \
-  } else                                                                                       \
-    swapfunc(a, b, es, swaptype)
-
-#define vecswap(a, b, n)                                                                       \
-  if ((n) > 0) swapfunc((a), (b), (size_t)(n), swaptype)
-
-#define med3(a, b, c, _cmp)                                                                    \
-  (cmpgt(b, a) ? (cmpgt(c, b) ? b : (cmpgt(c, a) ? c : a))                                     \
-               : (cmpgt(b, c) ? b : (cmpgt(c, a) ? a : c)))
-#endif
-
+DEF_NARRAY_POLY_METHOD_FUNC(uint8, numo_cUInt8)
 #undef qsort_dtype
-#define qsort_dtype dtype
+#define qsort_dtype uint8
 #undef qsort_cast
-#define qsort_cast *(dtype*)
-
-static void uint8_qsort(void* a, size_t n, ssize_t es) {
-  char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
-  int d, r, swaptype, presorted;
-
-loop:
-  SWAPINIT(a, es);
-  if (n < 7) {
-    for (pm = (char*)a + es; pm < (char*)a + n * es; pm += es)
-      for (pl = pm; pl > (char*)a && cmpgt(pl - es, pl); pl -= es) swap(pl, pl - es);
-    return;
-  }
-  presorted = 1;
-  for (pm = (char*)a + es; pm < (char*)a + n * es; pm += es) {
-    if (cmpgt(pm - es, pm)) {
-      presorted = 0;
-      break;
-    }
-  }
-  if (presorted) return;
-  pm = (char*)a + (n / 2) * es;
-  if (n > 7) {
-    pl = (char*)a;
-    pn = (char*)a + (n - 1) * es;
-    if (n > 40) {
-      d = (int)((n / 8) * es);
-      pl = med3(pl, pl + d, pl + 2 * d, cmp);
-      pm = med3(pm - d, pm, pm + d, cmp);
-      pn = med3(pn - 2 * d, pn - d, pn, cmp);
-    }
-    pm = med3(pl, pm, pn, cmp);
-  }
-  swap(a, pm);
-  pa = pb = (char*)a + es;
-  pc = pd = (char*)a + (n - 1) * es;
-  for (;;) {
-    while (pb <= pc && (r = cmp(pb, a)) <= 0) {
-      if (r == 0) {
-        swap(pa, pb);
-        pa += es;
-      }
-      pb += es;
-    }
-    while (pb <= pc && (r = cmp(pc, a)) >= 0) {
-      if (r == 0) {
-        swap(pc, pd);
-        pd -= es;
-      }
-      pc -= es;
-    }
-    if (pb > pc) break;
-    swap(pb, pc);
-    pb += es;
-    pc -= es;
-  }
-  pn = (char*)a + n * es;
-  r = (int)(Min(pa - (char*)a, pb - pa));
-  vecswap(a, pb - r, r);
-  r = (int)(Min(pd - pc, pn - pd - es));
-  vecswap(pb, pn - r, r);
-  if ((r = (int)(pb - pa)) > es) uint8_qsort(a, r / es, es);
-  if ((r = (int)(pd - pc)) > es) {
-    /* Iterate rather than recurse to save stack space */
-    a = pn - r;
-    n = r / es;
-    goto loop;
-  }
-  /*              qsort(pn - r, r / es, es, cmp);*/
-}
-
-static void iter_uint8_sort(na_loop_t* const lp) {
-  size_t n;
-  char* ptr;
-  ssize_t step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, ptr, step);
-  uint8_qsort(ptr, n, step);
-}
-
-/*
-  sort of self.
-  @overload sort(axis:nil)
-    @param [Numeric,Array,Range] axis  Performs sort along the axis.
-    @return [Numo::UInt8] returns result of sort.
-  @example
-      Numo::DFloat[3,4,1,2].sort #=> Numo::DFloat[1,2,3,4]
-*/
-static VALUE uint8_sort(int argc, VALUE* argv, VALUE self) {
-  VALUE reduce;
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_reduce, 0 } };
-  ndfunc_t ndf = { 0, NDF_HAS_LOOP | NDF_FLAT_REDUCE, 2, 0, ain, 0 };
-
-  if (!TEST_INPLACE(self)) {
-    self = na_copy(self);
-  }
-
-  ndf.func = iter_uint8_sort;
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
-
-  na_ndloop(&ndf, 2, self, reduce);
-  return self;
-}
-
-/*
-  qsort.c
-  Ruby/Numo::NArray - Numerical Array class for Ruby
-    modified by Masahiro TANAKA
-*/
-
-/*
- *      qsort.c: standard quicksort algorithm
- *
- *      Modifications from vanilla NetBSD source:
- *        Add do ... while() macro fix
- *        Remove __inline, _DIAGASSERTs, __P
- *        Remove ill-considered "swap_cnt" switch to insertion sort,
- *        in favor of a simple check for presorted input.
- *
- *      CAUTION: if you change this file, see also qsort_arg.c
- *
- *      $PostgreSQL: pgsql/src/port/qsort.c,v 1.12 2006/10/19 20:56:22 tgl Exp $
- */
-
-/*      $NetBSD: qsort.c,v 1.13 2003/08/07 16:43:42 agc Exp $   */
-
-/*-
- * Copyright (c) 1992, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *        notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *        notice, this list of conditions and the following disclaimer in the
- *        documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *        may be used to endorse or promote products derived from this software
- *        without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.      IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
+#define qsort_cast *(uint8*)
+DEF_NARRAY_INT_SORT_METHOD_FUNC(uint8)
 #undef qsort_dtype
-#define qsort_dtype dtype*
+#define qsort_dtype uint8*
 #undef qsort_cast
-#define qsort_cast **(dtype**)
+#define qsort_cast **(uint8**)
+DEF_NARRAY_INT_SORT_INDEX_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_INT_MEDIAN_METHOD_FUNC(uint8)
+DEF_NARRAY_INT_MEAN_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_INT_VAR_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_INT_STDDEV_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_INT_RMS_METHOD_FUNC(uint8, numo_cUInt8)
 
-static void uint8_index_qsort(void* a, size_t n, ssize_t es) {
-  char *pa, *pb, *pc, *pd, *pl, *pm, *pn;
-  int d, r, swaptype, presorted;
+static size_t uint8_memsize(const void* ptr) {
+  size_t size = sizeof(narray_data_t);
+  const narray_data_t* na = (const narray_data_t*)ptr;
 
-loop:
-  SWAPINIT(a, es);
-  if (n < 7) {
-    for (pm = (char*)a + es; pm < (char*)a + n * es; pm += es)
-      for (pl = pm; pl > (char*)a && cmpgt(pl - es, pl); pl -= es) swap(pl, pl - es);
-    return;
-  }
-  presorted = 1;
-  for (pm = (char*)a + es; pm < (char*)a + n * es; pm += es) {
-    if (cmpgt(pm - es, pm)) {
-      presorted = 0;
-      break;
-    }
-  }
-  if (presorted) return;
-  pm = (char*)a + (n / 2) * es;
-  if (n > 7) {
-    pl = (char*)a;
-    pn = (char*)a + (n - 1) * es;
-    if (n > 40) {
-      d = (int)((n / 8) * es);
-      pl = med3(pl, pl + d, pl + 2 * d, cmp);
-      pm = med3(pm - d, pm, pm + d, cmp);
-      pn = med3(pn - 2 * d, pn - d, pn, cmp);
-    }
-    pm = med3(pl, pm, pn, cmp);
+  assert(na->base.type == NARRAY_DATA_T);
+
+  if (na->ptr != NULL) {
+
+    size += na->base.size * sizeof(dtype);
   }
-  swap(a, pm);
-  for (pa = pb = (char*)a + es, pc = pd = (char*)a + (n - 1) * es; pb <= pc;
-       pb += es, pc -= es) {
-    while (pb <= pc && (r = cmp(pb, a)) <= 0) {
-      if (r == 0) {
-        swap(pa, pb);
-        pa += es;
-      }
-      pb += es;
-    }
-    while (pb <= pc && (r = cmp(pc, a)) >= 0) {
-      if (r == 0) {
-        swap(pc, pd);
-        pd -= es;
-      }
-      pc -= es;
+  if (na->base.size > 0) {
+    if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
+      size += sizeof(size_t) * na->base.ndim;
     }
-    if (pb > pc) break;
-    swap(pb, pc);
   }
-  pn = (char*)a + n * es;
-  r = (int)Min(pa - (char*)a, pb - pa);
-  vecswap(a, pb - r, r);
-  r = (int)Min(pd - pc, pn - pd - es);
-  vecswap(pb, pn - r, r);
-  if ((r = (int)(pb - pa)) > es) uint8_index_qsort(a, r / es, es);
-  if ((r = (int)(pd - pc)) > es) {
-    /* Iterate rather than recurse to save stack space */
-    a = pn - r;
-    n = r / es;
-    goto loop;
-  }
-  /*              qsort(pn - r, r / es, es, cmp);*/
+  return size;
 }
 
-#define idx_t int64_t
-static void uint8_index64_qsort(na_loop_t* const lp) {
-  size_t i, n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step, o_step;
-  char** ptr;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  INIT_PTR(lp, 2, o_ptr, o_step);
-
-  ptr = (char**)(lp->opt_ptr);
-
-  // o_ptr=%lx,o_step=%ld)\n",(size_t)ptr,(size_t)d_ptr,(ssize_t)d_step,(size_t)i_ptr,(ssize_t)i_step,(size_t)o_ptr,(ssize_t)o_step);
+static void uint8_free(void* ptr) {
+  narray_data_t* na = (narray_data_t*)ptr;
 
-  if (n == 1) {
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr);
-    return;
-  }
+  assert(na->base.type == NARRAY_DATA_T);
 
-  for (i = 0; i < n; i++) {
-    ptr[i] = d_ptr + d_step * i;
+  if (na->ptr != NULL) {
+    if (na->owned) {
+      xfree(na->ptr);
+    }
+    na->ptr = NULL;
   }
-
-  uint8_index_qsort(ptr, n, sizeof(dtype*));
-
-  // d_ptr = lp->args[0].ptr;
-
-  for (i = 0; i < n; i++) {
-    idx = (ptr[i] - d_ptr) / d_step;
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-    o_ptr += o_step;
+  if (na->base.size > 0) {
+    if (na->base.shape != NULL && na->base.shape != &(na->base.size)) {
+      xfree(na->base.shape);
+      na->base.shape = NULL;
+    }
   }
+  xfree(na);
 }
-#undef idx_t
-
-#define idx_t int32_t
-static void uint8_index32_qsort(na_loop_t* const lp) {
-  size_t i, n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step, o_step;
-  char** ptr;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  INIT_PTR(lp, 2, o_ptr, o_step);
-
-  ptr = (char**)(lp->opt_ptr);
 
-  // o_ptr=%lx,o_step=%ld)\n",(size_t)ptr,(size_t)d_ptr,(ssize_t)d_step,(size_t)i_ptr,(ssize_t)i_step,(size_t)o_ptr,(ssize_t)o_step);
+static narray_type_info_t uint8_info = {
 
-  if (n == 1) {
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr);
-    return;
-  }
+  0,             // element_bits
+  sizeof(dtype), // element_bytes
+  sizeof(dtype), // element_stride (in bytes)
 
-  for (i = 0; i < n; i++) {
-    ptr[i] = d_ptr + d_step * i;
-  }
+};
 
-  uint8_index_qsort(ptr, n, sizeof(dtype*));
+static const rb_data_type_t uint8_data_type = {
+  "Numo::UInt8",
+  {
+    0,
+    uint8_free,
+    uint8_memsize,
+  },
+  &na_data_type,
+  &uint8_info,
+  RUBY_TYPED_FROZEN_SHAREABLE, // flags
+};
 
-  // d_ptr = lp->args[0].ptr;
+static VALUE uint8_s_alloc_func(VALUE klass) {
+  narray_data_t* na = ALLOC(narray_data_t);
 
-  for (i = 0; i < n; i++) {
-    idx = (ptr[i] - d_ptr) / d_step;
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-    o_ptr += o_step;
-  }
+  na->base.ndim = 0;
+  na->base.type = NARRAY_DATA_T;
+  na->base.flag[0] = NA_FL0_INIT;
+  na->base.flag[1] = NA_FL1_INIT;
+  na->base.size = 0;
+  na->base.shape = NULL;
+  na->base.reduce = INT2FIX(0);
+  na->ptr = NULL;
+  na->owned = FALSE;
+  return TypedData_Wrap_Struct(klass, &uint8_data_type, (void*)na);
 }
-#undef idx_t
 
-/*
-  sort_index. Returns an index array of sort result.
-  @overload sort_index(axis:nil)
-    @param [Numeric,Array,Range] axis  Performs sort_index along the axis.
-    @return [Integer,Numo::Int] returns result index of sort_index.
-  @example
-      Numo::NArray[3,4,1,2].sort_index #=> Numo::Int32[2,3,0,1]
-*/
-static VALUE uint8_sort_index(int argc, VALUE* argv, VALUE self) {
-  size_t size;
+static VALUE uint8_allocate(VALUE self) {
   narray_t* na;
-  VALUE idx, tmp, reduce, res;
-  char* buf;
-  ndfunc_arg_in_t ain[3] = { { cT, 0 }, { 0, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };
-  ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_CUM, 3, 1, ain, aout };
+  char* ptr;
 
   GetNArray(self, na);
-  if (na->ndim == 0) {
-    return INT2FIX(0);
-  }
-  if (na->size > (~(u_int32_t)0)) {
-    ain[1].type = aout[0].type = numo_cInt64;
-    idx = nary_new(numo_cInt64, na->ndim, na->shape);
-
-    ndf.func = uint8_index64_qsort;
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
-
-  } else {
-    ain[1].type = aout[0].type = numo_cInt32;
-    idx = nary_new(numo_cInt32, na->ndim, na->shape);
-
-    ndf.func = uint8_index32_qsort;
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
-  }
-  rb_funcall(idx, rb_intern("seq"), 0);
-
-  size = na->size * sizeof(void*); // max capa
-  buf = rb_alloc_tmp_buffer(&tmp, size);
-  res = na_ndloop3(&ndf, buf, 3, self, idx, reduce);
-  rb_free_tmp_buffer(&tmp);
-  return res;
-}
-
-static void iter_uint8_median(na_loop_t* const lp) {
-  size_t n;
-  char *p1, *p2;
-  dtype* buf;
-
-  INIT_COUNTER(lp, n);
-  p1 = (lp->args[0]).ptr + (lp->args[0].iter[0]).pos;
-  p2 = (lp->args[1]).ptr + (lp->args[1].iter[0]).pos;
-  buf = (dtype*)p1;
 
-  uint8_qsort(buf, n, sizeof(dtype));
+  switch (NA_TYPE(na)) {
+  case NARRAY_DATA_T:
+    ptr = NA_DATA_PTR(na);
+    if (na->size > 0 && ptr == NULL) {
+      ptr = xmalloc(sizeof(dtype) * na->size);
 
-  if (n == 0) {
-    *(dtype*)p2 = buf[0];
-  } else if (n % 2 == 0) {
-    *(dtype*)p2 = (buf[n / 2 - 1] + buf[n / 2]) / 2;
-  } else {
-    *(dtype*)p2 = buf[(n - 1) / 2];
+      NA_DATA_PTR(na) = ptr;
+      NA_DATA_OWNED(na) = TRUE;
+    }
+    break;
+  case NARRAY_VIEW_T:
+    rb_funcall(NA_VIEW_DATA(na), rb_intern("allocate"), 0);
+    break;
+  case NARRAY_FILEMAP_T:
+    // ptr = ((narray_filemap_t*)na)->ptr;
+    //  to be implemented
+  default:
+    rb_bug("invalid narray type : %d", NA_TYPE(na));
   }
-}
-
-/*
-  median of self.
-  @overload median(axis:nil, keepdims:false)
-    @param [Numeric,Array,Range] axis  Finds median along the axis.
-    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-    dimensions with size one.
-    @return [Numo::UInt8] returns median of self.
-*/
-
-static VALUE uint8_median(int argc, VALUE* argv, VALUE self) {
-  VALUE v, reduce;
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { INT2FIX(0), 0 } };
-  ndfunc_t ndf = { 0, NDF_HAS_LOOP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
-
-  self = na_copy(self); // as temporary buffer
-
-  ndf.func = iter_uint8_median;
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-  return uint8_extract(v);
+  return self;
 }
 
 void Init_numo_uint8(void) {
@@ -2202,12 +323,7 @@ void Init_numo_uint8(void) {
   rb_define_const(cT, "UPCAST", hCast);
   rb_hash_aset(hCast, rb_cArray, cT);
 
-#ifdef RUBY_INTEGER_UNIFICATION
   rb_hash_aset(hCast, rb_cInteger, cT);
-#else
-  rb_hash_aset(hCast, rb_cFixnum, cT);
-  rb_hash_aset(hCast, rb_cBignum, cT);
-#endif
   rb_hash_aset(hCast, rb_cFloat, numo_cDFloat);
   rb_hash_aset(hCast, rb_cComplex, numo_cDComplex);
   rb_hash_aset(hCast, numo_cRObject, numo_cRObject);
@@ -2237,12 +353,50 @@ void Init_numo_uint8(void) {
   rb_define_const(cT, "MIN", M_MIN);
   rb_define_alloc_func(cT, uint8_s_alloc_func);
   rb_define_method(cT, "allocate", uint8_allocate, 0);
+  /**
+   * Extract an element only if self is a dimensionless NArray.
+   * @overload extract
+   *   @return [Numeric,Numo::NArray]
+   *   --- Extract element value as Ruby Object if self is a dimensionless NArray,
+   *   otherwise returns self.
+   */
   rb_define_method(cT, "extract", uint8_extract, 0);
-
+  /**
+   * Store elements to Numo::UInt8 from other.
+   * @overload store(other)
+   *   @param [Object] other
+   *   @return [Numo::UInt8] self
+   */
   rb_define_method(cT, "store", uint8_store, 1);
-
+  /**
+   * Cast object to Numo::UInt8.
+   * @overload [](elements)
+   * @overload cast(array)
+   *   @param [Numeric,Array] elements
+   *   @param [Array] array
+   *   @return [Numo::UInt8]
+   */
   rb_define_singleton_method(cT, "cast", uint8_s_cast, 1);
+  /**
+   * Multi-dimensional element reference.
+   * @overload [](dim0,...,dimL)
+   *   @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,
+   *     Symbol] dim0,...,dimL  multi-dimensional indices.
+   *   @return [Numeric,Numo::UInt8] an element or NArray view.
+   * @see Numo::NArray#[]
+   * @see #[]=
+   */
   rb_define_method(cT, "[]", uint8_aref, -1);
+  /**
+   * Multi-dimensional element assignment.
+   * @overload []=(dim0,...,dimL,val)
+   *   @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,
+   *     Symbol] dim0,...,dimL  multi-dimensional indices.
+   *   @param [Numeric,Numo::NArray,Array] val  Value(s) to be set to self.
+   *   @return [Numeric,Numo::NArray,Array] returns `val` (last argument).
+   * @see Numo::NArray#[]=
+   * @see #[]
+   */
   rb_define_method(cT, "[]=", uint8_aset, -1);
   /**
    * return NArray with cast to the type of self.
@@ -2283,10 +437,54 @@ void Init_numo_uint8(void) {
    *   @return [String]
    */
   rb_define_method(cT, "inspect", uint8_inspect, 0);
+  /**
+   * Calls the given block once for each element in self,
+   * passing that element as a parameter.
+   * @overload each
+   *   @return [Numo::NArray] self
+   *   For a block `{|x| ... }`,
+   *   @yieldparam [Numeric] x  an element of NArray.
+   * @see #each_with_index
+   * @see #map
+   */
   rb_define_method(cT, "each", uint8_each, 0);
+  /**
+   * Unary map.
+   * @overload map
+   *   @return [Numo::UInt8] map of self.
+   */
   rb_define_method(cT, "map", uint8_map, 0);
+  /**
+   * Invokes the given block once for each element of self,
+   * passing that element and indices along each axis as parameters.
+   * @overload each_with_index
+   *   For a block `{|x,i,j,...| ... }`,
+   *   @yieldparam [Numeric] x  an element
+   *   @yieldparam [Integer] i,j,...  multitimensional indices
+   *   @return [Numo::NArray] self
+   * @see #each
+   * @see #map_with_index
+   */
   rb_define_method(cT, "each_with_index", uint8_each_with_index, 0);
+  /**
+   * Invokes the given block once for each element of self,
+   * passing that element and indices along each axis as parameters.
+   * Creates a new NArray containing the values returned by the block.
+   * Inplace option is allowed, i.e., `nary.inplace.map` overwrites `nary`.
+   * @overload map_with_index
+   *   For a block `{|x,i,j,...| ... }`,
+   *   @yieldparam [Numeric] x  an element
+   *   @yieldparam [Integer] i,j,...  multitimensional indices
+   *   @return [Numo::NArray] mapped array
+   * @see #map
+   * @see #each_with_index
+   */
   rb_define_method(cT, "map_with_index", uint8_map_with_index, 0);
+  /**
+   * abs of self.
+   * @overload abs
+   *   @return [Numo::UInt8] abs of self.
+   */
   rb_define_method(cT, "abs", uint8_abs, 0);
   /**
    * Binary add.
@@ -2747,11 +945,40 @@ void Init_numo_uint8(void) {
    *   # [4, 3, 3, 2, 4, 2]
    */
   rb_define_method(cT, "rand", uint8_rand, -1);
+  /**
+   * Calculate polynomial.
+   *   `x.poly(a0,a1,a2,...,an) = a0 + a1*x + a2*x**2 + ... + an*x**n`
+   * @overload poly a0, a1, ..., an
+   *   @param [Numo::NArray,Numeric] a0,a1,...,an
+   *   @return [Numo::UInt8]
+   */
   rb_define_method(cT, "poly", uint8_poly, -2);
-
+  /**
+   * sort of self.
+   * @overload sort(axis:nil)
+   *   @param [Numeric,Array,Range] axis  Performs sort along the axis.
+   *   @return [Numo::UInt8] returns result of sort.
+   * @example
+   *     Numo::DFloat[3,4,1,2].sort #=> Numo::DFloat[1,2,3,4]
+   */
   rb_define_method(cT, "sort", uint8_sort, -1);
-
+  /**
+   * sort_index. Returns an index array of sort result.
+   * @overload sort_index(axis:nil)
+   *   @param [Numeric,Array,Range] axis  Performs sort_index along the axis.
+   *   @return [Integer,Numo::Int] returns result index of sort_index.
+   * @example
+   *     Numo::NArray[3,4,1,2].sort_index #=> Numo::Int32[2,3,0,1]
+   */
   rb_define_method(cT, "sort_index", uint8_sort_index, -1);
+  /**
+   * median of self.
+   * @overload median(axis:nil, keepdims:false)
+   *   @param [Numeric,Array,Range] axis  Finds median along the axis.
+   *   @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+   *   dimensions with size one.
+   *   @return [Numo::UInt8] returns median of self.
+   */
   rb_define_method(cT, "median", uint8_median, -1);
   rb_define_singleton_method(cT, "[]", uint8_s_cast, -2);
   /**