numo-narray-alt 0.9.13 → 0.10.0

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

@@ -42,12 +42,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"
@@ -64,6 +74,10 @@ extern VALUE cRT;
 #include "mh/round/ceil.h"
 #include "mh/round/trunc.h"
 #include "mh/round/rint.h"
+#include "mh/copysign.h"
+#include "mh/signbit.h"
+#include "mh/modf.h"
+#include "mh/kahan_sum.h"
 #include "mh/comp/eq.h"
 #include "mh/comp/ne.h"
 #include "mh/comp/nearly_eq.h"
@@ -101,6 +115,9 @@ extern VALUE cRT;
 #include "mh/eye.h"
 #include "mh/rand.h"
 #include "mh/rand_norm.h"
+#include "mh/poly.h"
+#include "mh/sort.h"
+#include "mh/median.h"
 #include "mh/math/sqrt.h"
 #include "mh/math/cbrt.h"
 #include "mh/math/log.h"
@@ -133,12 +150,23 @@ extern VALUE cRT;
 
 typedef double dfloat; // Type aliases for shorter notation
                        // following the codebase naming convention.
+DEF_NARRAY_STORE_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_S_CAST_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_EXTRACT_METHOD_FUNC(dfloat)
+DEF_NARRAY_AREF_METHOD_FUNC(dfloat)
+DEF_EXTRACT_DATA_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_ASET_METHOD_FUNC(dfloat)
 DEF_NARRAY_COERCE_CAST_METHOD_FUNC(dfloat)
 DEF_NARRAY_TO_A_METHOD_FUNC(dfloat)
 DEF_NARRAY_FILL_METHOD_FUNC(dfloat)
 DEF_NARRAY_FORMAT_METHOD_FUNC(dfloat)
 DEF_NARRAY_FORMAT_TO_A_METHOD_FUNC(dfloat)
 DEF_NARRAY_INSPECT_METHOD_FUNC(dfloat)
+DEF_NARRAY_EACH_METHOD_FUNC(dfloat)
+DEF_NARRAY_MAP_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_EACH_WITH_INDEX_METHOD_FUNC(dfloat)
+DEF_NARRAY_MAP_WITH_INDEX_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_ABS_METHOD_FUNC(dfloat, numo_cDFloat, dfloat, numo_cDFloat)
 #ifdef __SSE2__
 DEF_NARRAY_DFLT_ADD_SSE2_METHOD_FUNC()
 DEF_NARRAY_DFLT_SUB_SSE2_METHOD_FUNC()
@@ -162,6 +190,10 @@ DEF_NARRAY_FLT_ROUND_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_FLT_CEIL_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_FLT_TRUNC_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_FLT_RINT_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_COPYSIGN_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_SIGNBIT_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_MODF_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_KAHAN_SUM_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_EQ_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_NE_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_NEARLY_EQ_METHOD_FUNC(dfloat, numo_cDFloat)
@@ -199,6 +231,18 @@ DEF_NARRAY_FLT_LOGSEQ_METHOD_FUNC(dfloat)
 DEF_NARRAY_EYE_METHOD_FUNC(dfloat)
 DEF_NARRAY_FLT_RAND_METHOD_FUNC(dfloat)
 DEF_NARRAY_FLT_RAND_NORM_METHOD_FUNC(dfloat)
+DEF_NARRAY_POLY_METHOD_FUNC(dfloat, numo_cDFloat)
+#undef qsort_dtype
+#define qsort_dtype dfloat
+#undef qsort_cast
+#define qsort_cast *(dfloat*)
+DEF_NARRAY_FLT_SORT_METHOD_FUNC(dfloat)
+#undef qsort_dtype
+#define qsort_dtype dfloat*
+#undef qsort_cast
+#define qsort_cast **(dfloat**)
+DEF_NARRAY_FLT_SORT_INDEX_METHOD_FUNC(dfloat, numo_cDFloat)
+DEF_NARRAY_FLT_MEDIAN_METHOD_FUNC(dfloat)
 #ifdef __SSE2__
 DEF_NARRAY_FLT_SQRT_SSE2_DBL_METHOD_FUNC(dfloat, numo_cDFloat)
 #else
@@ -233,8 +277,6 @@ DEF_NARRAY_FLT_EXPM1_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_FLT_LDEXP_METHOD_FUNC(dfloat, numo_cDFloat)
 DEF_NARRAY_FLT_FREXP_METHOD_FUNC(dfloat, numo_cDFloat)
 
-static VALUE dfloat_store(VALUE, VALUE);
-
 static size_t dfloat_memsize(const void* ptr) {
   size_t size = sizeof(narray_data_t);
   const narray_data_t* na = (const narray_data_t*)ptr;
@@ -336,2447 +378,44 @@ static VALUE dfloat_allocate(VALUE self) {
   return self;
 }
 
-static VALUE dfloat_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 dfloat_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 dfloat_store_numeric(VALUE self, VALUE obj) {
-  dtype x;
-  x = m_num_to_data(obj);
-  obj = dfloat_new_dim0(x);
-  dfloat_store(self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_bit(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_bit, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_dfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_dfloat, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_sfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_sfloat, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_int64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_int64, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_int32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_int32, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_int16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_int16, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_int8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_int8, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_uint64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_uint64, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_uint32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_uint32, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_uint16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_uint16, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_uint8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_uint8, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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 dfloat_store_robject(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_robject, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop(&ndf, 2, self, obj);
-  return self;
-}
-
-static void iter_dfloat_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_dfloat_store_dfloat(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 dfloat_store_array(VALUE self, VALUE rary) {
-  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { rb_cArray, 0 } };
-  ndfunc_t ndf = { iter_dfloat_store_array, FULL_LOOP, 2, 0, ain, 0 };
-
-  na_ndloop_store_rarray(&ndf, self, rary);
-  return self;
-}
-
-static VALUE dfloat_store(VALUE self, VALUE obj) {
-  VALUE r, klass;
-
-  klass = rb_obj_class(obj);
-
-  if (klass == numo_cDFloat) {
-    dfloat_store_dfloat(self, obj);
-    return self;
-  }
-
-  if (IS_INTEGER_CLASS(klass) || klass == rb_cFloat || klass == rb_cComplex) {
-    dfloat_store_numeric(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cBit) {
-    dfloat_store_bit(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cSFloat) {
-    dfloat_store_sfloat(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt64) {
-    dfloat_store_int64(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt32) {
-    dfloat_store_int32(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt16) {
-    dfloat_store_int16(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cInt8) {
-    dfloat_store_int8(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cUInt64) {
-    dfloat_store_uint64(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cUInt32) {
-    dfloat_store_uint32(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cUInt16) {
-    dfloat_store_uint16(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cUInt8) {
-    dfloat_store_uint8(self, obj);
-    return self;
-  }
-
-  if (klass == numo_cRObject) {
-    dfloat_store_robject(self, obj);
-    return self;
-  }
-
-  if (klass == rb_cArray) {
-    dfloat_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) {
-      dfloat_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 dfloat_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_cDFloat) {
-      x = m_from_real(*(double*)(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_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;
-    }
+VALUE mTM;
 
-    if (klass == numo_cInt16) {
-      x = m_from_sint(*(int16_t*)(ptr + pos));
-      return x;
-    }
+void Init_numo_dfloat(void) {
+  VALUE hCast, mNumo;
 
-    if (klass == numo_cInt8) {
-      x = m_from_sint(*(int8_t*)(ptr + pos));
-      return x;
-    }
+  mNumo = rb_define_module("Numo");
 
-    if (klass == numo_cUInt64) {
-      x = m_from_uint64(*(u_int64_t*)(ptr + pos));
-      return x;
-    }
+  id_pow = rb_intern("**");
+  id_cast = rb_intern("cast");
+  id_copysign = rb_intern("copysign");
+  id_divmod = rb_intern("divmod");
+  id_eq = rb_intern("eq");
+  id_ge = rb_intern("ge");
+  id_gt = rb_intern("gt");
+  id_le = rb_intern("le");
+  id_lt = rb_intern("lt");
+  id_mulsum = rb_intern("mulsum");
+  id_nan = rb_intern("nan");
+  id_ne = rb_intern("ne");
+  id_nearly_eq = rb_intern("nearly_eq");
+  id_to_a = rb_intern("to_a");
 
-    if (klass == numo_cUInt32) {
-      x = m_from_uint32(*(u_int32_t*)(ptr + pos));
-      return x;
-    }
+  /**
+   * Document-class: Numo::DFloat
+   *
+   * Double precision floating point number (64-bit float) N-dimensional array class.
+   */
+  cT = rb_define_class_under(mNumo, "DFloat", cNArray);
 
-    if (klass == numo_cUInt16) {
-      x = m_from_sint(*(u_int16_t*)(ptr + pos));
-      return x;
-    }
+  // alias of DFloat
+  rb_define_const(mNumo, "Float64", numo_cDFloat);
 
-    if (klass == numo_cUInt8) {
-      x = m_from_sint(*(u_int8_t*)(ptr + pos));
-      return x;
-    }
+  hCast = rb_hash_new();
+  /* Upcasting rules of DFloat. */
+  rb_define_const(cT, "UPCAST", hCast);
+  rb_hash_aset(hCast, rb_cArray, cT);
 
-    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 dfloat_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 dfloat_cast_array(VALUE rary) {
-  VALUE nary;
-  narray_t* na;
-
-  nary = na_s_new_like(cT, rary);
-  GetNArray(nary, na);
-  if (na->size > 0) {
-    dfloat_store_array(nary, rary);
-  }
-  return nary;
-}
-
-static VALUE dfloat_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 dfloat_new_dim0(x);
-  }
-  if (RTEST(rb_obj_is_kind_of(obj, rb_cArray))) {
-    return dfloat_cast_array(obj);
-  }
-  if (IsNArray(obj)) {
-    GetNArray(obj, na);
-    v = nary_new(cT, NA_NDIM(na), NA_SHAPE(na));
-    if (NA_SIZE(na) > 0) {
-      dfloat_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 dfloat_cast_array(obj);
-  }
-
-  rb_raise(nary_eCastError, "cannot cast to %s", rb_class2name(type));
-  return Qnil;
-}
-
-static VALUE dfloat_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);
-  }
-}
-
-static VALUE dfloat_aset(int argc, VALUE* argv, VALUE self) {
-  int nd;
-  size_t pos;
-  char* ptr;
-  VALUE a;
-  dtype x;
-
-  argc--;
-  if (argc == 0) {
-    dfloat_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);
-      dfloat_store(a, argv[argc]);
-    } else {
-      x = dfloat_extract_data(argv[argc]);
-      ptr = na_get_pointer_for_read_write(self) + pos;
-      *(dtype*)ptr = x;
-    }
-  }
-  return argv[argc];
-}
-
-static void iter_dfloat_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);
-    }
-  }
-}
-
-static VALUE dfloat_each(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_each, FULL_LOOP_NIP, 1, 0, ain, 0 };
-
-  na_ndloop(&ndf, 1, self);
-  return self;
-}
-
-static void iter_dfloat_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 {
-      //
-      if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype))) {
-        if (s1 == sizeof(dtype) && s2 == sizeof(dtype)) {
-          for (i = 0; i < n; i++) {
-            ((dtype*)p2)[i] = m_map(((dtype*)p1)[i]);
-          }
-          return;
-        }
-        if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype))) {
-          //
-          for (i = 0; i < n; i++) {
-            *(dtype*)p2 = m_map(*(dtype*)p1);
-            p1 += s1;
-            p2 += s2;
-          }
-          return;
-          //
-        }
-      }
-      for (i = 0; i < n; i++) {
-        GET_DATA_STRIDE(p1, s1, dtype, x);
-        x = m_map(x);
-        SET_DATA_STRIDE(p2, s2, dtype, x);
-      }
-      //
-    }
-  }
-}
-
-static VALUE dfloat_map(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_dfloat_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_dfloat_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]++;
-    }
-  }
-}
-
-static VALUE dfloat_each_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
-  ndfunc_t ndf = { iter_dfloat_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_dfloat_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]++;
-      }
-    }
-  }
-}
-
-static VALUE dfloat_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_dfloat_map_with_index, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop_with_index(&ndf, 1, self);
-}
-
-static void iter_dfloat_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);
-      }
-    }
-  }
-}
-
-static VALUE dfloat_abs(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cRT, 0 } };
-  ndfunc_t ndf = { iter_dfloat_abs, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-#define check_intdivzero(y)                                                                    \
-  {}
-
-static void iter_dfloat_copysign(na_loop_t* const lp) {
-  size_t i = 0;
-  size_t n;
-  char *p1, *p2, *p3;
-  ssize_t s1, s2, s3;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, p1, s1);
-  INIT_PTR(lp, 1, p2, s2);
-  INIT_PTR(lp, 2, p3, s3);
-
-  //
-  if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype)) &&
-      is_aligned(p3, sizeof(dtype))) {
-
-    if (s1 == sizeof(dtype) && s2 == sizeof(dtype) && s3 == sizeof(dtype)) {
-      if (p1 == p3) { // inplace case
-        for (; i < n; i++) {
-          check_intdivzero(((dtype*)p2)[i]);
-          ((dtype*)p1)[i] = m_copysign(((dtype*)p1)[i], ((dtype*)p2)[i]);
-        }
-      } else {
-        for (; i < n; i++) {
-          check_intdivzero(((dtype*)p2)[i]);
-          ((dtype*)p3)[i] = m_copysign(((dtype*)p1)[i], ((dtype*)p2)[i]);
-        }
-      }
-      return;
-    }
-
-    if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype)) &&
-        is_aligned_step(s3, sizeof(dtype))) {
-      //
-
-      if (s2 == 0) { // Broadcasting from scalar value.
-        check_intdivzero(*(dtype*)p2);
-        if (s1 == sizeof(dtype) && s3 == sizeof(dtype)) {
-          if (p1 == p3) { // inplace case
-            for (; i < n; i++) {
-              ((dtype*)p1)[i] = m_copysign(((dtype*)p1)[i], *(dtype*)p2);
-            }
-          } else {
-            for (; i < n; i++) {
-              ((dtype*)p3)[i] = m_copysign(((dtype*)p1)[i], *(dtype*)p2);
-            }
-          }
-        } else {
-          for (i = 0; i < n; i++) {
-            *(dtype*)p3 = m_copysign(*(dtype*)p1, *(dtype*)p2);
-            p1 += s1;
-            p3 += s3;
-          }
-        }
-      } else {
-        if (p1 == p3) { // inplace case
-          for (i = 0; i < n; i++) {
-            check_intdivzero(*(dtype*)p2);
-            *(dtype*)p1 = m_copysign(*(dtype*)p1, *(dtype*)p2);
-            p1 += s1;
-            p2 += s2;
-          }
-        } else {
-          for (i = 0; i < n; i++) {
-            check_intdivzero(*(dtype*)p2);
-            *(dtype*)p3 = m_copysign(*(dtype*)p1, *(dtype*)p2);
-            p1 += s1;
-            p2 += s2;
-            p3 += s3;
-          }
-        }
-      }
-
-      return;
-      //
-    }
-  }
-  for (i = 0; i < n; i++) {
-    dtype x, y, z;
-    GET_DATA_STRIDE(p1, s1, dtype, x);
-    GET_DATA_STRIDE(p2, s2, dtype, y);
-    check_intdivzero(y);
-    z = m_copysign(x, y);
-    SET_DATA_STRIDE(p3, s3, dtype, z);
-  }
-  //
-}
-#undef check_intdivzero
-
-static VALUE dfloat_copysign_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_dfloat_copysign, STRIDE_LOOP, 2, 1, ain, aout };
-
-  return na_ndloop(&ndf, 2, self, other);
-}
-
-static VALUE dfloat_copysign(VALUE self, VALUE other) {
-
-  VALUE klass, v;
-
-  klass = na_upcast(rb_obj_class(self), rb_obj_class(other));
-  if (klass == cT) {
-    return dfloat_copysign_self(self, other);
-  } else {
-    v = rb_funcall(klass, id_cast, 1, self);
-    return rb_funcall(v, id_copysign, 1, other);
-  }
-}
-
-static void iter_dfloat_signbit(na_loop_t* const lp) {
-  size_t i;
-  char* p1;
-  BIT_DIGIT* a2;
-  size_t p2;
-  ssize_t s1, s2;
-  size_t* idx1;
-  dtype x;
-  BIT_DIGIT b;
-  INIT_COUNTER(lp, i);
-  INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  INIT_PTR_BIT(lp, 1, a2, p2, s2);
-  if (idx1) {
-    for (; i--;) {
-      GET_DATA_INDEX(p1, idx1, dtype, x);
-      b = (m_signbit(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      b = (m_signbit(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  }
-}
-
-static VALUE dfloat_signbit(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
-  ndfunc_t ndf = { iter_dfloat_signbit, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_dfloat_modf(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2, *p3;
-  ssize_t s1, s2, s3;
-  dtype x, y, z;
-  INIT_COUNTER(lp, i);
-  INIT_PTR(lp, 0, p1, s1);
-  INIT_PTR(lp, 1, p2, s2);
-  INIT_PTR(lp, 2, p3, s3);
-  for (; i--;) {
-    GET_DATA_STRIDE(p1, s1, dtype, x);
-    m_modf(x, y, z);
-    SET_DATA_STRIDE(p2, s2, dtype, y);
-    SET_DATA_STRIDE(p3, s3, dtype, z);
-  }
-}
-
-static VALUE dfloat_modf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[2] = { { cT, 0 }, { cT, 0 } };
-  ndfunc_t ndf = { iter_dfloat_modf, STRIDE_LOOP, 1, 2, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_dfloat_kahan_sum(na_loop_t* const lp) {
-  size_t n;
-  char *p1, *p2;
-  ssize_t s1;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, p1, s1);
-  p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
-
-  *(dtype*)p2 = f_kahan_sum(n, p1, s1);
-}
-static void iter_dfloat_kahan_sum_nan(na_loop_t* const lp) {
-  size_t n;
-  char *p1, *p2;
-  ssize_t s1;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, p1, s1);
-  p2 = lp->args[1].ptr + lp->args[1].iter[0].pos;
-
-  *(dtype*)p2 = f_kahan_sum_nan(n, p1, s1);
-}
-
-static VALUE dfloat_kahan_sum(int argc, VALUE* argv, VALUE self) {
-  VALUE v, reduce;
-  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_dfloat_kahan_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_kahan_sum_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return dfloat_extract(v);
-}
-
-static void iter_dfloat_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;
-}
-
-static VALUE dfloat_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_dfloat_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 dfloat_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
-
-#undef qsort_dtype
-#define qsort_dtype dtype
-#undef qsort_cast
-#define qsort_cast *(dtype*)
-#undef cmp
-#define cmp(a, b) cmp_prnan(a, b)
-#undef cmpgt
-#define cmpgt(a, b) cmpgt_prnan(a, b)
-
-static void dfloat_qsort_prnan(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) dfloat_qsort_prnan(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);*/
-}
-
-/*
-  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.
- */
-
-#undef qsort_dtype
-#define qsort_dtype dtype
-#undef qsort_cast
-#define qsort_cast *(dtype*)
-#undef cmp
-#define cmp(a, b) cmp_ignan(a, b)
-#undef cmpgt
-#define cmpgt(a, b) cmpgt_ignan(a, b)
-
-static void dfloat_qsort_ignan(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) dfloat_qsort_ignan(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_dfloat_sort_ignan(na_loop_t* const lp) {
-  size_t n;
-  char* ptr;
-  ssize_t step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, ptr, step);
-  dfloat_qsort_ignan(ptr, n, step);
-}
-static void iter_dfloat_sort_prnan(na_loop_t* const lp) {
-  size_t n;
-  char* ptr;
-  ssize_t step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, ptr, step);
-  dfloat_qsort_prnan(ptr, n, step);
-}
-
-static VALUE dfloat_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_dfloat_sort_ignan;
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_sort_prnan);
-
-  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.
- */
-
-#undef qsort_dtype
-#define qsort_dtype dtype*
-#undef qsort_cast
-#define qsort_cast **(dtype**)
-#undef cmp
-#define cmp(a, b) cmp_prnan(a, b)
-#undef cmpgt
-#define cmpgt(a, b) cmpgt_prnan(a, b)
-
-static void dfloat_index_qsort_prnan(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);
-  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 (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) dfloat_index_qsort_prnan(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);*/
-}
-
-/*
-  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.
- */
-
-#undef qsort_dtype
-#define qsort_dtype dtype*
-#undef qsort_cast
-#define qsort_cast **(dtype**)
-#undef cmp
-#define cmp(a, b) cmp_ignan(a, b)
-#undef cmpgt
-#define cmpgt(a, b) cmpgt_ignan(a, b)
-
-static void dfloat_index_qsort_ignan(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);
-  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 (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) dfloat_index_qsort_ignan(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);*/
-}
-
-#define idx_t int64_t
-static void dfloat_index64_qsort_ignan(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);
-
-  if (n == 1) {
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr);
-    return;
-  }
-
-  for (i = 0; i < n; i++) {
-    ptr[i] = d_ptr + d_step * i;
-  }
-
-  dfloat_index_qsort_ignan(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;
-  }
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void dfloat_index32_qsort_ignan(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);
-
-  if (n == 1) {
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr);
-    return;
-  }
-
-  for (i = 0; i < n; i++) {
-    ptr[i] = d_ptr + d_step * i;
-  }
-
-  dfloat_index_qsort_ignan(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;
-  }
-}
-#undef idx_t
-
-#define idx_t int64_t
-static void dfloat_index64_qsort_prnan(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);
-
-  if (n == 1) {
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr);
-    return;
-  }
-
-  for (i = 0; i < n; i++) {
-    ptr[i] = d_ptr + d_step * i;
-  }
-
-  dfloat_index_qsort_prnan(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;
-  }
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void dfloat_index32_qsort_prnan(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);
-
-  if (n == 1) {
-    *(idx_t*)o_ptr = *(idx_t*)(i_ptr);
-    return;
-  }
-
-  for (i = 0; i < n; i++) {
-    ptr[i] = d_ptr + d_step * i;
-  }
-
-  dfloat_index_qsort_prnan(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;
-  }
-}
-#undef idx_t
-
-static VALUE dfloat_sort_index(int argc, VALUE* argv, VALUE self) {
-  size_t size;
-  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 };
-
-  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 = dfloat_index64_qsort_ignan;
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, dfloat_index64_qsort_prnan);
-
-  } else {
-    ain[1].type = aout[0].type = numo_cInt32;
-    idx = nary_new(numo_cInt32, na->ndim, na->shape);
-
-    ndf.func = dfloat_index32_qsort_ignan;
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, dfloat_index32_qsort_prnan);
-  }
-  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_dfloat_median_ignan(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;
-
-  dfloat_qsort_ignan(buf, n, sizeof(dtype));
-
-  for (; n; n--) {
-    if (!isnan(buf[n - 1])) break;
-  }
-
-  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];
-  }
-}
-static void iter_dfloat_median_prnan(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;
-
-  dfloat_qsort_prnan(buf, n, sizeof(dtype));
-
-  for (; n; n--) {
-    if (!isnan(buf[n - 1])) break;
-  }
-
-  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];
-  }
-}
-
-static VALUE dfloat_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_dfloat_median_ignan;
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_median_prnan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-  return dfloat_extract(v);
-}
-
-VALUE mTM;
-
-void Init_numo_dfloat(void) {
-  VALUE hCast, mNumo;
-
-  mNumo = rb_define_module("Numo");
-
-  id_pow = rb_intern("**");
-  id_cast = rb_intern("cast");
-  id_copysign = rb_intern("copysign");
-  id_divmod = rb_intern("divmod");
-  id_eq = rb_intern("eq");
-  id_ge = rb_intern("ge");
-  id_gt = rb_intern("gt");
-  id_le = rb_intern("le");
-  id_lt = rb_intern("lt");
-  id_mulsum = rb_intern("mulsum");
-  id_nan = rb_intern("nan");
-  id_ne = rb_intern("ne");
-  id_nearly_eq = rb_intern("nearly_eq");
-  id_to_a = rb_intern("to_a");
-
-  /**
-   * Document-class: Numo::DFloat
-   *
-   * Double precision floating point number (64-bit float) N-dimensional array class.
-   */
-  cT = rb_define_class_under(mNumo, "DFloat", cNArray);
-
-  // alias of DFloat
-  rb_define_const(mNumo, "Float64", numo_cDFloat);
-
-  hCast = rb_hash_new();
-  /* Upcasting rules of DFloat. */
-  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, cT);
   rb_hash_aset(hCast, rb_cComplex, numo_cDComplex);
   rb_hash_aset(hCast, numo_cRObject, numo_cRObject);