numo-narray-alt 0.9.9 → 0.9.11

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

@@ -60,17 +60,57 @@ static ID id_truncate;
 VALUE cT;
 extern VALUE cRT;
 
+#include "mh/clip.h"
+#include "mh/sum.h"
+#include "mh/prod.h"
 #include "mh/mean.h"
 #include "mh/var.h"
 #include "mh/stddev.h"
 #include "mh/rms.h"
+#include "mh/min.h"
+#include "mh/max.h"
+#include "mh/ptp.h"
+#include "mh/max_index.h"
+#include "mh/min_index.h"
+#include "mh/argmax.h"
+#include "mh/argmin.h"
+#include "mh/maximum.h"
+#include "mh/minimum.h"
+#include "mh/minmax.h"
+#include "mh/cumsum.h"
+#include "mh/cumprod.h"
+#include "mh/mulsum.h"
+#include "mh/seq.h"
+#include "mh/logseq.h"
+#include "mh/eye.h"
+#include "mh/rand.h"
 
 typedef VALUE robject; // Type aliases for shorter notation
                        // following the codebase naming convention.
+DEF_NARRAY_CLIP_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_SUM_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_PROD_METHOD_FUNC(robject, numo_cRObject)
 DEF_NARRAY_FLT_MEAN_METHOD_FUNC(robject, numo_cRObject, VALUE, numo_cRObject)
 DEF_NARRAY_FLT_VAR_METHOD_FUNC(robject, numo_cRObject, VALUE, numo_cRObject)
 DEF_NARRAY_FLT_STDDEV_METHOD_FUNC(robject, numo_cRObject, VALUE, numo_cRObject)
 DEF_NARRAY_FLT_RMS_METHOD_FUNC(robject, numo_cRObject, VALUE, numo_cRObject)
+DEF_NARRAY_FLT_MIN_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_MAX_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_PTP_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_MAX_INDEX_METHOD_FUNC(robject)
+DEF_NARRAY_FLT_MIN_INDEX_METHOD_FUNC(robject)
+DEF_NARRAY_FLT_ARGMAX_METHOD_FUNC(robject)
+DEF_NARRAY_FLT_ARGMIN_METHOD_FUNC(robject)
+DEF_NARRAY_FLT_MAXIMUM_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_MINIMUM_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_MINMAX_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_CUMSUM_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_CUMPROD_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_MULSUM_METHOD_FUNC(robject, numo_cRObject)
+DEF_NARRAY_FLT_SEQ_METHOD_FUNC(robject)
+DEF_NARRAY_FLT_LOGSEQ_METHOD_FUNC(robject)
+DEF_NARRAY_EYE_METHOD_FUNC(robject)
+DEF_NARRAY_FLT_RAND_METHOD_FUNC(robject)
 
 static VALUE robject_store(VALUE, VALUE);
 
@@ -3425,123 +3465,6 @@ static VALUE robject_le(VALUE self, VALUE other) {
   return robject_le_self(self, other);
 }
 
-static void iter_robject_clip(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2, *p3, *p4;
-  ssize_t s1, s2, s3, s4;
-  dtype x, min, max;
-  INIT_COUNTER(lp, i);
-  INIT_PTR(lp, 0, p1, s1);
-  INIT_PTR(lp, 1, p2, s2);
-  INIT_PTR(lp, 2, p3, s3);
-  INIT_PTR(lp, 3, p4, s4);
-  for (; i--;) {
-    GET_DATA_STRIDE(p1, s1, dtype, x);
-    GET_DATA_STRIDE(p2, s2, dtype, min);
-    GET_DATA_STRIDE(p3, s3, dtype, max);
-    if (m_gt(min, max)) {
-      rb_raise(nary_eOperationError, "min is greater than max");
-    }
-    if (m_lt(x, min)) {
-      x = min;
-    }
-    if (m_gt(x, max)) {
-      x = max;
-    }
-    SET_DATA_STRIDE(p4, s4, dtype, x);
-  }
-}
-
-static void iter_robject_clip_min(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2, *p3;
-  ssize_t s1, s2, s3;
-  dtype x, min;
-  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);
-    GET_DATA_STRIDE(p2, s2, dtype, min);
-    if (m_lt(x, min)) {
-      x = min;
-    }
-    SET_DATA_STRIDE(p3, s3, dtype, x);
-  }
-}
-
-static void iter_robject_clip_max(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2, *p3;
-  ssize_t s1, s2, s3;
-  dtype x, max;
-  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);
-    GET_DATA_STRIDE(p2, s2, dtype, max);
-    if (m_gt(x, max)) {
-      x = max;
-    }
-    SET_DATA_STRIDE(p3, s3, dtype, x);
-  }
-}
-
-/*
-  Clip array elements by [min,max].
-  If either of min or max is nil, one side is clipped.
-  @overload clip(min,max)
-    @param [Numo::NArray,Numeric] min
-    @param [Numo::NArray,Numeric] max
-    @return [Numo::NArray] result of clip.
-
-  @example
-      a = Numo::Int32.new(10).seq
-      # => Numo::Int32#shape=[10]
-      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-      a.clip(1,8)
-      # => Numo::Int32#shape=[10]
-      # [1, 1, 2, 3, 4, 5, 6, 7, 8, 8]
-
-      a.inplace.clip(3,6)
-      a
-      # => Numo::Int32#shape=[10]
-      # [3, 3, 3, 3, 4, 5, 6, 6, 6, 6]
-
-      b = Numo::Int32.new(10).seq
-      # => Numo::Int32#shape=[10]
-      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-
-      b.clip([3,4,1,1,1,4,4,4,4,4], 8)
-      # => Numo::Int32#shape=[10]
-      # [3, 4, 2, 3, 4, 5, 6, 7, 8, 8]
-*/
-static VALUE robject_clip(VALUE self, VALUE min, VALUE max) {
-  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { cT, 0 }, { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf_min = { iter_robject_clip_min, STRIDE_LOOP, 2, 1, ain, aout };
-  ndfunc_t ndf_max = { iter_robject_clip_max, STRIDE_LOOP, 2, 1, ain, aout };
-  ndfunc_t ndf_both = { iter_robject_clip, STRIDE_LOOP, 3, 1, ain, aout };
-
-  if (RTEST(min)) {
-    if (RTEST(max)) {
-      return na_ndloop(&ndf_both, 3, self, min, max);
-    } else {
-      return na_ndloop(&ndf_min, 2, self, min);
-    }
-  } else {
-    if (RTEST(max)) {
-      return na_ndloop(&ndf_max, 2, self, max);
-    }
-  }
-  rb_raise(rb_eArgError, "min and max are not given");
-  return Qnil;
-}
-
 static void iter_robject_isnan(na_loop_t* const lp) {
   size_t i;
   char* p1;
@@ -3551,1641 +3474,205 @@ static void iter_robject_isnan(na_loop_t* const lp) {
   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_isnan(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      b = (m_isnan(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  }
-}
-
-/*
-  Condition of isnan.
-  @overload isnan
-    @return [Numo::Bit] Condition of isnan.
-*/
-static VALUE robject_isnan(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
-  ndfunc_t ndf = { iter_robject_isnan, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_robject_isinf(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_isinf(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      b = (m_isinf(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  }
-}
-
-/*
-  Condition of isinf.
-  @overload isinf
-    @return [Numo::Bit] Condition of isinf.
-*/
-static VALUE robject_isinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
-  ndfunc_t ndf = { iter_robject_isinf, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_robject_isposinf(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_isposinf(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      b = (m_isposinf(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  }
-}
-
-/*
-  Condition of isposinf.
-  @overload isposinf
-    @return [Numo::Bit] Condition of isposinf.
-*/
-static VALUE robject_isposinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
-  ndfunc_t ndf = { iter_robject_isposinf, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_robject_isneginf(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_isneginf(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      b = (m_isneginf(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  }
-}
-
-/*
-  Condition of isneginf.
-  @overload isneginf
-    @return [Numo::Bit] Condition of isneginf.
-*/
-static VALUE robject_isneginf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
-  ndfunc_t ndf = { iter_robject_isneginf, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_robject_isfinite(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_isfinite(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  } else {
-    for (; i--;) {
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      b = (m_isfinite(x)) ? 1 : 0;
-      STORE_BIT(a2, p2, b);
-      p2 += s2;
-    }
-  }
-}
-
-/*
-  Condition of isfinite.
-  @overload isfinite
-    @return [Numo::Bit] Condition of isfinite.
-*/
-static VALUE robject_isfinite(VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
-  ndfunc_t ndf = { iter_robject_isfinite, FULL_LOOP, 1, 1, ain, aout };
-
-  return na_ndloop(&ndf, 1, self);
-}
-
-static void iter_robject_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_sum(n, p1, s1);
-}
-static void iter_robject_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_sum_nan(n, p1, s1);
-}
-
-/*
-  sum of self.
-  @overload sum(axis:nil, keepdims:false, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
-    return NaN for min/max etc).
-    @param [Numeric,Array,Range] axis  Performs sum along the axis.
-    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-    dimensions with size one.
-    @return [Numo::RObject] returns result of sum.
-*/
-static VALUE robject_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_robject_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_sum_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return robject_extract(v);
-}
-
-static void iter_robject_prod(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_prod(n, p1, s1);
-}
-static void iter_robject_prod_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_prod_nan(n, p1, s1);
-}
-
-/*
-  prod of self.
-  @overload prod(axis:nil, keepdims:false, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
-    return NaN for min/max etc).
-    @param [Numeric,Array,Range] axis  Performs prod along the axis.
-    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-    dimensions with size one.
-    @return [Numo::RObject] returns result of prod.
-*/
-static VALUE robject_prod(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_robject_prod, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_prod_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return robject_extract(v);
-}
-
-static void iter_robject_min(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_min(n, p1, s1);
-}
-static void iter_robject_min_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_min_nan(n, p1, s1);
-}
-
-/*
-  min of self.
-  @overload min(axis:nil, keepdims:false, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
-    return NaN for min/max etc).
-    @param [Numeric,Array,Range] axis  Performs min along the axis.
-    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-    dimensions with size one.
-    @return [Numo::RObject] returns result of min.
-*/
-static VALUE robject_min(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_robject_min, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return robject_extract(v);
-}
-
-static void iter_robject_max(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_max(n, p1, s1);
-}
-static void iter_robject_max_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_max_nan(n, p1, s1);
-}
-
-/*
-  max of self.
-  @overload max(axis:nil, keepdims:false, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
-    return NaN for min/max etc).
-    @param [Numeric,Array,Range] axis  Performs max along the axis.
-    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-    dimensions with size one.
-    @return [Numo::RObject] returns result of max.
-*/
-static VALUE robject_max(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_robject_max, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return robject_extract(v);
-}
-
-static void iter_robject_ptp(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_ptp(n, p1, s1);
-}
-static void iter_robject_ptp_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_ptp_nan(n, p1, s1);
-}
-
-/*
-  ptp of self.
-  @overload ptp(axis:nil, keepdims:false, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
-    return NaN for min/max etc).
-    @param [Numeric,Array,Range] axis  Performs ptp along the axis.
-    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-    dimensions with size one.
-    @return [Numo::RObject] returns result of ptp.
-*/
-static VALUE robject_ptp(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_robject_ptp, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_ptp_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return robject_extract(v);
-}
-
-#define idx_t int64_t
-static void iter_robject_max_index_index64(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_max_index_index32(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-#define idx_t int64_t
-static void iter_robject_max_index_index64_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index_nan(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_max_index_index32_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index_nan(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-/*
-  Index of the maximum value.
-  @overload max_index(axis:nil, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
-    @param [Numeric,Array,Range] axis  Finds maximum values along the axis and returns **flat
-    1-d indices**.
-    @return [Integer,Numo::Int] returns result indices.
-  @see #argmax
-  @see #max
-
-  @example
-      a = Numo::NArray[3,4,1,2]
-      a.max_index  #=> 1
-
-      b = Numo::NArray[[3,4,1],[2,0,5]]
-      b.max_index             #=> 5
-      b.max_index(axis:1)     #=> [1, 5]
-      b.max_index(axis:0)     #=> [0, 1, 5]
-      b[b.max_index(axis:0)]  #=> [3, 4, 5]
- */
-static VALUE robject_max_index(int argc, VALUE* argv, VALUE self) {
-  narray_t* na;
-  VALUE idx, reduce;
-  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { Qnil, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };
-  ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 3, 1, ain, aout };
-
-  GetNArray(self, na);
-  if (na->ndim == 0) {
-    return INT2FIX(0);
-  }
-  if (na->size > (~(u_int32_t)0)) {
-    aout[0].type = numo_cInt64;
-    idx = nary_new(numo_cInt64, na->ndim, na->shape);
-    ndf.func = iter_robject_max_index_index64;
-
-    reduce =
-      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_index_index64_nan);
-
-  } else {
-    aout[0].type = numo_cInt32;
-    idx = nary_new(numo_cInt32, na->ndim, na->shape);
-    ndf.func = iter_robject_max_index_index32;
-
-    reduce =
-      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_index_index32_nan);
-  }
-  rb_funcall(idx, rb_intern("seq"), 0);
-
-  return na_ndloop(&ndf, 3, self, idx, reduce);
-}
-
-#define idx_t int64_t
-static void iter_robject_min_index_index64(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_min_index_index32(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-#define idx_t int64_t
-static void iter_robject_min_index_index64_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index_nan(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_min_index_index32_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *i_ptr, *o_ptr;
-  ssize_t d_step, i_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index_nan(n, d_ptr, d_step);
-
-  INIT_PTR(lp, 1, i_ptr, i_step);
-  o_ptr = NDL_PTR(lp, 2);
-  *(idx_t*)o_ptr = *(idx_t*)(i_ptr + i_step * idx);
-}
-#undef idx_t
-
-/*
-  Index of the minimum value.
-  @overload min_index(axis:nil, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
-    @param [Numeric,Array,Range] axis  Finds minimum values along the axis and returns **flat
-    1-d indices**.
-    @return [Integer,Numo::Int] returns result indices.
-  @see #argmin
-  @see #min
-
-  @example
-      a = Numo::NArray[3,4,1,2]
-      a.min_index  #=> 2
-
-      b = Numo::NArray[[3,4,1],[2,0,5]]
-      b.min_index             #=> 4
-      b.min_index(axis:1)     #=> [2, 4]
-      b.min_index(axis:0)     #=> [3, 4, 2]
-      b[b.min_index(axis:0)]  #=> [2, 0, 1]
- */
-static VALUE robject_min_index(int argc, VALUE* argv, VALUE self) {
-  narray_t* na;
-  VALUE idx, reduce;
-  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { Qnil, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };
-  ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 3, 1, ain, aout };
-
-  GetNArray(self, na);
-  if (na->ndim == 0) {
-    return INT2FIX(0);
-  }
-  if (na->size > (~(u_int32_t)0)) {
-    aout[0].type = numo_cInt64;
-    idx = nary_new(numo_cInt64, na->ndim, na->shape);
-    ndf.func = iter_robject_min_index_index64;
-
-    reduce =
-      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_index_index64_nan);
-
-  } else {
-    aout[0].type = numo_cInt32;
-    idx = nary_new(numo_cInt32, na->ndim, na->shape);
-    ndf.func = iter_robject_min_index_index32;
-
-    reduce =
-      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_index_index32_nan);
-  }
-  rb_funcall(idx, rb_intern("seq"), 0);
-
-  return na_ndloop(&ndf, 3, self, idx, reduce);
-}
-
-#define idx_t int64_t
-static void iter_robject_argmax_arg64(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_argmax_arg32(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-#define idx_t int64_t
-static void iter_robject_argmax_arg64_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index_nan(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_argmax_arg32_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_max_index_nan(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-/*
-  Index of the maximum value.
-  @overload argmax(axis:nil, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
-    @param [Numeric,Array,Range] axis  Finds maximum values along the axis and returns **indices
-    along the axis**.
-    @return [Integer,Numo::Int] returns the result indices.
-  @see #max_index
-  @see #max
-
-  @example
-      a = Numo::NArray[3,4,1,2]
-      a.argmax  #=> 1
-
-      b = Numo::NArray[[3,4,1],[2,0,5]]
-      b.argmax                       #=> 5
-      b.argmax(axis:1)               #=> [1, 2]
-      b.argmax(axis:0)               #=> [0, 0, 1]
-      b.at(b.argmax(axis:0), 0..-1)  #=> [3, 4, 5]
- */
-static VALUE robject_argmax(int argc, VALUE* argv, VALUE self) {
-  narray_t* na;
-  VALUE reduce;
-  ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };
-  ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout };
-
-  GetNArray(self, na);
-  if (na->ndim == 0) {
-    return INT2FIX(0);
-  }
-  if (na->size > (~(u_int32_t)0)) {
-    aout[0].type = numo_cInt64;
-    ndf.func = iter_robject_argmax_arg64;
-
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_argmax_arg64_nan);
-
-  } else {
-    aout[0].type = numo_cInt32;
-    ndf.func = iter_robject_argmax_arg32;
-
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_argmax_arg32_nan);
-  }
-
-  return na_ndloop(&ndf, 2, self, reduce);
-}
-
-#define idx_t int64_t
-static void iter_robject_argmin_arg64(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_argmin_arg32(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-#define idx_t int64_t
-static void iter_robject_argmin_arg64_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index_nan(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-#define idx_t int32_t
-static void iter_robject_argmin_arg32_nan(na_loop_t* const lp) {
-  size_t n, idx;
-  char *d_ptr, *o_ptr;
-  ssize_t d_step;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, d_ptr, d_step);
-
-  idx = f_min_index_nan(n, d_ptr, d_step);
-
-  o_ptr = NDL_PTR(lp, 1);
-  *(idx_t*)o_ptr = (idx_t)idx;
-}
-#undef idx_t
-
-/*
-  Index of the minimum value.
-  @overload argmin(axis:nil, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision if exist).
-    @param [Numeric,Array,Range] axis  Finds minimum values along the axis and returns **indices
-    along the axis**.
-    @return [Integer,Numo::Int] returns the result indices.
-  @see #min_index
-  @see #min
-
-  @example
-      a = Numo::NArray[3,4,1,2]
-      a.argmin  #=> 2
-
-      b = Numo::NArray[[3,4,1],[2,0,5]]
-      b.argmin                       #=> 4
-      b.argmin(axis:1)               #=> [2, 1]
-      b.argmin(axis:0)               #=> [1, 1, 0]
-      b.at(b.argmin(axis:0), 0..-1)  #=> [2, 0, 1]
- */
-static VALUE robject_argmin(int argc, VALUE* argv, VALUE self) {
-  narray_t* na;
-  VALUE reduce;
-  ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { 0, 0, 0 } };
-  ndfunc_t ndf = { 0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout };
-
-  GetNArray(self, na);
-  if (na->ndim == 0) {
-    return INT2FIX(0);
-  }
-  if (na->size > (~(u_int32_t)0)) {
-    aout[0].type = numo_cInt64;
-    ndf.func = iter_robject_argmin_arg64;
-
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_argmin_arg64_nan);
-
-  } else {
-    aout[0].type = numo_cInt32;
-    ndf.func = iter_robject_argmin_arg32;
-
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_argmin_arg32_nan);
-  }
-
-  return na_ndloop(&ndf, 2, self, reduce);
-}
-
-static void iter_robject_minmax(na_loop_t* const lp) {
-  size_t n;
-  char* p1;
-  ssize_t s1;
-  dtype xmin, xmax;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, p1, s1);
-
-  f_minmax(n, p1, s1, &xmin, &xmax);
-
-  *(dtype*)(lp->args[1].ptr + lp->args[1].iter[0].pos) = xmin;
-  *(dtype*)(lp->args[2].ptr + lp->args[2].iter[0].pos) = xmax;
-}
-static void iter_robject_minmax_nan(na_loop_t* const lp) {
-  size_t n;
-  char* p1;
-  ssize_t s1;
-  dtype xmin, xmax;
-
-  INIT_COUNTER(lp, n);
-  INIT_PTR(lp, 0, p1, s1);
-
-  f_minmax_nan(n, p1, s1, &xmin, &xmax);
-
-  *(dtype*)(lp->args[1].ptr + lp->args[1].iter[0].pos) = xmin;
-  *(dtype*)(lp->args[2].ptr + lp->args[2].iter[0].pos) = xmax;
-}
-
-/*
-  minmax of self.
-  @overload minmax(axis:nil, keepdims:false, nan:false)
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
-    @param [Numeric,Array,Range] axis  Finds min-max along the axis.
-    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
-    as dimensions with size one.
-    @return [Numo::RObject,Numo::RObject] min and max of self.
-*/
-static VALUE robject_minmax(int argc, VALUE* argv, VALUE self) {
-  VALUE reduce;
-  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[2] = { { cT, 0 }, { cT, 0 } };
-  ndfunc_t ndf = {
-    iter_robject_minmax, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 2, ain, aout
-  };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_minmax_nan);
-
-  return na_ndloop(&ndf, 2, self, reduce);
-}
-
-static void iter_robject_s_maximum(na_loop_t* const lp) {
-  size_t i, 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);
-
-  for (i = 0; i < n; i++) {
-    dtype x, y, z;
-    GET_DATA_STRIDE(p1, s1, dtype, x);
-    GET_DATA_STRIDE(p2, s2, dtype, y);
-    GET_DATA(p3, dtype, z);
-    z = f_maximum(x, y);
-    SET_DATA_STRIDE(p3, s3, dtype, z);
-  }
-}
-static void iter_robject_s_maximum_nan(na_loop_t* const lp) {
-  size_t i, 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);
-
-  for (i = 0; i < n; i++) {
-    dtype x, y, z;
-    GET_DATA_STRIDE(p1, s1, dtype, x);
-    GET_DATA_STRIDE(p2, s2, dtype, y);
-    GET_DATA(p3, dtype, z);
-    z = f_maximum_nan(x, y);
-    SET_DATA_STRIDE(p3, s3, dtype, z);
-  }
-}
-
-static VALUE robject_s_maximum(int argc, VALUE* argv, VALUE mod) {
-  VALUE a1 = Qnil;
-  VALUE a2 = Qnil;
-  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_robject_s_maximum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
-
-  VALUE kw_hash = Qnil;
-  ID kw_table[1] = { id_nan };
-  VALUE opts[1] = { Qundef };
-
-  rb_scan_args(argc, argv, "20:", &a1, &a2, &kw_hash);
-  rb_get_kwargs(kw_hash, kw_table, 0, 1, opts);
-  if (opts[0] != Qundef) {
-    ndf.func = iter_robject_s_maximum_nan;
-  }
-
-  return na_ndloop(&ndf, 2, a1, a2);
-}
-
-/*
-  Element-wise minimum of two arrays.
-
-  @overload minimum(a1, a2, nan:false)
-    @param [Numo::NArray,Numeric] a1  The array to be compared.
-    @param [Numo::NArray,Numeric] a2  The array to be compared.
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
-    @return [Numo::RObject]
-*/
-
-static void iter_robject_s_minimum(na_loop_t* const lp) {
-  size_t i, 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);
-
-  for (i = 0; i < n; i++) {
-    dtype x, y, z;
-    GET_DATA_STRIDE(p1, s1, dtype, x);
-    GET_DATA_STRIDE(p2, s2, dtype, y);
-    GET_DATA(p3, dtype, z);
-    z = f_minimum(x, y);
-    SET_DATA_STRIDE(p3, s3, dtype, z);
-  }
-}
-static void iter_robject_s_minimum_nan(na_loop_t* const lp) {
-  size_t i, 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);
-
-  for (i = 0; i < n; i++) {
-    dtype x, y, z;
-    GET_DATA_STRIDE(p1, s1, dtype, x);
-    GET_DATA_STRIDE(p2, s2, dtype, y);
-    GET_DATA(p3, dtype, z);
-    z = f_minimum_nan(x, y);
-    SET_DATA_STRIDE(p3, s3, dtype, z);
-  }
-}
-
-static VALUE robject_s_minimum(int argc, VALUE* argv, VALUE mod) {
-  VALUE a1 = Qnil;
-  VALUE a2 = Qnil;
-  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_robject_s_minimum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
-
-  VALUE kw_hash = Qnil;
-  ID kw_table[1] = { id_nan };
-  VALUE opts[1] = { Qundef };
-
-  rb_scan_args(argc, argv, "20:", &a1, &a2, &kw_hash);
-  rb_get_kwargs(kw_hash, kw_table, 0, 1, opts);
-  if (opts[0] != Qundef) {
-    ndf.func = iter_robject_s_minimum_nan;
-  }
-
-  return na_ndloop(&ndf, 2, a1, a2);
-}
-
-static void iter_robject_cumsum(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  dtype x, y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR(lp, 0, p1, s1);
-  INIT_PTR(lp, 1, p2, s2);
-
-  GET_DATA_STRIDE(p1, s1, dtype, x);
-  SET_DATA_STRIDE(p2, s2, dtype, x);
-  for (i--; i--;) {
-    GET_DATA_STRIDE(p1, s1, dtype, y);
-    m_cumsum(x, y);
-    SET_DATA_STRIDE(p2, s2, dtype, x);
-  }
-}
-static void iter_robject_cumsum_nan(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  dtype x, y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR(lp, 0, p1, s1);
-  INIT_PTR(lp, 1, p2, s2);
-
-  GET_DATA_STRIDE(p1, s1, dtype, x);
-  SET_DATA_STRIDE(p2, s2, dtype, x);
-  for (i--; i--;) {
-    GET_DATA_STRIDE(p1, s1, dtype, y);
-    m_cumsum_nan(x, y);
-    SET_DATA_STRIDE(p2, s2, dtype, x);
-  }
-}
-
-/*
-  cumsum of self.
-  @overload cumsum(axis:nil, nan:false)
-    @param [Numeric,Array,Range] axis  Performs cumsum along the axis.
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
-    @return [Numo::RObject] cumsum of self.
-*/
-static VALUE robject_cumsum(int argc, VALUE* argv, VALUE self) {
-  VALUE reduce;
-  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = {
-    iter_robject_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
-  };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_cumsum_nan);
-
-  return na_ndloop(&ndf, 2, self, reduce);
-}
-
-static void iter_robject_cumprod(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  dtype x, y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR(lp, 0, p1, s1);
-  INIT_PTR(lp, 1, p2, s2);
-
-  GET_DATA_STRIDE(p1, s1, dtype, x);
-  SET_DATA_STRIDE(p2, s2, dtype, x);
-  for (i--; i--;) {
-    GET_DATA_STRIDE(p1, s1, dtype, y);
-    m_cumprod(x, y);
-    SET_DATA_STRIDE(p2, s2, dtype, x);
-  }
-}
-static void iter_robject_cumprod_nan(na_loop_t* const lp) {
-  size_t i;
-  char *p1, *p2;
-  ssize_t s1, s2;
-  dtype x, y;
-
-  INIT_COUNTER(lp, i);
-  INIT_PTR(lp, 0, p1, s1);
-  INIT_PTR(lp, 1, p2, s2);
-
-  GET_DATA_STRIDE(p1, s1, dtype, x);
-  SET_DATA_STRIDE(p2, s2, dtype, x);
-  for (i--; i--;) {
-    GET_DATA_STRIDE(p1, s1, dtype, y);
-    m_cumprod_nan(x, y);
-    SET_DATA_STRIDE(p2, s2, dtype, x);
-  }
-}
-
-/*
-  cumprod of self.
-  @overload cumprod(axis:nil, nan:false)
-    @param [Numeric,Array,Range] axis  Performs cumprod along the axis.
-    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
-    @return [Numo::RObject] cumprod of self.
-*/
-static VALUE robject_cumprod(int argc, VALUE* argv, VALUE self) {
-  VALUE reduce;
-  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = {
-    iter_robject_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
-  };
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_cumprod_nan);
-
-  return na_ndloop(&ndf, 2, self, reduce);
-}
-
-//
-static void iter_robject_mulsum(na_loop_t* const lp) {
-  size_t i, 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 (s3 == 0) {
-    dtype z;
-    // Reduce loop
-    GET_DATA(p3, dtype, z);
-    for (i = 0; i < n; i++) {
-      dtype x, y;
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      GET_DATA_STRIDE(p2, s2, dtype, y);
-      m_mulsum(x, y, z);
-    }
-    SET_DATA(p3, dtype, z);
-    return;
-  } else {
-    for (i = 0; i < n; i++) {
-      dtype x, y, z;
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      GET_DATA_STRIDE(p2, s2, dtype, y);
-      GET_DATA(p3, dtype, z);
-      m_mulsum(x, y, z);
-      SET_DATA_STRIDE(p3, s3, dtype, z);
-    }
-  }
-}
-//
-static void iter_robject_mulsum_nan(na_loop_t* const lp) {
-  size_t i, 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 (s3 == 0) {
-    dtype z;
-    // Reduce loop
-    GET_DATA(p3, dtype, z);
-    for (i = 0; i < n; i++) {
-      dtype x, y;
-      GET_DATA_STRIDE(p1, s1, dtype, x);
-      GET_DATA_STRIDE(p2, s2, dtype, y);
-      m_mulsum_nan(x, y, z);
+  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_isnan(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
-    SET_DATA(p3, dtype, z);
-    return;
   } else {
-    for (i = 0; i < n; i++) {
-      dtype x, y, z;
+    for (; i--;) {
       GET_DATA_STRIDE(p1, s1, dtype, x);
-      GET_DATA_STRIDE(p2, s2, dtype, y);
-      GET_DATA(p3, dtype, z);
-      m_mulsum_nan(x, y, z);
-      SET_DATA_STRIDE(p3, s3, dtype, z);
+      b = (m_isnan(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   }
 }
-//
-
-static VALUE robject_mulsum_self(int argc, VALUE* argv, VALUE self) {
-  VALUE v, reduce;
-  VALUE naryv[2];
-  ndfunc_arg_in_t ain[4] = { { cT, 0 }, { cT, 0 }, { sym_reduce, 0 }, { sym_init, 0 } };
-  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
-  ndfunc_t ndf = { iter_robject_mulsum, STRIDE_LOOP_NIP, 4, 1, ain, aout };
-
-  if (argc < 1) {
-    rb_raise(rb_eArgError, "wrong number of arguments (%d for >=1)", argc);
-  }
-  // should fix below: [self.ndim,other.ndim].max or?
-  naryv[0] = self;
-  naryv[1] = argv[0];
-  //
-  reduce = na_reduce_dimension(argc - 1, argv + 1, 2, naryv, &ndf, iter_robject_mulsum_nan);
-  //
-
-  v = na_ndloop(&ndf, 4, self, argv[0], reduce, m_mulsum_init);
-  return robject_extract(v);
-}
 
 /*
-  Binary mulsum.
-
-  @overload mulsum(other, axis:nil, keepdims:false, nan:false)
-    @param [Numo::NArray,Numeric] other
-    @param [Numeric,Array,Range] axis  Performs mulsum along the axis.
-    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
-    as dimensions with size one.
-    @param [TrueClass] nan (keyword) If true, apply NaN-aware algorithm (avoid NaN if exists).
-    @return [Numo::NArray] mulsum of self and other.
+  Condition of isnan.
+  @overload isnan
+    @return [Numo::Bit] Condition of isnan.
 */
-static VALUE robject_mulsum(int argc, VALUE* argv, VALUE self) {
-  //
-  if (argc < 1) {
-    rb_raise(rb_eArgError, "wrong number of arguments (%d for >=1)", argc);
-  }
-  //
-  return robject_mulsum_self(argc, argv, self);
-  //
-}
-
-typedef dtype seq_data_t;
-
-typedef size_t seq_count_t;
+static VALUE robject_isnan(VALUE self) {
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isnan, FULL_LOOP, 1, 1, ain, aout };
 
-typedef struct {
-  seq_data_t beg;
-  seq_data_t step;
-  seq_count_t count;
-} seq_opt_t;
+  return na_ndloop(&ndf, 1, self);
+}
 
-static void iter_robject_seq(na_loop_t* const lp) {
+static void iter_robject_isinf(na_loop_t* const lp) {
   size_t i;
   char* p1;
-  ssize_t s1;
+  BIT_DIGIT* a2;
+  size_t p2;
+  ssize_t s1, s2;
   size_t* idx1;
   dtype x;
-  seq_data_t beg, step;
-  seq_count_t c;
-  seq_opt_t* g;
-
+  BIT_DIGIT b;
   INIT_COUNTER(lp, i);
   INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  g = (seq_opt_t*)(lp->opt_ptr);
-  beg = g->beg;
-  step = g->step;
-  c = g->count;
+  INIT_PTR_BIT(lp, 1, a2, p2, s2);
   if (idx1) {
     for (; i--;) {
-      x = f_seq(beg, step, c++);
-      *(dtype*)(p1 + *idx1) = x;
-      idx1++;
+      GET_DATA_INDEX(p1, idx1, dtype, x);
+      b = (m_isinf(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   } else {
     for (; i--;) {
-      x = f_seq(beg, step, c++);
-      *(dtype*)(p1) = x;
-      p1 += s1;
+      GET_DATA_STRIDE(p1, s1, dtype, x);
+      b = (m_isinf(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   }
-  g->count = c;
 }
 
 /*
-  Set linear sequence of numbers to self. The sequence is obtained from
-     beg+i*step
-  where i is 1-dimensional index.
-  @overload seq([beg,[step]])
-    @param [Numeric] beg  beginning of sequence. (default=0)
-    @param [Numeric] step  step of sequence. (default=1)
-    @return [Numo::RObject] self.
-  @example
-    Numo::DFloat.new(6).seq(1,-0.2)
-    # => Numo::DFloat#shape=[6]
-    # [1, 0.8, 0.6, 0.4, 0.2, 0]
-
-    Numo::DComplex.new(6).seq(1,-0.2+0.2i)
-    # => Numo::DComplex#shape=[6]
-    # [1+0i, 0.8+0.2i, 0.6+0.4i, 0.4+0.6i, 0.2+0.8i, 0+1i]
+  Condition of isinf.
+  @overload isinf
+    @return [Numo::Bit] Condition of isinf.
 */
-static VALUE robject_seq(int argc, VALUE* argv, VALUE self) {
-  seq_opt_t* g;
-  VALUE vbeg = Qnil, vstep = Qnil;
-  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
-  ndfunc_t ndf = { iter_robject_seq, FULL_LOOP, 1, 0, ain, 0 };
-
-  g = ALLOCA_N(seq_opt_t, 1);
-  g->beg = m_zero;
-  g->step = m_one;
-  g->count = 0;
-  rb_scan_args(argc, argv, "02", &vbeg, &vstep);
-  if (vbeg != Qnil) {
-    g->beg = m_num_to_data(vbeg);
-  }
-  if (vstep != Qnil) {
-    g->step = m_num_to_data(vstep);
-  }
+static VALUE robject_isinf(VALUE self) {
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isinf, FULL_LOOP, 1, 1, ain, aout };
 
-  na_ndloop3(&ndf, g, 1, self);
-  return self;
+  return na_ndloop(&ndf, 1, self);
 }
 
-typedef struct {
-  seq_data_t beg;
-  seq_data_t step;
-  seq_data_t base;
-  seq_count_t count;
-} logseq_opt_t;
-
-static void iter_robject_logseq(na_loop_t* const lp) {
+static void iter_robject_isposinf(na_loop_t* const lp) {
   size_t i;
   char* p1;
-  ssize_t s1;
+  BIT_DIGIT* a2;
+  size_t p2;
+  ssize_t s1, s2;
   size_t* idx1;
   dtype x;
-  seq_data_t beg, step, base;
-  seq_count_t c;
-  logseq_opt_t* g;
-
+  BIT_DIGIT b;
   INIT_COUNTER(lp, i);
   INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  g = (logseq_opt_t*)(lp->opt_ptr);
-  beg = g->beg;
-  step = g->step;
-  base = g->base;
-  c = g->count;
+  INIT_PTR_BIT(lp, 1, a2, p2, s2);
   if (idx1) {
     for (; i--;) {
-      x = f_seq(beg, step, c++);
-      *(dtype*)(p1 + *idx1) = m_pow(base, x);
-      idx1++;
+      GET_DATA_INDEX(p1, idx1, dtype, x);
+      b = (m_isposinf(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   } else {
     for (; i--;) {
-      x = f_seq(beg, step, c++);
-      *(dtype*)(p1) = m_pow(base, x);
-      p1 += s1;
+      GET_DATA_STRIDE(p1, s1, dtype, x);
+      b = (m_isposinf(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   }
-  g->count = c;
 }
 
 /*
-  Set logarithmic sequence of numbers to self. The sequence is obtained from
-     `base**(beg+i*step)`
-  where i is 1-dimensional index.
-  Applicable classes: DFloat, SFloat, DComplex, SCopmplex.
-
-  @overload logseq(beg,step,[base])
-    @param [Numeric] beg  The beginning of sequence.
-    @param [Numeric] step  The step of sequence.
-    @param [Numeric] base  The base of log space. (default=10)
-    @return [Numo::RObject] self.
-
-  @example
-    Numo::DFloat.new(5).logseq(4,-1,2)
-    # => Numo::DFloat#shape=[5]
-    # [16, 8, 4, 2, 1]
-
-    Numo::DComplex.new(5).logseq(0,1i*Math::PI/3,Math::E)
-    # => Numo::DComplex#shape=[5]
-    # [1+7.26156e-310i, 0.5+0.866025i, -0.5+0.866025i, -1+1.22465e-16i, ...]
+  Condition of isposinf.
+  @overload isposinf
+    @return [Numo::Bit] Condition of isposinf.
 */
-static VALUE robject_logseq(int argc, VALUE* argv, VALUE self) {
-  logseq_opt_t* g;
-  VALUE vbeg, vstep, vbase;
-  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
-  ndfunc_t ndf = { iter_robject_logseq, FULL_LOOP, 1, 0, ain, 0 };
-
-  g = ALLOCA_N(logseq_opt_t, 1);
-  rb_scan_args(argc, argv, "21", &vbeg, &vstep, &vbase);
-  g->beg = m_num_to_data(vbeg);
-  g->step = m_num_to_data(vstep);
-  if (vbase == Qnil) {
-    g->base = m_from_real(10);
-  } else {
-    g->base = m_num_to_data(vbase);
-  }
-  na_ndloop3(&ndf, g, 1, self);
-  return self;
-}
+static VALUE robject_isposinf(VALUE self) {
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isposinf, FULL_LOOP, 1, 1, ain, aout };
 
-static void iter_robject_eye(na_loop_t* const lp) {
-  size_t n0, n1;
-  size_t i0, i1;
-  ssize_t s0, s1;
-  char *p0, *p1;
-  char* g;
-  ssize_t kofs;
-  dtype data;
-
-  g = (char*)(lp->opt_ptr);
-  kofs = *(ssize_t*)g;
-  data = *(dtype*)(g + sizeof(ssize_t));
-
-  n0 = lp->args[0].shape[0];
-  n1 = lp->args[0].shape[1];
-  s0 = lp->args[0].iter[0].step;
-  s1 = lp->args[0].iter[1].step;
-  p0 = NDL_PTR(lp, 0);
-
-  for (i0 = 0; i0 < n0; i0++) {
-    p1 = p0;
-    for (i1 = 0; i1 < n1; i1++) {
-      *(dtype*)p1 = (i0 + kofs == i1) ? data : m_zero;
-      p1 += s1;
-    }
-    p0 += s0;
-  }
+  return na_ndloop(&ndf, 1, self);
 }
 
-/*
-  Eye: Set a value to diagonal components, set 0 to non-diagonal components.
-  @overload eye([element,offset])
-    @param [Numeric] element  Diagonal element to be stored. Default is 1.
-    @param [Integer] offset Diagonal offset from the main diagonal.  The
-        default is 0. k>0 for diagonals above the main diagonal, and k<0
-        for diagonals below the main diagonal.
-    @return [Numo::RObject] eye of self.
-*/
-static VALUE robject_eye(int argc, VALUE* argv, VALUE self) {
-  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
-  ndfunc_t ndf = { iter_robject_eye, NO_LOOP, 1, 0, ain, 0 };
-  ssize_t kofs;
-  dtype data;
-  char* g;
-  int nd;
-  narray_t* na;
-
-  // check arguments
-  if (argc > 2) {
-    rb_raise(rb_eArgError, "too many arguments (%d for 0..2)", argc);
-  } else if (argc == 2) {
-    data = m_num_to_data(argv[0]);
-    kofs = NUM2SSIZET(argv[1]);
-  } else if (argc == 1) {
-    data = m_num_to_data(argv[0]);
-    kofs = 0;
-  } else {
-    data = m_one;
-    kofs = 0;
-  }
-
-  GetNArray(self, na);
-  nd = na->ndim;
-  if (nd < 2) {
-    rb_raise(nary_eDimensionError, "less than 2-d array");
-  }
-
-  // Diagonal offset from the main diagonal.
-  if (kofs >= 0) {
-    if ((size_t)(kofs) >= na->shape[nd - 1]) {
-      rb_raise(
-        rb_eArgError,
-        "invalid diagonal offset(%" SZF "d) for "
-        "last dimension size(%" SZF "d)",
-        kofs, na->shape[nd - 1]
-      );
+static void iter_robject_isneginf(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_isneginf(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   } else {
-    if ((size_t)(-kofs) >= na->shape[nd - 2]) {
-      rb_raise(
-        rb_eArgError,
-        "invalid diagonal offset(%" SZF "d) for "
-        "last-1 dimension size(%" SZF "d)",
-        kofs, na->shape[nd - 2]
-      );
+    for (; i--;) {
+      GET_DATA_STRIDE(p1, s1, dtype, x);
+      b = (m_isneginf(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   }
+}
 
-  g = ALLOCA_N(char, sizeof(ssize_t) + sizeof(dtype));
-  *(ssize_t*)g = kofs;
-  *(dtype*)(g + sizeof(ssize_t)) = data;
+/*
+  Condition of isneginf.
+  @overload isneginf
+    @return [Numo::Bit] Condition of isneginf.
+*/
+static VALUE robject_isneginf(VALUE self) {
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isneginf, FULL_LOOP, 1, 1, ain, aout };
 
-  na_ndloop3(&ndf, g, 1, self);
-  return self;
+  return na_ndloop(&ndf, 1, self);
 }
 
-typedef struct {
-  dtype low;
-  dtype max;
-} rand_opt_t;
-
-static void iter_robject_rand(na_loop_t* const lp) {
+static void iter_robject_isfinite(na_loop_t* const lp) {
   size_t i;
   char* p1;
-  ssize_t s1;
+  BIT_DIGIT* a2;
+  size_t p2;
+  ssize_t s1, s2;
   size_t* idx1;
   dtype x;
-  rand_opt_t* g;
-  dtype low;
-  dtype max;
-
+  BIT_DIGIT b;
   INIT_COUNTER(lp, i);
   INIT_PTR_IDX(lp, 0, p1, s1, idx1);
-  g = (rand_opt_t*)(lp->opt_ptr);
-  low = g->low;
-  max = g->max;
-
+  INIT_PTR_BIT(lp, 1, a2, p2, s2);
   if (idx1) {
     for (; i--;) {
-      x = m_add(m_rand(max), low);
-      SET_DATA_INDEX(p1, idx1, dtype, x);
+      GET_DATA_INDEX(p1, idx1, dtype, x);
+      b = (m_isfinite(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   } else {
     for (; i--;) {
-      x = m_add(m_rand(max), low);
-      SET_DATA_STRIDE(p1, s1, dtype, x);
+      GET_DATA_STRIDE(p1, s1, dtype, x);
+      b = (m_isfinite(x)) ? 1 : 0;
+      STORE_BIT(a2, p2, b);
+      p2 += s2;
     }
   }
 }
 
 /*
-  Generate uniformly distributed random numbers on self narray.
-  @overload rand([[low],high])
-    @param [Numeric] low  lower inclusive boundary of random numbers. (default=0)
-    @param [Numeric] high  upper exclusive boundary of random numbers. (default=1 or 1+1i for
-    complex types)
-    @return [Numo::RObject] self.
-  @example
-    Numo::DFloat.new(6).rand
-    # => Numo::DFloat#shape=[6]
-    # [0.0617545, 0.373067, 0.794815, 0.201042, 0.116041, 0.344032]
-
-    Numo::DComplex.new(6).rand(5+5i)
-    # => Numo::DComplex#shape=[6]
-    # [2.69974+3.68908i, 0.825443+0.254414i, 0.540323+0.34354i, 4.52061+2.39322i, ...]
-
-    Numo::Int32.new(6).rand(2,5)
-    # => Numo::Int32#shape=[6]
-    # [4, 3, 3, 2, 4, 2]
+  Condition of isfinite.
+  @overload isfinite
+    @return [Numo::Bit] Condition of isfinite.
 */
-static VALUE robject_rand(int argc, VALUE* argv, VALUE self) {
-  rand_opt_t g;
-  VALUE v1 = Qnil, v2 = Qnil;
-  dtype high;
-  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
-  ndfunc_t ndf = { iter_robject_rand, FULL_LOOP, 1, 0, ain, 0 };
-
-  rb_scan_args(argc, argv, "02", &v1, &v2);
-  if (v2 == Qnil) {
-    g.low = m_zero;
-    if (v1 == Qnil) {
-
-      g.max = high = m_one;
-
-    } else {
-      g.max = high = m_num_to_data(v1);
-    }
-
-  } else {
-    g.low = m_num_to_data(v1);
-    high = m_num_to_data(v2);
-    g.max = m_sub(high, g.low);
-  }
+static VALUE robject_isfinite(VALUE self) {
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isfinite, FULL_LOOP, 1, 1, ain, aout };
 
-  na_ndloop3(&ndf, &g, 1, self);
-  return self;
+  return na_ndloop(&ndf, 1, self);
 }
 
 static void iter_robject_poly(na_loop_t* const lp) {
@@ -5376,13 +3863,63 @@ void Init_numo_robject(void) {
   rb_define_alias(cT, ">=", "ge");
   rb_define_alias(cT, "<", "lt");
   rb_define_alias(cT, "<=", "le");
+  /**
+   * Clip array elements by [min,max].
+   * If either of min or max is nil, one side is clipped.
+   * @overload clip(min,max)
+   *   @param [Numo::NArray,Numeric] min
+   *   @param [Numo::NArray,Numeric] max
+   *   @return [Numo::NArray] result of clip.
+   *
+   * @example
+   *     a = Numo::Int32.new(10).seq
+   *     # => Numo::Int32#shape=[10]
+   *     # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+   *
+   *     a.clip(1,8)
+   *     # => Numo::Int32#shape=[10]
+   *     # [1, 1, 2, 3, 4, 5, 6, 7, 8, 8]
+   *
+   *     a.inplace.clip(3,6)
+   *     a
+   *     # => Numo::Int32#shape=[10]
+   *     # [3, 3, 3, 3, 4, 5, 6, 6, 6, 6]
+   *
+   *     b = Numo::Int32.new(10).seq
+   *     # => Numo::Int32#shape=[10]
+   *     # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+   *
+   *     b.clip([3,4,1,1,1,4,4,4,4,4], 8)
+   *     # => Numo::Int32#shape=[10]
+   *     # [3, 4, 2, 3, 4, 5, 6, 7, 8, 8]
+   */
   rb_define_method(cT, "clip", robject_clip, 2);
   rb_define_method(cT, "isnan", robject_isnan, 0);
   rb_define_method(cT, "isinf", robject_isinf, 0);
   rb_define_method(cT, "isposinf", robject_isposinf, 0);
   rb_define_method(cT, "isneginf", robject_isneginf, 0);
   rb_define_method(cT, "isfinite", robject_isfinite, 0);
+  /**
+   * sum of self.
+   * @overload sum(axis:nil, keepdims:false, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @param [Numeric,Array,Range] axis  Performs sum along the axis.
+   *   @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::RObject] returns result of sum.
+   */
   rb_define_method(cT, "sum", robject_sum, -1);
+  /**
+   * prod of self.
+   * @overload prod(axis:nil, keepdims:false, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @param [Numeric,Array,Range] axis  Performs prod along the axis.
+   *   @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::RObject] returns result of prod.
+   */
   rb_define_method(cT, "prod", robject_prod, -1);
   /**
    * mean of self.
@@ -5428,13 +3965,135 @@ void Init_numo_robject(void) {
    *   @return [Numo::RObject] returns result of rms.
    */
   rb_define_method(cT, "rms", robject_rms, -1);
+  /**
+   * min of self.
+   * @overload min(axis:nil, keepdims:false, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @param [Numeric,Array,Range] axis  Performs min along the axis.
+   *   @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::RObject] returns result of min.
+   */
   rb_define_method(cT, "min", robject_min, -1);
+  /**
+   * max of self.
+   * @overload max(axis:nil, keepdims:false, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @param [Numeric,Array,Range] axis  Performs max along the axis.
+   *   @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::RObject] returns result of max.
+   */
   rb_define_method(cT, "max", robject_max, -1);
+  /**
+   * ptp of self.
+   * @overload ptp(axis:nil, keepdims:false, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @param [Numeric,Array,Range] axis  Performs ptp along the axis.
+   *   @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::RObject] returns result of ptp.
+   */
   rb_define_method(cT, "ptp", robject_ptp, -1);
+  /**
+   * Index of the maximum value.
+   * @overload max_index(axis:nil, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm (return
+   *     NaN posision if exist).
+   *   @param [Numeric,Array,Range] axis  Finds maximum values along the axis and
+   *     returns **flat 1-d indices**.
+   *   @return [Integer,Numo::Int] returns result indices.
+   * @see #argmax
+   * @see #max
+   *
+   * @example
+   *     a = Numo::NArray[3,4,1,2]
+   *     a.max_index  #=> 1
+   *
+   *     b = Numo::NArray[[3,4,1],[2,0,5]]
+   *     b.max_index             #=> 5
+   *     b.max_index(axis:1)     #=> [1, 5]
+   *     b.max_index(axis:0)     #=> [0, 1, 5]
+   *     b[b.max_index(axis:0)]  #=> [3, 4, 5]
+   */
   rb_define_method(cT, "max_index", robject_max_index, -1);
+  /**
+   * Index of the minimum value.
+   * @overload min_index(axis:nil, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm (returnNaN posision if exist).
+   *   @param [Numeric,Array,Range] axis  Finds minimum values along the axis and
+   *     returns **flat 1-d indices**.
+   *   @return [Integer,Numo::Int] returns result indices.
+   * @see #argmin
+   * @see #min
+   *
+   * @example
+   *     a = Numo::NArray[3,4,1,2]
+   *     a.min_index  #=> 2
+   *
+   *     b = Numo::NArray[[3,4,1],[2,0,5]]
+   *     b.min_index             #=> 4
+   *     b.min_index(axis:1)     #=> [2, 4]
+   *     b.min_index(axis:0)     #=> [3, 4, 2]
+   *     b[b.min_index(axis:0)]  #=> [2, 0, 1]
+   */
   rb_define_method(cT, "min_index", robject_min_index, -1);
+  /**
+   * Index of the maximum value.
+   * @overload argmax(axis:nil, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN posision
+   *     if exist).
+   *   @param [Numeric,Array,Range] axis  Finds maximum values along the axis and
+   *     returns **indices along the axis**.
+   *   @return [Integer,Numo::Int] returns the result indices.
+   * @see #max_index
+   * @see #max
+   *
+   * @example
+   *     a = Numo::NArray[3,4,1,2]
+   *     a.argmax  #=> 1
+   *
+   *     b = Numo::NArray[[3,4,1],[2,0,5]]
+   *     b.argmax                       #=> 5
+   *     b.argmax(axis:1)               #=> [1, 2]
+   *     b.argmax(axis:0)               #=> [0, 0, 1]
+   *     b.at(b.argmax(axis:0), 0..-1)  #=> [3, 4, 5]
+   */
   rb_define_method(cT, "argmax", robject_argmax, -1);
+  /**
+   * Index of the minimum value.
+   * @overload argmin(axis:nil, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm (return
+   *     NaN posision if exist).
+   *   @param [Numeric,Array,Range] axis  Finds minimum values along the axis and
+   *     returns **indices along the axis**.
+   *   @return [Integer,Numo::Int] returns the result indices.
+   * @see #min_index
+   * @see #min
+   *
+   * @example
+   *     a = Numo::NArray[3,4,1,2]
+   *     a.argmin  #=> 2
+   *
+   *     b = Numo::NArray[[3,4,1],[2,0,5]]
+   *     b.argmin                       #=> 4
+   *     b.argmin(axis:1)               #=> [2, 1]
+   *     b.argmin(axis:0)               #=> [1, 1, 0]
+   *     b.at(b.argmin(axis:0), 0..-1)  #=> [2, 0, 1]
+   */
   rb_define_method(cT, "argmin", robject_argmin, -1);
+  /**
+   * minmax of self.
+   * @overload minmax(axis:nil, keepdims:false, nan:false)
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+   *   @param [Numeric,Array,Range] axis  Finds min-max along the axis.
+   *   @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in
+   *     the result array as dimensions with size one.
+   *   @return [Numo::RObject,Numo::RObject] min and max of self.
+   */
   rb_define_method(cT, "minmax", robject_minmax, -1);
   /**
    * Element-wise maximum of two arrays.
@@ -5454,13 +4113,106 @@ void Init_numo_robject(void) {
    *   @return [Numo::RObject]
    */
   rb_define_module_function(cT, "minimum", robject_s_minimum, -1);
+  /**
+   * cumsum of self.
+   * @overload cumsum(axis:nil, nan:false)
+   *   @param [Numeric,Array,Range] axis  Performs cumsum along the axis.
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
+   *   @return [Numo::RObject] cumsum of self.
+   */
   rb_define_method(cT, "cumsum", robject_cumsum, -1);
+  /**
+   * cumprod of self.
+   * @overload cumprod(axis:nil, nan:false)
+   *   @param [Numeric,Array,Range] axis  Performs cumprod along the axis.
+   *   @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
+   *   @return [Numo::RObject] cumprod of self.
+   */
   rb_define_method(cT, "cumprod", robject_cumprod, -1);
+  /**
+   * Binary mulsum.
+   *
+   * @overload mulsum(other, axis:nil, keepdims:false, nan:false)
+   *   @param [Numo::NArray,Numeric] other
+   *   @param [Numeric,Array,Range] axis  Performs mulsum along the axis.
+   *   @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in
+   *     the result array as dimensions with size one.
+   *   @param [TrueClass] nan (keyword) If true, apply NaN-aware algorithm
+   *     (avoid NaN if exists).
+   *   @return [Numo::NArray] mulsum of self and other.
+   */
   rb_define_method(cT, "mulsum", robject_mulsum, -1);
+  /**
+   * Set linear sequence of numbers to self. The sequence is obtained from
+   *    beg+i*step
+   * where i is 1-dimensional index.
+   * @overload seq([beg,[step]])
+   *   @param [Numeric] beg  beginning of sequence. (default=0)
+   *   @param [Numeric] step  step of sequence. (default=1)
+   *   @return [Numo::RObject] self.
+   * @example
+   *   Numo::DFloat.new(6).seq(1,-0.2)
+   *   # => Numo::DFloat#shape=[6]
+   *   # [1, 0.8, 0.6, 0.4, 0.2, 0]
+   *
+   *   Numo::DComplex.new(6).seq(1,-0.2+0.2i)
+   *   # => Numo::DComplex#shape=[6]
+   *   # [1+0i, 0.8+0.2i, 0.6+0.4i, 0.4+0.6i, 0.2+0.8i, 0+1i]
+   */
   rb_define_method(cT, "seq", robject_seq, -1);
+  /**
+   * Set logarithmic sequence of numbers to self. The sequence is obtained from
+   *    `base**(beg+i*step)`
+   * where i is 1-dimensional index.
+   * Applicable classes: DFloat, SFloat, DComplex, SCopmplex.
+   *
+   * @overload logseq(beg,step,[base])
+   *   @param [Numeric] beg  The beginning of sequence.
+   *   @param [Numeric] step  The step of sequence.
+   *   @param [Numeric] base  The base of log space. (default=10)
+   *   @return [Numo::RObject] self.
+   *
+   * @example
+   *   Numo::DFloat.new(5).logseq(4,-1,2)
+   *   # => Numo::DFloat#shape=[5]
+   *   # [16, 8, 4, 2, 1]
+   *
+   *   Numo::DComplex.new(5).logseq(0,1i*Math::PI/3,Math::E)
+   *   # => Numo::DComplex#shape=[5]
+   *   # [1+7.26156e-310i, 0.5+0.866025i, -0.5+0.866025i, -1+1.22465e-16i, ...]
+   */
   rb_define_method(cT, "logseq", robject_logseq, -1);
+  /**
+   * Eye: Set a value to diagonal components, set 0 to non-diagonal components.
+   * @overload eye([element,offset])
+   *   @param [Numeric] element  Diagonal element to be stored. Default is 1.
+   *   @param [Integer] offset Diagonal offset from the main diagonal.  The
+   *       default is 0. k>0 for diagonals above the main diagonal, and k<0
+   *       for diagonals below the main diagonal.
+   *   @return [Numo::RObject] eye of self.
+   */
   rb_define_method(cT, "eye", robject_eye, -1);
   rb_define_alias(cT, "indgen", "seq");
+  /**
+   * Generate uniformly distributed random numbers on self narray.
+   * @overload rand([[low],high])
+   *   @param [Numeric] low  lower inclusive boundary of random numbers. (default=0)
+   *   @param [Numeric] high  upper exclusive boundary of random numbers.
+   *     (default=1 or 1+1i for complex types)
+   *   @return [Numo::RObject] self.
+   * @example
+   *   Numo::DFloat.new(6).rand
+   *   # => Numo::DFloat#shape=[6]
+   *   # [0.0617545, 0.373067, 0.794815, 0.201042, 0.116041, 0.344032]
+   *
+   *   Numo::DComplex.new(6).rand(5+5i)
+   *   # => Numo::DComplex#shape=[6]
+   *   # [2.69974+3.68908i, 0.825443+0.254414i, 0.540323+0.34354i, 4.52061+2.39322i, ...]
+   *
+   *   Numo::Int32.new(6).rand(2,5)
+   *   # => Numo::Int32#shape=[6]
+   *   # [4, 3, 3, 2, 4, 2]
+   */
   rb_define_method(cT, "rand", robject_rand, -1);
   rb_define_method(cT, "poly", robject_poly, -2);
   rb_define_singleton_method(cT, "[]", robject_s_cast, -2);