numo-narray-alt 0.9.4 → 0.9.6

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

@@ -36,14 +36,23 @@ static ID id_to_a;
 
 #include <numo/types/dfloat.h>
 
-VALUE cT;
-extern VALUE cRT;
-
 /*
   class definition: Numo::DFloat
 */
-
 VALUE cT;
+extern VALUE cRT;
+
+#include "mh/mean.h"
+#include "mh/var.h"
+#include "mh/stddev.h"
+#include "mh/rms.h"
+
+typedef double dfloat; // Type aliases for shorter notation
+                       // following the codebase naming convention.
+DEF_NARRAY_FLT_MEAN_METHOD_FUNC(dfloat, double, numo_cDFloat, numo_cDFloat)
+DEF_NARRAY_FLT_VAR_METHOD_FUNC(dfloat, double, numo_cDFloat, numo_cDFloat)
+DEF_NARRAY_FLT_STDDEV_METHOD_FUNC(dfloat, double, numo_cDFloat, numo_cDFloat)
+DEF_NARRAY_FLT_RMS_METHOD_FUNC(dfloat, double, numo_cDFloat, numo_cDFloat)
 
 static VALUE dfloat_store(VALUE, VALUE);
 
@@ -148,13 +157,6 @@ static VALUE dfloat_allocate(VALUE self) {
   return self;
 }
 
-/*
-  Extract an element only if self is a dimensionless NArray.
-  @overload extract
-  @return [Numeric,Numo::NArray]
-  --- Extract element value as Ruby Object if self is a dimensionless NArray,
-  otherwise returns self.
-*/
 static VALUE dfloat_extract(VALUE self) {
   volatile VALUE v;
   char* ptr;
@@ -237,8 +239,8 @@ static void iter_dfloat_store_bit(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -286,8 +288,8 @@ static void iter_dfloat_store_dfloat(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -335,8 +337,8 @@ static void iter_dfloat_store_sfloat(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -384,8 +386,8 @@ static void iter_dfloat_store_int64(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -433,8 +435,8 @@ static void iter_dfloat_store_int32(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -482,8 +484,8 @@ static void iter_dfloat_store_int16(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -531,8 +533,8 @@ static void iter_dfloat_store_int8(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -580,8 +582,8 @@ static void iter_dfloat_store_uint64(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -629,8 +631,8 @@ static void iter_dfloat_store_uint32(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -678,8 +680,8 @@ static void iter_dfloat_store_uint16(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -727,8 +729,8 @@ static void iter_dfloat_store_uint8(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -776,8 +778,8 @@ static void iter_dfloat_store_robject(na_loop_t* const lp) {
 }
 
 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};
+  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;
@@ -885,19 +887,13 @@ loop_end:
 }
 
 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};
+  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;
 }
 
-/*
-  Store elements to Numo::DFloat from other.
-  @overload store(other)
-  @param [Object] other
-  @return [Numo::DFloat] self
-*/
 static VALUE dfloat_store(VALUE self, VALUE obj) {
   VALUE r, klass;
 
@@ -981,8 +977,10 @@ static VALUE dfloat_store(VALUE self, VALUE obj) {
     }
   }
 
-  rb_raise(nary_eCastError, "unknown conversion from %s to %s", rb_class2name(rb_obj_class(obj)),
-           rb_class2name(rb_obj_class(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;
 }
@@ -1076,7 +1074,10 @@ static dtype dfloat_extract_data(VALUE obj) {
       return dfloat_extract_data(r);
     }
 
-    rb_raise(nary_eCastError, "unknown conversion from %s to %s", rb_class2name(rb_obj_class(obj)), rb_class2name(cT));
+    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) {
@@ -1099,14 +1100,6 @@ static VALUE dfloat_cast_array(VALUE rary) {
   return nary;
 }
 
-/*
-  Cast object to Numo::DFloat.
-  @overload [](elements)
-  @overload cast(array)
-  @param [Numeric,Array] elements
-  @param [Array] array
-  @return [Numo::DFloat]
-*/
 static VALUE dfloat_s_cast(VALUE type, VALUE obj) {
   VALUE v;
   narray_t* na;
@@ -1142,15 +1135,6 @@ static VALUE dfloat_s_cast(VALUE type, VALUE obj) {
   return Qnil;
 }
 
-/*
-  Multi-dimensional element reference.
-  @overload [](dim0,...,dimL)
-  @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,Symbol] dim0,...,dimL  multi-dimensional
-  indices.
-  @return [Numeric,Numo::DFloat] an element or NArray view.
-  @see Numo::NArray#[]
-  @see #[]=
- */
 static VALUE dfloat_aref(int argc, VALUE* argv, VALUE self) {
   int nd;
   size_t pos;
@@ -1165,16 +1149,6 @@ static VALUE dfloat_aref(int argc, VALUE* argv, VALUE self) {
   }
 }
 
-/*
-  Multi-dimensional element assignment.
-  @overload []=(dim0,...,dimL,val)
-  @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,Symbol] dim0,...,dimL  multi-dimensional
-  indices.
-  @param [Numeric,Numo::NArray,Array] val  Value(s) to be set to self.
-  @return [Numeric,Numo::NArray,Array] returns `val` (last argument).
-  @see Numo::NArray#[]=
-  @see #[]
-*/
 static VALUE dfloat_aset(int argc, VALUE* argv, VALUE self) {
   int nd;
   size_t pos;
@@ -1199,11 +1173,6 @@ static VALUE dfloat_aset(int argc, VALUE* argv, VALUE self) {
   return argv[argc];
 }
 
-/*
-  return NArray with cast to the type of self.
-  @overload coerce_cast(type)
-  @return [nil]
-*/
 static VALUE dfloat_coerce_cast(VALUE self, VALUE type) {
   return Qnil;
 }
@@ -1234,15 +1203,10 @@ static void iter_dfloat_to_a(na_loop_t* const lp) {
   }
 }
 
-/*
-  Convert self to Array.
-  @overload to_a
-  @return [Array]
-*/
 static VALUE dfloat_to_a(VALUE self) {
-  ndfunc_arg_in_t ain[3] = {{Qnil, 0}, {sym_loop_opt}, {sym_option}};
-  ndfunc_arg_out_t aout[1] = {{rb_cArray, 0}}; // dummy?
-  ndfunc_t ndf = {iter_dfloat_to_a, FULL_LOOP_NIP, 3, 1, ain, aout};
+  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };
+  ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } }; // dummy?
+  ndfunc_t ndf = { iter_dfloat_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
   return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
 }
 
@@ -1267,15 +1231,9 @@ static void iter_dfloat_fill(na_loop_t* const lp) {
   }
 }
 
-/*
-  Fill elements with other.
-  @overload fill other
-  @param [Numeric] other
-  @return [Numo::DFloat] self.
-*/
 static VALUE dfloat_fill(VALUE self, VALUE val) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {sym_option}};
-  ndfunc_t ndf = {iter_dfloat_fill, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };
+  ndfunc_t ndf = { iter_dfloat_fill, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, val);
   return self;
@@ -1321,18 +1279,12 @@ static void iter_dfloat_format(na_loop_t* const lp) {
   }
 }
 
-/*
-  Format elements into strings.
-  @overload format format
-  @param [String] format
-  @return [Numo::RObject] array of formatted strings.
-*/
 static VALUE dfloat_format(int argc, VALUE* argv, VALUE self) {
   VALUE fmt = Qnil;
 
-  ndfunc_arg_in_t ain[2] = {{Qnil, 0}, {sym_option}};
-  ndfunc_arg_out_t aout[1] = {{numo_cRObject, 0}};
-  ndfunc_t ndf = {iter_dfloat_format, FULL_LOOP_NIP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_option } };
+  ndfunc_arg_out_t aout[1] = { { numo_cRObject, 0 } };
+  ndfunc_t ndf = { iter_dfloat_format, FULL_LOOP_NIP, 2, 1, ain, aout };
 
   rb_scan_args(argc, argv, "01", &fmt);
   return na_ndloop(&ndf, 2, self, fmt);
@@ -1368,17 +1320,11 @@ static void iter_dfloat_format_to_a(na_loop_t* const lp) {
   }
 }
 
-/*
-  Format elements into strings.
-  @overload format_to_a format
-  @param [String] format
-  @return [Array] array of formatted strings.
-*/
 static VALUE dfloat_format_to_a(int argc, VALUE* argv, VALUE self) {
   VALUE fmt = Qnil;
-  ndfunc_arg_in_t ain[3] = {{Qnil, 0}, {sym_loop_opt}, {sym_option}};
-  ndfunc_arg_out_t aout[1] = {{rb_cArray, 0}}; // dummy?
-  ndfunc_t ndf = {iter_dfloat_format_to_a, FULL_LOOP_NIP, 3, 1, ain, aout};
+  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };
+  ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } }; // dummy?
+  ndfunc_t ndf = { iter_dfloat_format_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
 
   rb_scan_args(argc, argv, "01", &fmt);
   return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);
@@ -1388,11 +1334,6 @@ static VALUE iter_dfloat_inspect(char* ptr, size_t pos, VALUE fmt) {
   return format_dfloat(fmt, (dtype*)(ptr + pos));
 }
 
-/*
-  Returns a string containing a human-readable representation of NArray.
-  @overload inspect
-  @return [String]
-*/
 static VALUE dfloat_inspect(VALUE ary) {
   return na_ndloop_inspect(ary, iter_dfloat_inspect, Qnil);
 }
@@ -1421,19 +1362,9 @@ static void iter_dfloat_each(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calls the given block once for each element in self,
-  passing that element as a parameter.
-  @overload each
-  @return [Numo::NArray] self
-  For a block `{|x| ... }`,
-  @yieldparam [Numeric] x  an element of NArray.
-  @see #each_with_index
-  @see #map
-*/
 static VALUE 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};
+  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;
@@ -1501,15 +1432,10 @@ static void iter_dfloat_map(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary map.
-  @overload map
-  @return [Numo::DFloat] map of self.
-*/
 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};
+  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);
 }
@@ -1559,20 +1485,9 @@ static void iter_dfloat_each_with_index(na_loop_t* const lp) {
   }
 }
 
-/*
-  Invokes the given block once for each element of self,
-  passing that element and indices along each axis as parameters.
-  @overload each_with_index
-  For a block `{|x,i,j,...| ... }`,
-  @yieldparam [Numeric] x  an element
-  @yieldparam [Integer] i,j,...  multitimensional indices
-  @return [Numo::NArray] self
-  @see #each
-  @see #map_with_index
-*/
 static VALUE 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};
+  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;
@@ -1648,23 +1563,10 @@ static void iter_dfloat_map_with_index(na_loop_t* const lp) {
   }
 }
 
-/*
-  Invokes the given block once for each element of self,
-  passing that element and indices along each axis as parameters.
-  Creates a new NArray containing the values returned by the block.
-  Inplace option is allowed, i.e., `nary.inplace.map` overwrites `nary`.
-  @overload map_with_index
-  For a block `{|x,i,j,...| ... }`,
-  @yieldparam [Numeric] x  an element
-  @yieldparam [Integer] i,j,...  multitimensional indices
-  @return [Numo::NArray] mapped array
-  @see #map
-  @see #each_with_index
-*/
 static VALUE 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};
+  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);
 }
@@ -1710,20 +1612,15 @@ static void iter_dfloat_abs(na_loop_t* const lp) {
   }
 }
 
-/*
-  abs of self.
-  @overload abs
-  @return [Numo::DFloat] abs of self.
-*/
 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};
+  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)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dfloat_add(na_loop_t* const lp) {
@@ -1748,14 +1645,20 @@ static void iter_dfloat_add(na_loop_t* const lp) {
   INIT_PTR(lp, 2, p3, s3);
 
   //
-  if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype)) && is_aligned(p3, sizeof(dtype))) {
+  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)) {
 #ifdef __SSE2__
       // Check number of elements. & Check same alignment.
-      if ((n >= num_pack) && is_same_aligned3(&((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+      if ((n >= num_pack) &&
+          is_same_aligned3(
+            &((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE
+          )) {
         // Calculate up to the position just before the start of SIMD computation.
-        cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+        cnt = get_count_of_elements_not_aligned_to_simd_size(
+          &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+        );
 #endif
         if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -1816,7 +1719,8 @@ static void iter_dfloat_add(na_loop_t* const lp) {
       return;
     }
 
-    if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype)) && is_aligned_step(s3, sizeof(dtype))) {
+    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.
@@ -1827,9 +1731,12 @@ static void iter_dfloat_add(na_loop_t* const lp) {
           b = _mm_load1_pd(&((dtype*)p2)[0]);
 
           // Check number of elements. & Check same alignment.
-          if ((n >= num_pack) && is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+          if ((n >= num_pack) &&
+              is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
             // Calculate up to the position just before the start of SIMD computation.
-            cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+            cnt = get_count_of_elements_not_aligned_to_simd_size(
+              &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+            );
 #endif
             if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -1924,19 +1831,13 @@ static void iter_dfloat_add(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dfloat_add_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_add, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_add, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Binary add.
-  @overload + other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self + other
-*/
 static VALUE dfloat_add(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -1950,7 +1851,7 @@ static VALUE dfloat_add(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dfloat_sub(na_loop_t* const lp) {
@@ -1975,14 +1876,20 @@ static void iter_dfloat_sub(na_loop_t* const lp) {
   INIT_PTR(lp, 2, p3, s3);
 
   //
-  if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype)) && is_aligned(p3, sizeof(dtype))) {
+  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)) {
 #ifdef __SSE2__
       // Check number of elements. & Check same alignment.
-      if ((n >= num_pack) && is_same_aligned3(&((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+      if ((n >= num_pack) &&
+          is_same_aligned3(
+            &((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE
+          )) {
         // Calculate up to the position just before the start of SIMD computation.
-        cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+        cnt = get_count_of_elements_not_aligned_to_simd_size(
+          &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+        );
 #endif
         if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -2044,7 +1951,8 @@ static void iter_dfloat_sub(na_loop_t* const lp) {
       return;
     }
 
-    if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype)) && is_aligned_step(s3, sizeof(dtype))) {
+    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.
@@ -2055,9 +1963,12 @@ static void iter_dfloat_sub(na_loop_t* const lp) {
           b = _mm_load1_pd(&((dtype*)p2)[0]);
 
           // Check number of elements. & Check same alignment.
-          if ((n >= num_pack) && is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+          if ((n >= num_pack) &&
+              is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
             // Calculate up to the position just before the start of SIMD computation.
-            cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+            cnt = get_count_of_elements_not_aligned_to_simd_size(
+              &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+            );
 #endif
             if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -2153,19 +2064,13 @@ static void iter_dfloat_sub(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dfloat_sub_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_sub, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_sub, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Binary sub.
-  @overload - other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self - other
-*/
 static VALUE dfloat_sub(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -2179,7 +2084,7 @@ static VALUE dfloat_sub(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dfloat_mul(na_loop_t* const lp) {
@@ -2204,14 +2109,20 @@ static void iter_dfloat_mul(na_loop_t* const lp) {
   INIT_PTR(lp, 2, p3, s3);
 
   //
-  if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype)) && is_aligned(p3, sizeof(dtype))) {
+  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)) {
 #ifdef __SSE2__
       // Check number of elements. & Check same alignment.
-      if ((n >= num_pack) && is_same_aligned3(&((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+      if ((n >= num_pack) &&
+          is_same_aligned3(
+            &((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE
+          )) {
         // Calculate up to the position just before the start of SIMD computation.
-        cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+        cnt = get_count_of_elements_not_aligned_to_simd_size(
+          &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+        );
 #endif
         if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -2273,7 +2184,8 @@ static void iter_dfloat_mul(na_loop_t* const lp) {
       return;
     }
 
-    if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype)) && is_aligned_step(s3, sizeof(dtype))) {
+    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.
@@ -2284,9 +2196,12 @@ static void iter_dfloat_mul(na_loop_t* const lp) {
           b = _mm_load1_pd(&((dtype*)p2)[0]);
 
           // Check number of elements. & Check same alignment.
-          if ((n >= num_pack) && is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+          if ((n >= num_pack) &&
+              is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
             // Calculate up to the position just before the start of SIMD computation.
-            cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+            cnt = get_count_of_elements_not_aligned_to_simd_size(
+              &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+            );
 #endif
             if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -2382,19 +2297,13 @@ static void iter_dfloat_mul(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dfloat_mul_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_mul, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_mul, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Binary mul.
-  @overload * other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self * other
-*/
 static VALUE dfloat_mul(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -2408,7 +2317,7 @@ static VALUE dfloat_mul(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dfloat_div(na_loop_t* const lp) {
@@ -2433,14 +2342,20 @@ static void iter_dfloat_div(na_loop_t* const lp) {
   INIT_PTR(lp, 2, p3, s3);
 
   //
-  if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype)) && is_aligned(p3, sizeof(dtype))) {
+  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)) {
 #ifdef __SSE2__
       // Check number of elements. & Check same alignment.
-      if ((n >= num_pack) && is_same_aligned3(&((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+      if ((n >= num_pack) &&
+          is_same_aligned3(
+            &((dtype*)p1)[i], &((dtype*)p2)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE
+          )) {
         // Calculate up to the position just before the start of SIMD computation.
-        cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+        cnt = get_count_of_elements_not_aligned_to_simd_size(
+          &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+        );
 #endif
         if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -2500,7 +2415,8 @@ static void iter_dfloat_div(na_loop_t* const lp) {
       return;
     }
 
-    if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype)) && is_aligned_step(s3, sizeof(dtype))) {
+    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.
@@ -2511,9 +2427,12 @@ static void iter_dfloat_div(na_loop_t* const lp) {
           b = _mm_load1_pd(&((dtype*)p2)[0]);
 
           // Check number of elements. & Check same alignment.
-          if ((n >= num_pack) && is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
+          if ((n >= num_pack) &&
+              is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p3)[i], SIMD_ALIGNMENT_SIZE)) {
             // Calculate up to the position just before the start of SIMD computation.
-            cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+            cnt = get_count_of_elements_not_aligned_to_simd_size(
+              &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+            );
 #endif
             if (p1 == p3) { // inplace case
 #ifdef __SSE2__
@@ -2611,19 +2530,13 @@ static void iter_dfloat_div(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dfloat_div_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_div, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_div, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Binary div.
-  @overload / other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self / other
-*/
 static VALUE dfloat_div(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -2637,7 +2550,7 @@ static VALUE dfloat_div(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dfloat_mod(na_loop_t* const lp) {
@@ -2652,7 +2565,8 @@ static void iter_dfloat_mod(na_loop_t* const lp) {
   INIT_PTR(lp, 2, p3, s3);
 
   //
-  if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype)) && is_aligned(p3, sizeof(dtype))) {
+  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
@@ -2669,7 +2583,8 @@ static void iter_dfloat_mod(na_loop_t* const lp) {
       return;
     }
 
-    if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype)) && is_aligned_step(s3, sizeof(dtype))) {
+    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.
@@ -2727,19 +2642,13 @@ static void iter_dfloat_mod(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dfloat_mod_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_mod, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_mod, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Binary mod.
-  @overload % other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self % other
-*/
 static VALUE dfloat_mod(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -2773,19 +2682,13 @@ static void iter_dfloat_divmod(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_divmod_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_divmod, STRIDE_LOOP, 2, 2, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_divmod, STRIDE_LOOP, 2, 2, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Binary divmod.
-  @overload divmod other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] divmod of self and other.
-*/
 static VALUE dfloat_divmod(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -2834,11 +2737,11 @@ static void iter_dfloat_pow_int32(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_pow_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_in_t ain_i[2] = {{cT, 0}, {numo_cInt32, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_pow, STRIDE_LOOP, 2, 1, ain, aout};
-  ndfunc_t ndf_i = {iter_dfloat_pow_int32, STRIDE_LOOP, 2, 1, ain_i, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_in_t ain_i[2] = { { cT, 0 }, { numo_cInt32, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_pow, STRIDE_LOOP, 2, 1, ain, aout };
+  ndfunc_t ndf_i = { iter_dfloat_pow_int32, STRIDE_LOOP, 2, 1, ain_i, aout };
 
   // fixme : use na.integer?
   if (FIXNUM_P(other) || rb_obj_is_kind_of(other, numo_cInt32)) {
@@ -2848,12 +2751,6 @@ static VALUE dfloat_pow_self(VALUE self, VALUE other) {
   }
 }
 
-/*
-  Binary power.
-  @overload ** other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self to the other-th power.
-*/
 static VALUE dfloat_pow(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -2928,15 +2825,10 @@ static void iter_dfloat_minus(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary minus.
-  @overload -@
-  @return [Numo::DFloat] minus of self.
-*/
 static VALUE dfloat_minus(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_minus, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_minus, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3003,15 +2895,10 @@ static void iter_dfloat_reciprocal(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary reciprocal.
-  @overload reciprocal
-  @return [Numo::DFloat] reciprocal of self.
-*/
 static VALUE dfloat_reciprocal(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_reciprocal, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_reciprocal, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3078,15 +2965,10 @@ static void iter_dfloat_sign(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary sign.
-  @overload sign
-  @return [Numo::DFloat] sign of self.
-*/
 static VALUE dfloat_sign(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_sign, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_sign, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3153,15 +3035,10 @@ static void iter_dfloat_square(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary square.
-  @overload square
-  @return [Numo::DFloat] square of self.
-*/
 static VALUE dfloat_square(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_square, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_square, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3188,19 +3065,13 @@ static void iter_dfloat_eq(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_eq_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_eq, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_eq, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Comparison eq other.
-  @overload eq other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self eq other.
-*/
 static VALUE dfloat_eq(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -3235,19 +3106,13 @@ static void iter_dfloat_ne(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_ne_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_ne, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_ne, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Comparison ne other.
-  @overload ne other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self ne other.
-*/
 static VALUE dfloat_ne(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -3282,19 +3147,13 @@ static void iter_dfloat_nearly_eq(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_nearly_eq_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_nearly_eq, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_nearly_eq, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Comparison nearly_eq other.
-  @overload nearly_eq other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self nearly_eq other.
-*/
 static VALUE dfloat_nearly_eq(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -3369,15 +3228,10 @@ static void iter_dfloat_floor(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary floor.
-  @overload floor
-  @return [Numo::DFloat] floor of self.
-*/
 static VALUE dfloat_floor(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_floor, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_floor, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3444,15 +3298,10 @@ static void iter_dfloat_round(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary round.
-  @overload round
-  @return [Numo::DFloat] round of self.
-*/
 static VALUE dfloat_round(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_round, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_round, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3519,15 +3368,10 @@ static void iter_dfloat_ceil(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary ceil.
-  @overload ceil
-  @return [Numo::DFloat] ceil of self.
-*/
 static VALUE dfloat_ceil(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_ceil, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_ceil, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3594,15 +3438,10 @@ static void iter_dfloat_trunc(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary trunc.
-  @overload trunc
-  @return [Numo::DFloat] trunc of self.
-*/
 static VALUE dfloat_trunc(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_trunc, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_trunc, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3669,20 +3508,15 @@ static void iter_dfloat_rint(na_loop_t* const lp) {
   }
 }
 
-/*
-  Unary rint.
-  @overload rint
-  @return [Numo::DFloat] rint of self.
-*/
 static VALUE dfloat_rint(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_rint, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_rint, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dfloat_copysign(na_loop_t* const lp) {
@@ -3697,7 +3531,8 @@ static void iter_dfloat_copysign(na_loop_t* const lp) {
   INIT_PTR(lp, 2, p3, s3);
 
   //
-  if (is_aligned(p1, sizeof(dtype)) && is_aligned(p2, sizeof(dtype)) && is_aligned(p3, sizeof(dtype))) {
+  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
@@ -3714,7 +3549,8 @@ static void iter_dfloat_copysign(na_loop_t* const lp) {
       return;
     }
 
-    if (is_aligned_step(s1, sizeof(dtype)) && is_aligned_step(s2, sizeof(dtype)) && is_aligned_step(s3, sizeof(dtype))) {
+    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.
@@ -3772,19 +3608,13 @@ static void iter_dfloat_copysign(na_loop_t* const lp) {
 #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};
+  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);
 }
 
-/*
-  Binary copysign.
-  @overload copysign other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self copysign other
-*/
 static VALUE dfloat_copysign(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -3827,15 +3657,10 @@ static void iter_dfloat_signbit(na_loop_t* const lp) {
   }
 }
 
-/*
-  Condition of signbit.
-  @overload signbit
-  @return [Numo::Bit] Condition of signbit.
-*/
 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};
+  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);
 }
@@ -3857,15 +3682,10 @@ static void iter_dfloat_modf(na_loop_t* const lp) {
   }
 }
 
-/*
-  modf of self.
-  @overload modf
-  @return [Numo::DFloat] modf of self.
-*/
 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};
+  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);
 }
@@ -3892,19 +3712,13 @@ static void iter_dfloat_gt(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_gt_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_gt, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_gt, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Comparison gt other.
-  @overload gt other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self gt other.
-*/
 static VALUE dfloat_gt(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -3939,19 +3753,13 @@ static void iter_dfloat_ge(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_ge_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_ge, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_ge, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Comparison ge other.
-  @overload ge other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self ge other.
-*/
 static VALUE dfloat_ge(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -3986,19 +3794,13 @@ static void iter_dfloat_lt(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_lt_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_lt, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_lt, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Comparison lt other.
-  @overload lt other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self lt other.
-*/
 static VALUE dfloat_lt(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -4033,19 +3835,13 @@ static void iter_dfloat_le(na_loop_t* const lp) {
 }
 
 static VALUE dfloat_le_self(VALUE self, VALUE other) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_le, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_le, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
 
-/*
-  Comparison le other.
-  @overload le other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self le other.
-*/
 static VALUE dfloat_le(VALUE self, VALUE other) {
 
   VALUE klass, v;
@@ -4123,42 +3919,12 @@ static void iter_dfloat_clip_max(na_loop_t* const lp) {
   }
 }
 
-/*
-  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 dfloat_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_dfloat_clip_min, STRIDE_LOOP, 2, 1, ain, aout};
-  ndfunc_t ndf_max = {iter_dfloat_clip_max, STRIDE_LOOP, 2, 1, ain, aout};
-  ndfunc_t ndf_both = {iter_dfloat_clip, STRIDE_LOOP, 3, 1, ain, aout};
+  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_dfloat_clip_min, STRIDE_LOOP, 2, 1, ain, aout };
+  ndfunc_t ndf_max = { iter_dfloat_clip_max, STRIDE_LOOP, 2, 1, ain, aout };
+  ndfunc_t ndf_both = { iter_dfloat_clip, STRIDE_LOOP, 3, 1, ain, aout };
 
   if (RTEST(min)) {
     if (RTEST(max)) {
@@ -4204,15 +3970,10 @@ static void iter_dfloat_isnan(na_loop_t* const lp) {
   }
 }
 
-/*
-  Condition of isnan.
-  @overload isnan
-  @return [Numo::Bit] Condition of isnan.
-*/
 static VALUE dfloat_isnan(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_isnan, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_isnan, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -4246,15 +4007,10 @@ static void iter_dfloat_isinf(na_loop_t* const lp) {
   }
 }
 
-/*
-  Condition of isinf.
-  @overload isinf
-  @return [Numo::Bit] Condition of isinf.
-*/
 static VALUE dfloat_isinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_isinf, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_isinf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -4288,15 +4044,10 @@ static void iter_dfloat_isposinf(na_loop_t* const lp) {
   }
 }
 
-/*
-  Condition of isposinf.
-  @overload isposinf
-  @return [Numo::Bit] Condition of isposinf.
-*/
 static VALUE dfloat_isposinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_isposinf, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_isposinf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -4330,15 +4081,10 @@ static void iter_dfloat_isneginf(na_loop_t* const lp) {
   }
 }
 
-/*
-  Condition of isneginf.
-  @overload isneginf
-  @return [Numo::Bit] Condition of isneginf.
-*/
 static VALUE dfloat_isneginf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_isneginf, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_isneginf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -4372,15 +4118,10 @@ static void iter_dfloat_isfinite(na_loop_t* const lp) {
   }
 }
 
-/*
-  Condition of isfinite.
-  @overload isfinite
-  @return [Numo::Bit] Condition of isfinite.
-*/
 static VALUE dfloat_isfinite(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dfloat_isfinite, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_dfloat_isfinite, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -4408,19 +4149,11 @@ static void iter_dfloat_sum_nan(na_loop_t* const lp) {
   *(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::DFloat] returns result of sum.
-*/
 static VALUE dfloat_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_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_sum_nan);
 
@@ -4452,19 +4185,11 @@ static void iter_dfloat_prod_nan(na_loop_t* const lp) {
   *(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::DFloat] returns result of prod.
-*/
 static VALUE dfloat_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_dfloat_prod, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_prod, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_prod_nan);
 
@@ -4496,19 +4221,11 @@ static void iter_dfloat_kahan_sum_nan(na_loop_t* const lp) {
   *(dtype*)p2 = f_kahan_sum_nan(n, p1, s1);
 }
 
-/*
-  kahan_sum of self.
-  @overload kahan_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 kahan_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::DFloat] returns result of kahan_sum.
-*/
 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};
+  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);
 
@@ -4517,182 +4234,6 @@ static VALUE dfloat_kahan_sum(int argc, VALUE* argv, VALUE self) {
   return dfloat_extract(v);
 }
 
-static void iter_dfloat_mean(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_mean(n, p1, s1);
-}
-static void iter_dfloat_mean_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_mean_nan(n, p1, s1);
-}
-
-/*
-  mean of self.
-  @overload mean(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 mean along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::DFloat] returns result of mean.
-*/
-static VALUE dfloat_mean(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_mean, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_mean_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return dfloat_extract(v);
-}
-
-static void iter_dfloat_stddev(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;
-
-  *(rtype*)p2 = f_stddev(n, p1, s1);
-}
-static void iter_dfloat_stddev_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;
-
-  *(rtype*)p2 = f_stddev_nan(n, p1, s1);
-}
-
-/*
-  stddev of self.
-  @overload stddev(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 stddev along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::DFloat] returns result of stddev.
-*/
-static VALUE dfloat_stddev(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] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_dfloat_stddev, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_stddev_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
-static void iter_dfloat_var(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;
-
-  *(rtype*)p2 = f_var(n, p1, s1);
-}
-static void iter_dfloat_var_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;
-
-  *(rtype*)p2 = f_var_nan(n, p1, s1);
-}
-
-/*
-  var of self.
-  @overload var(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 var along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::DFloat] returns result of var.
-*/
-static VALUE dfloat_var(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] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_dfloat_var, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_var_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
-static void iter_dfloat_rms(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;
-
-  *(rtype*)p2 = f_rms(n, p1, s1);
-}
-static void iter_dfloat_rms_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;
-
-  *(rtype*)p2 = f_rms_nan(n, p1, s1);
-}
-
-/*
-  rms of self.
-  @overload rms(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 rms along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::DFloat] returns result of rms.
-*/
-static VALUE dfloat_rms(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] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_dfloat_rms, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_rms_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
 static void iter_dfloat_min(na_loop_t* const lp) {
   size_t n;
   char *p1, *p2;
@@ -4716,19 +4257,11 @@ static void iter_dfloat_min_nan(na_loop_t* const lp) {
   *(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::DFloat] returns result of min.
-*/
 static VALUE dfloat_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_dfloat_min, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_min, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_min_nan);
 
@@ -4760,19 +4293,11 @@ static void iter_dfloat_max_nan(na_loop_t* const lp) {
   *(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::DFloat] returns result of max.
-*/
 static VALUE dfloat_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_dfloat_max, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_max, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_max_nan);
 
@@ -4804,19 +4329,11 @@ static void iter_dfloat_ptp_nan(na_loop_t* const lp) {
   *(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::DFloat] returns result of ptp.
-*/
 static VALUE dfloat_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_dfloat_ptp, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_ptp, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_ptp_nan);
 
@@ -4893,31 +4410,12 @@ static void iter_dfloat_max_index_index32_nan(na_loop_t* const lp) {
 }
 #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 dfloat_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};
+  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) {
@@ -5010,31 +4508,12 @@ static void iter_dfloat_min_index_index32_nan(na_loop_t* const lp) {
 }
 #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 dfloat_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};
+  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) {
@@ -5123,31 +4602,12 @@ static void iter_dfloat_argmax_arg32_nan(na_loop_t* const lp) {
 }
 #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 dfloat_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};
+  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) {
@@ -5233,31 +4693,12 @@ static void iter_dfloat_argmin_arg32_nan(na_loop_t* const lp) {
 }
 #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 dfloat_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};
+  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) {
@@ -5308,35 +4749,19 @@ static void iter_dfloat_minmax_nan(na_loop_t* const lp) {
   *(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::DFloat,Numo::DFloat] min and max of self.
-*/
 static VALUE dfloat_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_dfloat_minmax, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 2, ain, aout};
+  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_dfloat_minmax, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 2, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_minmax_nan);
 
   return na_ndloop(&ndf, 2, self, reduce);
 }
 
-/*
-  Element-wise maximum of two arrays.
-
-  @overload maximum(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::DFloat]
-*/
-
 static void iter_dfloat_s_maximum(na_loop_t* const lp) {
   size_t i, n;
   char *p1, *p2, *p3;
@@ -5379,13 +4804,13 @@ static void iter_dfloat_s_maximum_nan(na_loop_t* const lp) {
 static VALUE dfloat_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_dfloat_s_maximum, STRIDE_LOOP_NIP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_s_maximum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
 
   VALUE kw_hash = Qnil;
-  ID kw_table[1] = {id_nan};
-  VALUE opts[1] = {Qundef};
+  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);
@@ -5396,16 +4821,6 @@ static VALUE dfloat_s_maximum(int argc, VALUE* argv, VALUE mod) {
   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::DFloat]
-*/
-
 static void iter_dfloat_s_minimum(na_loop_t* const lp) {
   size_t i, n;
   char *p1, *p2, *p3;
@@ -5448,13 +4863,13 @@ static void iter_dfloat_s_minimum_nan(na_loop_t* const lp) {
 static VALUE dfloat_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_dfloat_s_minimum, STRIDE_LOOP_NIP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_s_minimum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
 
   VALUE kw_hash = Qnil;
-  ID kw_table[1] = {id_nan};
-  VALUE opts[1] = {Qundef};
+  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);
@@ -5474,16 +4889,13 @@ static void iter_dfloat_cumsum(na_loop_t* const lp) {
   INIT_COUNTER(lp, i);
   INIT_PTR(lp, 0, p1, s1);
   INIT_PTR(lp, 1, p2, s2);
-  // printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
 
   GET_DATA_STRIDE(p1, s1, dtype, x);
   SET_DATA_STRIDE(p2, s2, dtype, x);
-  // printf("i=%lu x=%f\n",i,x);
   for (i--; i--;) {
     GET_DATA_STRIDE(p1, s1, dtype, y);
     m_cumsum(x, y);
     SET_DATA_STRIDE(p2, s2, dtype, x);
-    // printf("i=%lu x=%f\n",i,x);
   }
 }
 static void iter_dfloat_cumsum_nan(na_loop_t* const lp) {
@@ -5495,31 +4907,23 @@ static void iter_dfloat_cumsum_nan(na_loop_t* const lp) {
   INIT_COUNTER(lp, i);
   INIT_PTR(lp, 0, p1, s1);
   INIT_PTR(lp, 1, p2, s2);
-  // printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
 
   GET_DATA_STRIDE(p1, s1, dtype, x);
   SET_DATA_STRIDE(p2, s2, dtype, x);
-  // printf("i=%lu x=%f\n",i,x);
   for (i--; i--;) {
     GET_DATA_STRIDE(p1, s1, dtype, y);
     m_cumsum_nan(x, y);
     SET_DATA_STRIDE(p2, s2, dtype, x);
-    // printf("i=%lu x=%f\n",i,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::DFloat] cumsum of self.
-*/
 static VALUE dfloat_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_dfloat_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = {
+    iter_dfloat_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_cumsum_nan);
 
@@ -5535,16 +4939,13 @@ static void iter_dfloat_cumprod(na_loop_t* const lp) {
   INIT_COUNTER(lp, i);
   INIT_PTR(lp, 0, p1, s1);
   INIT_PTR(lp, 1, p2, s2);
-  // printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
 
   GET_DATA_STRIDE(p1, s1, dtype, x);
   SET_DATA_STRIDE(p2, s2, dtype, x);
-  // printf("i=%lu x=%f\n",i,x);
   for (i--; i--;) {
     GET_DATA_STRIDE(p1, s1, dtype, y);
     m_cumprod(x, y);
     SET_DATA_STRIDE(p2, s2, dtype, x);
-    // printf("i=%lu x=%f\n",i,x);
   }
 }
 static void iter_dfloat_cumprod_nan(na_loop_t* const lp) {
@@ -5556,31 +4957,23 @@ static void iter_dfloat_cumprod_nan(na_loop_t* const lp) {
   INIT_COUNTER(lp, i);
   INIT_PTR(lp, 0, p1, s1);
   INIT_PTR(lp, 1, p2, s2);
-  // printf("i=%lu p1=%lx s1=%lu p2=%lx s2=%lu\n",i,(size_t)p1,s1,(size_t)p2,s2);
 
   GET_DATA_STRIDE(p1, s1, dtype, x);
   SET_DATA_STRIDE(p2, s2, dtype, x);
-  // printf("i=%lu x=%f\n",i,x);
   for (i--; i--;) {
     GET_DATA_STRIDE(p1, s1, dtype, y);
     m_cumprod_nan(x, y);
     SET_DATA_STRIDE(p2, s2, dtype, x);
-    // printf("i=%lu x=%f\n",i,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::DFloat] cumprod of self.
-*/
 static VALUE dfloat_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_dfloat_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = {
+    iter_dfloat_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dfloat_cumprod_nan);
 
@@ -5660,9 +5053,9 @@ static void iter_dfloat_mulsum_nan(na_loop_t* const lp) {
 static VALUE dfloat_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_dfloat_mulsum, STRIDE_LOOP_NIP, 4, 1, ain, aout};
+  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_dfloat_mulsum, STRIDE_LOOP_NIP, 4, 1, ain, aout };
 
   if (argc < 1) {
     rb_raise(rb_eArgError, "wrong number of arguments (%d for >=1)", argc);
@@ -5678,16 +5071,6 @@ static VALUE dfloat_mulsum_self(int argc, VALUE* argv, VALUE self) {
   return dfloat_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.
-*/
 static VALUE dfloat_mulsum(int argc, VALUE* argv, VALUE self) {
   //
   VALUE klass, v;
@@ -5750,28 +5133,11 @@ static void iter_dfloat_seq(na_loop_t* const lp) {
   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::DFloat] 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]
-*/
 static VALUE dfloat_seq(int argc, VALUE* args, VALUE self) {
   seq_opt_t* g;
   VALUE vbeg = Qnil, vstep = Qnil;
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 0}};
-  ndfunc_t ndf = {iter_dfloat_seq, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dfloat_seq, FULL_LOOP, 1, 0, ain, 0 };
 
   g = ALLOCA_N(seq_opt_t, 1);
   g->beg = m_zero;
@@ -5829,32 +5195,11 @@ static void iter_dfloat_logseq(na_loop_t* const lp) {
   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::DFloat] 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, ...]
-*/
 static VALUE dfloat_logseq(int argc, VALUE* args, VALUE self) {
   logseq_opt_t* g;
   VALUE vbeg, vstep, vbase;
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 0}};
-  ndfunc_t ndf = {iter_dfloat_logseq, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dfloat_logseq, FULL_LOOP, 1, 0, ain, 0 };
 
   g = ALLOCA_N(logseq_opt_t, 1);
   rb_scan_args(argc, args, "21", &vbeg, &vstep, &vbase);
@@ -5898,18 +5243,9 @@ static void iter_dfloat_eye(na_loop_t* const lp) {
   }
 }
 
-/*
-  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::DFloat] eye of self.
-*/
 static VALUE dfloat_eye(int argc, VALUE* argv, VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 2}};
-  ndfunc_t ndf = {iter_dfloat_eye, NO_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+  ndfunc_t ndf = { iter_dfloat_eye, NO_LOOP, 1, 0, ain, 0 };
   ssize_t kofs;
   dtype data;
   char* g;
@@ -5939,17 +5275,21 @@ static VALUE dfloat_eye(int argc, VALUE* argv, VALUE self) {
   // 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]);
+      rb_raise(
+        rb_eArgError,
+        "invalid diagonal offset(%" SZF "d) for "
+        "last dimension size(%" SZF "d)",
+        kofs, na->shape[nd - 1]
+      );
     }
   } 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]);
+      rb_raise(
+        rb_eArgError,
+        "invalid diagonal offset(%" SZF "d) for "
+        "last-1 dimension size(%" SZF "d)",
+        kofs, na->shape[nd - 2]
+      );
     }
   }
 
@@ -5995,31 +5335,12 @@ static void iter_dfloat_rand(na_loop_t* const lp) {
   }
 }
 
-/*
-  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::DFloat] 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]
-*/
 static VALUE dfloat_rand(int argc, VALUE* args, 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_dfloat_rand, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dfloat_rand, FULL_LOOP, 1, 0, ain, 0 };
 
   rb_scan_args(argc, args, "02", &v1, &v2);
   if (v2 == Qnil) {
@@ -6093,42 +5414,12 @@ static void iter_dfloat_rand_norm(na_loop_t* const lp) {
   }
 }
 
-/*
-  Generates random numbers from the normal distribution on self narray
-  using Box-Muller Transformation.
-  @overload rand_norm([mu,[sigma]])
-  @param [Numeric] mu  mean of normal distribution. (default=0)
-  @param [Numeric] sigma  standard deviation of normal distribution. (default=1)
-  @return [Numo::DFloat] self.
-  @example
-    Numo::DFloat.new(5,5).rand_norm
-    # => Numo::DFloat#shape=[5,5]
-    # [[-0.581255, -0.168354, 0.586895, -0.595142, -0.802802],
-    #  [-0.326106, 0.282922, 1.68427, 0.918499, -0.0485384],
-    #  [-0.464453, -0.992194, 0.413794, -0.60717, -0.699695],
-    #  [-1.64168, 0.48676, -0.875871, -1.43275, 0.812172],
-    #  [-0.209975, -0.103612, -0.878617, -1.42495, 1.0968]]
-
-    Numo::DFloat.new(5,5).rand_norm(10,0.1)
-    # => Numo::DFloat#shape=[5,5]
-    # [[9.9019, 9.90339, 10.0826, 9.98384, 9.72861],
-    #  [9.81507, 10.0272, 9.91445, 10.0568, 9.88923],
-    #  [10.0234, 9.97874, 9.96011, 9.9006, 9.99964],
-    #  [10.0186, 9.94598, 9.92236, 9.99811, 9.97003],
-    #  [9.79266, 9.95044, 9.95212, 9.93692, 10.2027]]
-
-    Numo::DComplex.new(3,3).rand_norm(5+5i)
-    # => Numo::DComplex#shape=[3,3]
-    # [[5.84303+4.40052i, 4.00984+6.08982i, 5.10979+5.13215i],
-    #  [4.26477+3.99655i, 4.90052+5.00763i, 4.46607+2.3444i],
-    #  [4.5528+7.11003i, 5.62117+6.69094i, 5.05443+5.35133i]]
-*/
 static VALUE dfloat_rand_norm(int argc, VALUE* args, VALUE self) {
   int n;
   randn_opt_t g;
   VALUE v1 = Qnil, v2 = Qnil;
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 0}};
-  ndfunc_t ndf = {iter_dfloat_rand_norm, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dfloat_rand_norm, FULL_LOOP, 1, 0, ain, 0 };
 
   n = rb_scan_args(argc, args, "02", &v1, &v2);
   if (n == 0) {
@@ -6161,19 +5452,12 @@ static void iter_dfloat_poly(na_loop_t* const lp) {
   *(dtype*)(lp->args[i].ptr + lp->args[i].iter[0].pos) = y;
 }
 
-/*
-  Calculate polynomial.
-    `x.poly(a0,a1,a2,...,an) = a0 + a1*x + a2*x**2 + ... + an*x**n`
-  @overload poly a0, a1, ..., an
-  @param [Numo::NArray,Numeric] a0,a1,...,an
-  @return [Numo::DFloat]
-*/
 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};
+  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;
@@ -6253,23 +5537,28 @@ static VALUE dfloat_poly(VALUE self, VALUE args) {
  * 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);                                                                                                         \
+#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;
+#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;
+#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) {
@@ -6279,19 +5568,20 @@ static inline void swapfunc(char* a, char* b, size_t n, int swaptype) {
     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                                                                                                                       \
+#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)                                                                                                       \
+#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)))
+#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
@@ -6520,19 +5810,10 @@ static void iter_dfloat_sort_prnan(na_loop_t* const lp) {
   dfloat_qsort_prnan(ptr, n, step);
 }
 
-/*
-  sort of self.
-  @overload sort(axis:nil, nan:false)
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
-  @param [Numeric,Array,Range] axis  Performs sort along the axis.
-  @return [Numo::DFloat] returns result of sort.
-  @example
-      Numo::DFloat[3,4,1,2].sort #=> Numo::DFloat[1,2,3,4]
-*/
 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};
+  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);
@@ -6637,7 +5918,8 @@ loop:
     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) {
+  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);
@@ -6762,7 +6044,8 @@ loop:
     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) {
+  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);
@@ -6809,7 +6092,6 @@ static void dfloat_index64_qsort_ignan(na_loop_t* const lp) {
 
   ptr = (char**)(lp->opt_ptr);
 
-  // printf("(ptr=%lx, d_ptr=%lx,d_step=%ld, i_ptr=%lx,i_step=%ld,
   // 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) {
@@ -6819,21 +6101,17 @@ static void dfloat_index64_qsort_ignan(na_loop_t* const lp) {
 
   for (i = 0; i < n; i++) {
     ptr[i] = d_ptr + d_step * i;
-    // printf("(%ld,%.3f)",i,*(double*)ptr[i]);
   }
 
   dfloat_index_qsort_ignan(ptr, n, sizeof(dtype*));
 
   // d_ptr = lp->args[0].ptr;
-  // printf("(d_ptr=%lx)\n",(size_t)d_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);
-    // printf("(idx[%ld]=%ld,%d)",i,idx,*(idx_t*)o_ptr);
     o_ptr += o_step;
   }
-  // printf("\n");
 }
 #undef idx_t
 
@@ -6851,7 +6129,6 @@ static void dfloat_index32_qsort_ignan(na_loop_t* const lp) {
 
   ptr = (char**)(lp->opt_ptr);
 
-  // printf("(ptr=%lx, d_ptr=%lx,d_step=%ld, i_ptr=%lx,i_step=%ld,
   // 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) {
@@ -6861,21 +6138,17 @@ static void dfloat_index32_qsort_ignan(na_loop_t* const lp) {
 
   for (i = 0; i < n; i++) {
     ptr[i] = d_ptr + d_step * i;
-    // printf("(%ld,%.3f)",i,*(double*)ptr[i]);
   }
 
   dfloat_index_qsort_ignan(ptr, n, sizeof(dtype*));
 
   // d_ptr = lp->args[0].ptr;
-  // printf("(d_ptr=%lx)\n",(size_t)d_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);
-    // printf("(idx[%ld]=%ld,%d)",i,idx,*(idx_t*)o_ptr);
     o_ptr += o_step;
   }
-  // printf("\n");
 }
 #undef idx_t
 
@@ -6893,7 +6166,6 @@ static void dfloat_index64_qsort_prnan(na_loop_t* const lp) {
 
   ptr = (char**)(lp->opt_ptr);
 
-  // printf("(ptr=%lx, d_ptr=%lx,d_step=%ld, i_ptr=%lx,i_step=%ld,
   // 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) {
@@ -6903,21 +6175,17 @@ static void dfloat_index64_qsort_prnan(na_loop_t* const lp) {
 
   for (i = 0; i < n; i++) {
     ptr[i] = d_ptr + d_step * i;
-    // printf("(%ld,%.3f)",i,*(double*)ptr[i]);
   }
 
   dfloat_index_qsort_prnan(ptr, n, sizeof(dtype*));
 
   // d_ptr = lp->args[0].ptr;
-  // printf("(d_ptr=%lx)\n",(size_t)d_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);
-    // printf("(idx[%ld]=%ld,%d)",i,idx,*(idx_t*)o_ptr);
     o_ptr += o_step;
   }
-  // printf("\n");
 }
 #undef idx_t
 
@@ -6935,7 +6203,6 @@ static void dfloat_index32_qsort_prnan(na_loop_t* const lp) {
 
   ptr = (char**)(lp->opt_ptr);
 
-  // printf("(ptr=%lx, d_ptr=%lx,d_step=%ld, i_ptr=%lx,i_step=%ld,
   // 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) {
@@ -6945,41 +6212,28 @@ static void dfloat_index32_qsort_prnan(na_loop_t* const lp) {
 
   for (i = 0; i < n; i++) {
     ptr[i] = d_ptr + d_step * i;
-    // printf("(%ld,%.3f)",i,*(double*)ptr[i]);
   }
 
   dfloat_index_qsort_prnan(ptr, n, sizeof(dtype*));
 
   // d_ptr = lp->args[0].ptr;
-  // printf("(d_ptr=%lx)\n",(size_t)d_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);
-    // printf("(idx[%ld]=%ld,%d)",i,idx,*(idx_t*)o_ptr);
     o_ptr += o_step;
   }
-  // printf("\n");
 }
 #undef idx_t
 
-/*
-  sort_index. Returns an index array of sort result.
-  @overload sort_index(axis:nil, nan:false)
-  @param [TrueClass] nan  If true, propagete NaN. If false, ignore NaN.
-  @param [Numeric,Array,Range] axis  Performs sort_index along the axis.
-  @return [Integer,Numo::Int] returns result index of sort_index.
-  @example
-      Numo::NArray[3,4,1,2].sort_index #=> Numo::Int32[2,3,0,1]
-*/
 static VALUE 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};
+  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) {
@@ -7057,20 +6311,11 @@ static void iter_dfloat_median_prnan(na_loop_t* const lp) {
   }
 }
 
-/*
-  median of self.
-  @overload median(axis:nil, keepdims:false, nan:false)
-  @param [TrueClass] nan (keyword) If true, propagete NaN. If false, ignore NaN.
-  @param [Numeric,Array,Range] axis  Finds median along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::DFloat] returns median of self.
-*/
-
 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};
+  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
 
@@ -7081,10 +6326,6 @@ static VALUE dfloat_median(int argc, VALUE* argv, VALUE self) {
   return dfloat_extract(v);
 }
 
-/*
-  module definition: Numo::DFloat::NMath
-*/
-
 VALUE mTM;
 
 static void iter_dfloat_math_s_sqrt(na_loop_t* const lp) {
@@ -7135,9 +6376,12 @@ static void iter_dfloat_math_s_sqrt(na_loop_t* const lp) {
 #ifdef __SSE2__
           //
           // Check number of elements. & Check same alignment.
-          if ((n >= num_pack) && is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p2)[i], SIMD_ALIGNMENT_SIZE)) {
+          if ((n >= num_pack) &&
+              is_same_aligned2(&((dtype*)p1)[i], &((dtype*)p2)[i], SIMD_ALIGNMENT_SIZE)) {
             // Calculate up to the position just before the start of SIMD computation.
-            cnt = get_count_of_elements_not_aligned_to_simd_size(&((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype));
+            cnt = get_count_of_elements_not_aligned_to_simd_size(
+              &((dtype*)p1)[i], SIMD_ALIGNMENT_SIZE, sizeof(dtype)
+            );
 #endif
 #ifdef __SSE2__
             for (i = 0; i < cnt; i++) {
@@ -7199,16 +6443,10 @@ static void iter_dfloat_math_s_sqrt(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate sqrt(x).
-  @overload sqrt(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of sqrt(x).
-*/
 static VALUE dfloat_math_s_sqrt(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_sqrt, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_sqrt, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7277,16 +6515,10 @@ static void iter_dfloat_math_s_cbrt(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate cbrt(x).
-  @overload cbrt(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of cbrt(x).
-*/
 static VALUE dfloat_math_s_cbrt(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_cbrt, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_cbrt, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7355,16 +6587,10 @@ static void iter_dfloat_math_s_log(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate log(x).
-  @overload log(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of log(x).
-*/
 static VALUE dfloat_math_s_log(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_log, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_log, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7433,16 +6659,10 @@ static void iter_dfloat_math_s_log2(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate log2(x).
-  @overload log2(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of log2(x).
-*/
 static VALUE dfloat_math_s_log2(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_log2, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_log2, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7511,16 +6731,10 @@ static void iter_dfloat_math_s_log10(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate log10(x).
-  @overload log10(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of log10(x).
-*/
 static VALUE dfloat_math_s_log10(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_log10, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_log10, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7589,16 +6803,10 @@ static void iter_dfloat_math_s_exp(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate exp(x).
-  @overload exp(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of exp(x).
-*/
 static VALUE dfloat_math_s_exp(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_exp, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_exp, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7667,16 +6875,10 @@ static void iter_dfloat_math_s_exp2(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate exp2(x).
-  @overload exp2(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of exp2(x).
-*/
 static VALUE dfloat_math_s_exp2(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_exp2, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_exp2, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7745,16 +6947,10 @@ static void iter_dfloat_math_s_exp10(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate exp10(x).
-  @overload exp10(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of exp10(x).
-*/
 static VALUE dfloat_math_s_exp10(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_exp10, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_exp10, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7823,16 +7019,10 @@ static void iter_dfloat_math_s_sin(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate sin(x).
-  @overload sin(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of sin(x).
-*/
 static VALUE dfloat_math_s_sin(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_sin, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_sin, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7901,16 +7091,10 @@ static void iter_dfloat_math_s_cos(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate cos(x).
-  @overload cos(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of cos(x).
-*/
 static VALUE dfloat_math_s_cos(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_cos, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_cos, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -7979,16 +7163,10 @@ static void iter_dfloat_math_s_tan(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate tan(x).
-  @overload tan(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of tan(x).
-*/
 static VALUE dfloat_math_s_tan(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_tan, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_tan, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8057,16 +7235,10 @@ static void iter_dfloat_math_s_asin(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate asin(x).
-  @overload asin(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of asin(x).
-*/
 static VALUE dfloat_math_s_asin(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_asin, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_asin, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8135,16 +7307,10 @@ static void iter_dfloat_math_s_acos(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate acos(x).
-  @overload acos(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of acos(x).
-*/
 static VALUE dfloat_math_s_acos(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_acos, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_acos, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8213,16 +7379,10 @@ static void iter_dfloat_math_s_atan(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate atan(x).
-  @overload atan(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of atan(x).
-*/
 static VALUE dfloat_math_s_atan(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_atan, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_atan, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8291,16 +7451,10 @@ static void iter_dfloat_math_s_sinh(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate sinh(x).
-  @overload sinh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of sinh(x).
-*/
 static VALUE dfloat_math_s_sinh(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_sinh, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_sinh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8369,16 +7523,10 @@ static void iter_dfloat_math_s_cosh(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate cosh(x).
-  @overload cosh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of cosh(x).
-*/
 static VALUE dfloat_math_s_cosh(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_cosh, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_cosh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8447,16 +7595,10 @@ static void iter_dfloat_math_s_tanh(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate tanh(x).
-  @overload tanh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of tanh(x).
-*/
 static VALUE dfloat_math_s_tanh(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_tanh, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_tanh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8525,16 +7667,10 @@ static void iter_dfloat_math_s_asinh(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate asinh(x).
-  @overload asinh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of asinh(x).
-*/
 static VALUE dfloat_math_s_asinh(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_asinh, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_asinh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8603,16 +7739,10 @@ static void iter_dfloat_math_s_acosh(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate acosh(x).
-  @overload acosh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of acosh(x).
-*/
 static VALUE dfloat_math_s_acosh(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_acosh, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_acosh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8681,16 +7811,10 @@ static void iter_dfloat_math_s_atanh(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate atanh(x).
-  @overload atanh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of atanh(x).
-*/
 static VALUE dfloat_math_s_atanh(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_atanh, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_atanh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8759,16 +7883,10 @@ static void iter_dfloat_math_s_sinc(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate sinc(x).
-  @overload sinc(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of sinc(x).
-*/
 static VALUE dfloat_math_s_sinc(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_sinc, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_sinc, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8790,17 +7908,10 @@ static void iter_dfloat_math_s_atan2(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate atan2(a1,a2).
-  @overload atan2(a1,a2)
-  @param [Numo::NArray,Numeric] a1  first value
-  @param [Numo::NArray,Numeric] a2  second value
-  @return [Numo::DFloat] atan2(a1,a2).
-*/
 static VALUE dfloat_math_s_atan2(VALUE mod, VALUE a1, VALUE a2) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_atan2, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_atan2, STRIDE_LOOP, 2, 1, ain, aout };
   return na_ndloop(&ndf, 2, a1, a2);
 }
 
@@ -8821,17 +7932,10 @@ static void iter_dfloat_math_s_hypot(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate hypot(a1,a2).
-  @overload hypot(a1,a2)
-  @param [Numo::NArray,Numeric] a1  first value
-  @param [Numo::NArray,Numeric] a2  second value
-  @return [Numo::DFloat] hypot(a1,a2).
-*/
 static VALUE dfloat_math_s_hypot(VALUE mod, VALUE a1, VALUE a2) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_hypot, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_hypot, STRIDE_LOOP, 2, 1, ain, aout };
   return na_ndloop(&ndf, 2, a1, a2);
 }
 
@@ -8899,16 +8003,10 @@ static void iter_dfloat_math_s_erf(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate erf(x).
-  @overload erf(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of erf(x).
-*/
 static VALUE dfloat_math_s_erf(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_erf, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_erf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -8977,16 +8075,10 @@ static void iter_dfloat_math_s_erfc(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate erfc(x).
-  @overload erfc(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of erfc(x).
-*/
 static VALUE dfloat_math_s_erfc(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_erfc, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_erfc, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -9055,16 +8147,10 @@ static void iter_dfloat_math_s_log1p(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate log1p(x).
-  @overload log1p(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of log1p(x).
-*/
 static VALUE dfloat_math_s_log1p(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_log1p, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_log1p, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -9133,16 +8219,10 @@ static void iter_dfloat_math_s_expm1(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate expm1(x).
-  @overload expm1(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DFloat] result of expm1(x).
-*/
 static VALUE dfloat_math_s_expm1(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_expm1, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_expm1, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -9164,17 +8244,10 @@ static void iter_dfloat_math_s_ldexp(na_loop_t* const lp) {
   }
 }
 
-/*
-  Calculate ldexp(a1,a2).
-  @overload ldexp(a1,a2)
-  @param [Numo::NArray,Numeric] a1  first value
-  @param [Numo::NArray,Numeric] a2  second value
-  @return [Numo::DFloat] ldexp(a1,a2).
-*/
 static VALUE dfloat_math_s_ldexp(VALUE mod, VALUE a1, VALUE a2) {
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_ldexp, STRIDE_LOOP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_ldexp, STRIDE_LOOP, 2, 1, ain, aout };
   return na_ndloop(&ndf, 2, a1, a2);
 }
 
@@ -9196,19 +8269,10 @@ static void iter_dfloat_math_s_frexp(na_loop_t* const lp) {
   }
 }
 
-/*
-  split the number x into a normalized fraction and an exponent.
-  Returns [mantissa, exponent], where x = mantissa * 2**exponent.
-
-  @overload frexp(x)
-  @param [Numo::NArray,Numeric]  x
-  @return [Numo::DFloat,Numo::Int32]  mantissa and exponent.
-
-*/
 static VALUE dfloat_math_s_frexp(VALUE mod, VALUE a1) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[2] = {{cT, 0}, {numo_cInt32, 0}};
-  ndfunc_t ndf = {iter_dfloat_math_s_frexp, STRIDE_LOOP, 1, 2, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[2] = { { cT, 0 }, { numo_cInt32, 0 } };
+  ndfunc_t ndf = { iter_dfloat_math_s_frexp, STRIDE_LOOP, 1, 2, ain, aout };
   return na_ndloop(&ndf, 1, a1);
 }
 
@@ -9232,16 +8296,18 @@ void Init_numo_dfloat(void) {
   id_nearly_eq = rb_intern("nearly_eq");
   id_to_a = rb_intern("to_a");
 
-  /*
-    Document-class: Numo::DFloat
-
-  */
+  /**
+   * 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);
 
@@ -9268,148 +8334,1002 @@ void Init_numo_dfloat(void) {
   rb_hash_aset(hCast, numo_cUInt8, numo_cDFloat);
   rb_obj_freeze(hCast);
 
-  /**/
+  /* Element size of DFloat in bits. */
   rb_define_const(cT, "ELEMENT_BIT_SIZE", INT2FIX(sizeof(dtype) * 8));
-  /**/
+  /* Element size of DFloat in bytes. */
   rb_define_const(cT, "ELEMENT_BYTE_SIZE", INT2FIX(sizeof(dtype)));
-  /**/
+  /* Stride size of contiguous DFloat array. */
   rb_define_const(cT, "CONTIGUOUS_STRIDE", INT2FIX(sizeof(dtype)));
-  /**/
+  /* Machine epsilon of DFloat. */
   rb_define_const(cT, "EPSILON", M_EPSILON);
-  /**/
+  /* The largest representable value of DFloat. */
   rb_define_const(cT, "MAX", M_MAX);
-  /**/
+  /* The smallest representable value of DFloat. */
   rb_define_const(cT, "MIN", M_MIN);
   rb_define_alloc_func(cT, dfloat_s_alloc_func);
   rb_define_method(cT, "allocate", dfloat_allocate, 0);
+  /**
+   * Extract an element only if self is a dimensionless NArray.
+   * @overload extract
+   *   @return [Numeric,Numo::NArray] Extract element value as Ruby Object
+   *     if self is a dimensionless NArray, otherwise returns self.
+   */
   rb_define_method(cT, "extract", dfloat_extract, 0);
-
+  /**
+   * Store elements to Numo::DFloat from other.
+   * @overload store(other)
+   *   @param [Object] other
+   *   @return [Numo::DFloat] self
+   */
   rb_define_method(cT, "store", dfloat_store, 1);
-
+  /**
+   * Cast object to Numo::DFloat.
+   * @overload cast(array)
+   *   @param [Numeric,Array] elements
+   *   @param [Array] array
+   *   @return [Numo::DFloat]
+   */
   rb_define_singleton_method(cT, "cast", dfloat_s_cast, 1);
+  /**
+   * Cast object to Numo::DFloat.
+   * @overload [](elements)
+   *   @param [Numeric,Array] elements
+   *   @param [Array] array
+   *   @return [Numo::DFloat]
+   */
+  rb_define_singleton_method(cT, "[]", dfloat_s_cast, -2);
+  /**
+   * Multi-dimensional element reference.
+   * @overload [](dim0,...,dimL)
+   *   @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,Boolean,Symbol]
+   *     dim0,...,dimL  multi-dimensional indices.
+   *   @return [Numeric,Numo::DFloat] an element or NArray view.
+   * @see Numo::NArray#[]
+   * @see #[]=
+   */
   rb_define_method(cT, "[]", dfloat_aref, -1);
+  /**
+   * Multi-dimensional element assignment.
+   * @overload []=(dim0,...,dimL,val)
+   *   @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,Boolean,Symbol]
+   *     dim0,...,dimL  multi-dimensional indices.
+   *   @param [Numeric,Numo::NArray,Array] val  Value(s) to be set to self.
+   *   @return [Numeric,Numo::NArray,Array] returns `val` (last argument).
+   * @see Numo::NArray#[]=
+   * @see #[]
+   */
   rb_define_method(cT, "[]=", dfloat_aset, -1);
+  /**
+   * Return NArray with cast to the type of self.
+   * @overload coerce_cast(type)
+   *   @return [nil]
+   */
   rb_define_method(cT, "coerce_cast", dfloat_coerce_cast, 1);
+  /**
+   * Convert self to Array.
+   * @overload to_a
+   *   @return [Array]
+   */
   rb_define_method(cT, "to_a", dfloat_to_a, 0);
+  /**
+   * Fill elements with other.
+   * @overload fill other
+   *   @param [Numeric] other
+   *   @return [Numo::DFloat] self.
+   */
   rb_define_method(cT, "fill", dfloat_fill, 1);
+  /**
+   * Format elements into strings.
+   * @overload format format
+   *   @param [String] format
+   *   @return [Numo::RObject] array of formatted strings.
+   */
   rb_define_method(cT, "format", dfloat_format, -1);
+  /**
+   * Format elements into strings.
+   * @overload format_to_a format
+   *   @param [String] format
+   *   @return [Array] array of formatted strings.
+   */
   rb_define_method(cT, "format_to_a", dfloat_format_to_a, -1);
+  /**
+   * Returns a string containing a human-readable representation of NArray.
+   * @overload inspect
+   *   @return [String]
+   */
   rb_define_method(cT, "inspect", dfloat_inspect, 0);
+  /**
+   * Calls the given block once for each element in self,
+   * passing that element as a parameter. For a block `{|x| ... }`,
+   * @overload each
+   *   @return [Numo::NArray] self
+   *   @yieldparam [Numeric] x  an element of NArray.
+   * @see #each_with_index
+   * @see #map
+   */
   rb_define_method(cT, "each", dfloat_each, 0);
+  /**
+   * Unary map.
+   * @overload map
+   *   @return [Numo::DFloat] map of self.
+   */
   rb_define_method(cT, "map", dfloat_map, 0);
+  /**
+   * Invokes the given block once for each element of self, passing that element
+   * and indices along each axis as parameters. For a block `{|x,i,j,...| ... }`,
+   * @overload each_with_index
+   *   @yieldparam [Numeric] x  an element
+   *   @yieldparam [Integer] i,j,...  multitimensional indices
+   *   @return [Numo::NArray] self
+   * @see #each
+   * @see #map_with_index
+   */
   rb_define_method(cT, "each_with_index", dfloat_each_with_index, 0);
+  /**
+   * Invokes the given block once for each element of self,
+   * passing that element and indices along each axis as parameters.
+   * Creates a new NArray containing the values returned by the block.
+   * Inplace option is allowed, i.e., `nary.inplace.map` overwrites `nary`.
+   * For a block `{|x,i,j,...| ... }`,
+   * @overload map_with_index
+   *   @yieldparam [Numeric] x  an element
+   *   @yieldparam [Integer] i,j,...  multitimensional indices
+   *   @return [Numo::NArray] mapped array
+   * @see #map
+   * @see #each_with_index
+   */
   rb_define_method(cT, "map_with_index", dfloat_map_with_index, 0);
+  /**
+   * abs of self.
+   * @overload abs
+   *   @return [Numo::DFloat] abs of self.
+   */
   rb_define_method(cT, "abs", dfloat_abs, 0);
+  /**
+   * Binary add.
+   * @overload + other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] self + other
+   */
   rb_define_method(cT, "+", dfloat_add, 1);
+  /**
+   * Binary sub.
+   * @overload - other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] self - other
+   */
   rb_define_method(cT, "-", dfloat_sub, 1);
+  /**
+   * Binary mul.
+   * @overload * other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] self * other
+   */
   rb_define_method(cT, "*", dfloat_mul, 1);
+  /**
+   * Binary div.
+   * @overload / other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] self / other
+   */
   rb_define_method(cT, "/", dfloat_div, 1);
+  /**
+   * Binary mod.
+   * @overload % other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] self % other
+   */
   rb_define_method(cT, "%", dfloat_mod, 1);
+  /**
+   * Binary divmod.
+   * @overload divmod other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] divmod of self and other.
+   */
   rb_define_method(cT, "divmod", dfloat_divmod, 1);
+  /**
+   * Binary power.
+   * @overload ** other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] self to the other-th power.
+   */
   rb_define_method(cT, "**", dfloat_pow, 1);
   rb_define_alias(cT, "pow", "**");
+  /**
+   * Unary minus.
+   * @overload -@
+   *   @return [Numo::DFloat] minus of self.
+   */
   rb_define_method(cT, "-@", dfloat_minus, 0);
+  /**
+   * Unary reciprocal.
+   * @overload reciprocal
+   *   @return [Numo::DFloat] reciprocal of self.
+   */
   rb_define_method(cT, "reciprocal", dfloat_reciprocal, 0);
+  /**
+   * Unary sign.
+   * @overload sign
+   *   @return [Numo::DFloat] sign of self.
+   */
   rb_define_method(cT, "sign", dfloat_sign, 0);
+  /**
+   * Unary square.
+   * @overload square
+   *   @return [Numo::DFloat] square of self.
+   */
   rb_define_method(cT, "square", dfloat_square, 0);
   rb_define_alias(cT, "conj", "view");
   rb_define_alias(cT, "im", "view");
   rb_define_alias(cT, "conjugate", "conj");
+  /**
+   * Comparison eq other.
+   * @overload eq other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::Bit] result of self eq other.
+   */
   rb_define_method(cT, "eq", dfloat_eq, 1);
+  /**
+   * Comparison ne other.
+   * @overload ne other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::Bit] result of self ne other.
+   */
   rb_define_method(cT, "ne", dfloat_ne, 1);
+  /**
+   * Comparison nearly_eq other.
+   * @overload nearly_eq other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::Bit] result of self nearly_eq other.
+   */
   rb_define_method(cT, "nearly_eq", dfloat_nearly_eq, 1);
   rb_define_alias(cT, "close_to", "nearly_eq");
+  /**
+   * Unary floor.
+   * @overload floor
+   *   @return [Numo::DFloat] floor of self.
+   */
   rb_define_method(cT, "floor", dfloat_floor, 0);
+  /**
+   * Unary round.
+   * @overload round
+   *   @return [Numo::DFloat] round of self.
+   */
   rb_define_method(cT, "round", dfloat_round, 0);
+  /**
+   * Unary ceil.
+   * @overload ceil
+   *   @return [Numo::DFloat] ceil of self.
+   */
   rb_define_method(cT, "ceil", dfloat_ceil, 0);
+  /**
+   * Unary trunc.
+   * @overload trunc
+   *   @return [Numo::DFloat] trunc of self.
+   */
   rb_define_method(cT, "trunc", dfloat_trunc, 0);
+  /**
+   * Unary rint.
+   * @overload rint
+   *   @return [Numo::DFloat] rint of self.
+   */
   rb_define_method(cT, "rint", dfloat_rint, 0);
+  /**
+   * Binary copysign.
+   * @overload copysign other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::NArray] self copysign other
+   */
   rb_define_method(cT, "copysign", dfloat_copysign, 1);
+  /**
+   * Condition of signbit.
+   * @overload signbit
+   *   @return [Numo::Bit] Condition of signbit.
+   */
   rb_define_method(cT, "signbit", dfloat_signbit, 0);
+  /**
+   * modf of self.
+   * @overload modf
+   *   @return [Numo::DFloat] modf of self.
+   */
   rb_define_method(cT, "modf", dfloat_modf, 0);
+  /**
+   * Comparison gt other.
+   * @overload gt other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::Bit] result of self gt other.
+   */
   rb_define_method(cT, "gt", dfloat_gt, 1);
+  /**
+   * Comparison ge other.
+   * @overload ge other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::Bit] result of self ge other.
+   */
   rb_define_method(cT, "ge", dfloat_ge, 1);
+  /**
+   * Comparison lt other.
+   * @overload lt other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::Bit] result of self lt other.
+   */
   rb_define_method(cT, "lt", dfloat_lt, 1);
+  /**
+   * Comparison le other.
+   * @overload le other
+   *   @param [Numo::NArray,Numeric] other
+   *   @return [Numo::Bit] result of self le other.
+   */
   rb_define_method(cT, "le", dfloat_le, 1);
   rb_define_alias(cT, ">", "gt");
   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", dfloat_clip, 2);
+  /**
+   * Condition of isnan.
+   * @overload isnan
+   *   @return [Numo::Bit] Condition of isnan.
+   */
   rb_define_method(cT, "isnan", dfloat_isnan, 0);
+  /**
+   * Condition of isinf.
+   * @overload isinf
+   *   @return [Numo::Bit] Condition of isinf.
+   */
   rb_define_method(cT, "isinf", dfloat_isinf, 0);
+  /**
+   * Condition of isposinf.
+   * @overload isposinf
+   *   @return [Numo::Bit] Condition of isposinf.
+   */
   rb_define_method(cT, "isposinf", dfloat_isposinf, 0);
+  /**
+   * Condition of isneginf.
+   * @overload isneginf
+   *   @return [Numo::Bit] Condition of isneginf.
+   */
   rb_define_method(cT, "isneginf", dfloat_isneginf, 0);
+  /**
+   * Condition of isfinite.
+   * @overload isfinite
+   *   @return [Numo::Bit] Condition of isfinite.
+   */
   rb_define_method(cT, "isfinite", dfloat_isfinite, 0);
+  /**
+   * sum of self.
+   * @overload sum(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] 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 [Boolean] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::DFloat] returns result of sum.
+   */
   rb_define_method(cT, "sum", dfloat_sum, -1);
+  /**
+   * prod of self.
+   * @overload prod(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] 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 [Boolean] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::DFloat] returns result of prod.
+   */
   rb_define_method(cT, "prod", dfloat_prod, -1);
+  /**
+   * kahan_sum of self.
+   * @overload kahan_sum(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] 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 kahan_sum along the axis.
+   *   @param [Boolean] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::DFloat] returns result of kahan_sum.
+   */
   rb_define_method(cT, "kahan_sum", dfloat_kahan_sum, -1);
+  /**
+   * mean of self.
+   * @overload mean(axis: nil, keepdims: false, nan: false)
+   *   @param axis [Numeric, Array, Range] Performs mean along the axis.
+   *   @param keepdims [Boolean] If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @param nan [Boolean] If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or return NaN for min/max etc).
+   *   @return [Numo::DFloat] returns result of mean.
+   */
   rb_define_method(cT, "mean", dfloat_mean, -1);
-  rb_define_method(cT, "stddev", dfloat_stddev, -1);
+  /**
+   * var of self.
+   * @overload var(axis: nil, keepdims: false, nan: false)
+   *   @param axis [Numeric, Array, Range] Performs var along the axis.
+   *   @param keepdims [Boolean] If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @param nan [Boolean] If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @return [Numo::DFloat] returns result of var.
+   */
   rb_define_method(cT, "var", dfloat_var, -1);
+  /**
+   * stddev of self.
+   * @overload stddev(axis: nil, keepdims: false, nan: false)
+   *   @param axis [Numeric, Array, Range] Performs stddev along the axis.
+   *   @param keepdims [Boolean] If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @param nan [Boolean] If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @return [Numo::DFloat] returns result of stddev.
+   */
+  rb_define_method(cT, "stddev", dfloat_stddev, -1);
+  /**
+   * rms of self.
+   * @overload rms(axis: nil, keepdims: false, nan: false)
+   *   @param axis [Numeric, Array, Range] Performs rms along the axis.
+   *   @param keepdims [Boolean] If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @param nan [Boolean] If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
+   *   @return [Numo::DFloat] returns result of rms.
+   */
   rb_define_method(cT, "rms", dfloat_rms, -1);
+  /**
+   * min of self.
+   * @overload min(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] 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 [Boolean] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::DFloat] returns result of min.
+   */
   rb_define_method(cT, "min", dfloat_min, -1);
+  /**
+   * max of self.
+   * @overload max(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] 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 [Boolean] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::DFloat] returns result of max.
+   */
   rb_define_method(cT, "max", dfloat_max, -1);
+  /**
+   * ptp of self.
+   * @overload ptp(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] 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 [Boolean] keepdims  If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @return [Numo::DFloat] returns result of ptp.
+   */
   rb_define_method(cT, "ptp", dfloat_ptp, -1);
+  /**
+   * Index of the maximum value.
+   * @overload max_index(axis:nil, nan:false)
+   *   @param [Boolean] 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", dfloat_max_index, -1);
+  /**
+   * Index of the minimum value.
+   * @overload min_index(axis:nil, nan:false)
+   *   @param [Boolean] 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]
+   */
   rb_define_method(cT, "min_index", dfloat_min_index, -1);
+  /**
+   * Index of the maximum value.
+   * @overload argmax(axis:nil, nan:false)
+   *   @param [Boolean] 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", dfloat_argmax, -1);
+  /**
+   * Index of the minimum value.
+   * @overload argmin(axis:nil, nan:false)
+   *   @param [Boolean] 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", dfloat_argmin, -1);
+  /**
+   * minmax of self.
+   * @overload minmax(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+   *   @param [Numeric,Array,Range] axis  Finds min-max along the axis.
+   *   @param [Boolean] keepdims (keyword) If true, the reduced axes are left
+   *     in the result array as dimensions with size one.
+   *   @return [Numo::DFloat,Numo::DFloat] min and max of self.
+   */
   rb_define_method(cT, "minmax", dfloat_minmax, -1);
+  /**
+   * Element-wise maximum of two arrays.
+   * @overload maximum(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 [Boolean] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+   *   @return [Numo::DFloat]
+   */
   rb_define_module_function(cT, "maximum", dfloat_s_maximum, -1);
+  /**
+   * 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 [Boolean] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+   *   @return [Numo::DFloat]
+   */
   rb_define_module_function(cT, "minimum", dfloat_s_minimum, -1);
+  /**
+   * cumsum of self.
+   * @overload cumsum(axis:nil, nan:false)
+   *   @param [Numeric,Array,Range] axis  Performs cumsum along the axis.
+   *   @param [Boolean] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
+   *   @return [Numo::DFloat] cumsum of self.
+   */
   rb_define_method(cT, "cumsum", dfloat_cumsum, -1);
+  /**
+   * cumprod of self.
+   * @overload cumprod(axis:nil, nan:false)
+   *   @param [Numeric,Array,Range] axis  Performs cumprod along the axis.
+   *   @param [Boolean] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
+   *   @return [Numo::DFloat] cumprod of self.
+   */
   rb_define_method(cT, "cumprod", dfloat_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 [Boolean] keepdims (keyword) If true, the reduced axes are left
+   *     in the result array as dimensions with size one.
+   *   @param [Boolean] 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", dfloat_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::DFloat] 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", dfloat_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::DFloat] 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", dfloat_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::DFloat] eye of self.
+   */
   rb_define_method(cT, "eye", dfloat_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::DFloat] 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", dfloat_rand, -1);
+  /**
+   * Generates random numbers from the normal distribution on self narray
+   * using Box-Muller Transformation.
+   * @overload rand_norm([mu,[sigma]])
+   *   @param [Numeric] mu  mean of normal distribution. (default=0)
+   *   @param [Numeric] sigma  standard deviation of normal distribution. (default=1)
+   *   @return [Numo::DFloat] self.
+   * @example
+   *   Numo::DFloat.new(5,5).rand_norm
+   *   # => Numo::DFloat#shape=[5,5]
+   *   # [[-0.581255, -0.168354, 0.586895, -0.595142, -0.802802],
+   *   #  [-0.326106, 0.282922, 1.68427, 0.918499, -0.0485384],
+   *   #  [-0.464453, -0.992194, 0.413794, -0.60717, -0.699695],
+   *   #  [-1.64168, 0.48676, -0.875871, -1.43275, 0.812172],
+   *   #  [-0.209975, -0.103612, -0.878617, -1.42495, 1.0968]]
+   *
+   *   Numo::DFloat.new(5,5).rand_norm(10,0.1)
+   *   # => Numo::DFloat#shape=[5,5]
+   *   # [[9.9019, 9.90339, 10.0826, 9.98384, 9.72861],
+   *   #  [9.81507, 10.0272, 9.91445, 10.0568, 9.88923],
+   *   #  [10.0234, 9.97874, 9.96011, 9.9006, 9.99964],
+   *   #  [10.0186, 9.94598, 9.92236, 9.99811, 9.97003],
+   *   #  [9.79266, 9.95044, 9.95212, 9.93692, 10.2027]]
+   *
+   *   Numo::DComplex.new(3,3).rand_norm(5+5i)
+   *   # => Numo::DComplex#shape=[3,3]
+   *   # [[5.84303+4.40052i, 4.00984+6.08982i, 5.10979+5.13215i],
+   *   #  [4.26477+3.99655i, 4.90052+5.00763i, 4.46607+2.3444i],
+   *   #  [4.5528+7.11003i, 5.62117+6.69094i, 5.05443+5.35133i]]
+   */
   rb_define_method(cT, "rand_norm", dfloat_rand_norm, -1);
+  /**
+   * Calculate polynomial.
+   *   `x.poly(a0,a1,a2,...,an) = a0 + a1*x + a2*x**2 + ... + an*x**n`
+   * @overload poly a0, a1, ..., an
+   *   @param [Numo::NArray,Numeric] a0,a1,...,an
+   *   @return [Numo::DFloat]
+   */
   rb_define_method(cT, "poly", dfloat_poly, -2);
-
+  /**
+   * sort of self.
+   * @overload sort(axis:nil, nan:false)
+   *   @param [Boolean] nan  If true, propagete NaN. If false, ignore NaN.
+   *   @param [Numeric,Array,Range] axis  Performs sort along the axis.
+   *   @return [Numo::DFloat] returns result of sort.
+   * @example
+   *   Numo::DFloat[3,4,1,2].sort #=> Numo::DFloat[1,2,3,4]
+   */
   rb_define_method(cT, "sort", dfloat_sort, -1);
-
+  /**
+   * sort_index. Returns an index array of sort result.
+   * @overload sort_index(axis:nil, nan:false)
+   *   @param [Boolean] nan  If true, propagete NaN. If false, ignore NaN.
+   *   @param [Numeric,Array,Range] axis  Performs sort_index along the axis.
+   *   @return [Integer,Numo::Int] returns result index of sort_index.
+   * @example
+   *   Numo::NArray[3,4,1,2].sort_index #=> Numo::Int32[2,3,0,1]
+   */
   rb_define_method(cT, "sort_index", dfloat_sort_index, -1);
+  /**
+   * median of self.
+   * @overload median(axis:nil, keepdims:false, nan:false)
+   *   @param [Boolean] nan (keyword) If true, propagete NaN. If false, ignore NaN.
+   *   @param [Numeric,Array,Range] axis  Finds median along the axis.
+   *   @param [Boolean] keepdims  If true, the reduced axes are left
+   *     in the result array as dimensions with size one.
+   * @return [Numo::DFloat] returns median of self.
+   */
   rb_define_method(cT, "median", dfloat_median, -1);
-  rb_define_singleton_method(cT, "[]", dfloat_s_cast, -2);
-
-  /*
-    Document-module: Numo::DFloat::NMath
-
-  */
 
+  /**
+   * Document-module: Numo::DFloat::Math
+   *
+   * This module contains mathematical functions for Numo::DFloat.
+   */
   mTM = rb_define_module_under(cT, "Math");
-
+  /**
+   * Calculate sqrt(x).
+   * @overload sqrt(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of sqrt(x).
+   */
   rb_define_module_function(mTM, "sqrt", dfloat_math_s_sqrt, 1);
+  /**
+   * Calculate cbrt(x).
+   * @overload cbrt(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of cbrt(x).
+   */
   rb_define_module_function(mTM, "cbrt", dfloat_math_s_cbrt, 1);
+  /**
+   * Calculate log(x).
+   * @overload log(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of log(x).
+   */
   rb_define_module_function(mTM, "log", dfloat_math_s_log, 1);
+  /**
+   * Calculate log2(x).
+   * @overload log2(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of log2(x).
+   */
   rb_define_module_function(mTM, "log2", dfloat_math_s_log2, 1);
+  /**
+   * Calculate log10(x).
+   * @overload log10(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of log10(x).
+   */
   rb_define_module_function(mTM, "log10", dfloat_math_s_log10, 1);
+  /**
+   * Calculate exp(x).
+   * @overload exp(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of exp(x).
+   */
   rb_define_module_function(mTM, "exp", dfloat_math_s_exp, 1);
+  /**
+   * Calculate exp2(x).
+   * @overload exp2(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of exp2(x).
+   */
   rb_define_module_function(mTM, "exp2", dfloat_math_s_exp2, 1);
+  /**
+   * Calculate exp10(x).
+   * @overload exp10(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of exp10(x).
+   */
   rb_define_module_function(mTM, "exp10", dfloat_math_s_exp10, 1);
+  /**
+   * Calculate sin(x).
+   * @overload sin(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of sin(x).
+   */
   rb_define_module_function(mTM, "sin", dfloat_math_s_sin, 1);
+  /**
+   * Calculate cos(x).
+   * @overload cos(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of cos(x).
+   */
   rb_define_module_function(mTM, "cos", dfloat_math_s_cos, 1);
+  /**
+   * Calculate tan(x).
+   * @overload tan(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of tan(x).
+   */
   rb_define_module_function(mTM, "tan", dfloat_math_s_tan, 1);
+  /**
+   * Calculate asin(x).
+   * @overload asin(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of asin(x).
+   */
   rb_define_module_function(mTM, "asin", dfloat_math_s_asin, 1);
+  /**
+   * Calculate acos(x).
+   * @overload acos(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of acos(x).
+   */
   rb_define_module_function(mTM, "acos", dfloat_math_s_acos, 1);
+  /**
+   * Calculate atan(x).
+   * @overload atan(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of atan(x).
+   */
   rb_define_module_function(mTM, "atan", dfloat_math_s_atan, 1);
+  /**
+   * Calculate sinh(x).
+   * @overload sinh(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of sinh(x).
+   */
   rb_define_module_function(mTM, "sinh", dfloat_math_s_sinh, 1);
+  /**
+   * Calculate cosh(x).
+   * @overload cosh(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of cosh(x).
+   */
   rb_define_module_function(mTM, "cosh", dfloat_math_s_cosh, 1);
+  /**
+   * Calculate tanh(x).
+   * @overload tanh(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of tanh(x).
+   */
   rb_define_module_function(mTM, "tanh", dfloat_math_s_tanh, 1);
+  /**
+   * Calculate asinh(x).
+   * @overload asinh(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of asinh(x).
+   */
   rb_define_module_function(mTM, "asinh", dfloat_math_s_asinh, 1);
+  /**
+   * Calculate acosh(x).
+   * @overload acosh(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of acosh(x).
+   */
   rb_define_module_function(mTM, "acosh", dfloat_math_s_acosh, 1);
+  /**
+   * Calculate atanh(x).
+   * @overload atanh(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of atanh(x).
+   */
   rb_define_module_function(mTM, "atanh", dfloat_math_s_atanh, 1);
+  /**
+   * Calculate sinc(x).
+   * @overload sinc(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of sinc(x).
+   */
   rb_define_module_function(mTM, "sinc", dfloat_math_s_sinc, 1);
+  /**
+   * Calculate atan2(a1,a2).
+   * @overload atan2(a1,a2)
+   *   @param [Numo::NArray,Numeric] a1  first value
+   *   @param [Numo::NArray,Numeric] a2  second value
+   *   @return [Numo::DFloat] atan2(a1,a2).
+   */
   rb_define_module_function(mTM, "atan2", dfloat_math_s_atan2, 2);
+  /**
+   * Calculate hypot(a1,a2).
+   * @overload hypot(a1,a2)
+   *   @param [Numo::NArray,Numeric] a1  first value
+   *   @param [Numo::NArray,Numeric] a2  second value
+   *   @return [Numo::DFloat] hypot(a1,a2).
+   */
   rb_define_module_function(mTM, "hypot", dfloat_math_s_hypot, 2);
+  /**
+   * Calculate erf(x).
+   * @overload erf(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of erf(x).
+   */
   rb_define_module_function(mTM, "erf", dfloat_math_s_erf, 1);
+  /**
+   * Calculate erfc(x).
+   * @overload erfc(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of erfc(x).
+   */
   rb_define_module_function(mTM, "erfc", dfloat_math_s_erfc, 1);
+  /**
+   * Calculate log1p(x).
+   * @overload log1p(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of log1p(x).
+   */
   rb_define_module_function(mTM, "log1p", dfloat_math_s_log1p, 1);
+  /**
+   * Calculate expm1(x).
+   * @overload expm1(x)
+   *   @param [Numo::NArray,Numeric] x  input value
+   *   @return [Numo::DFloat] result of expm1(x).
+   */
   rb_define_module_function(mTM, "expm1", dfloat_math_s_expm1, 1);
+  /**
+   * Calculate ldexp(a1,a2).
+   * @overload ldexp(a1,a2)
+   *   @param [Numo::NArray,Numeric] a1  first value
+   *   @param [Numo::NArray,Numeric] a2  second value
+   *   @return [Numo::DFloat] ldexp(a1,a2).
+   */
   rb_define_module_function(mTM, "ldexp", dfloat_math_s_ldexp, 2);
+  /**
+   * split the number x into a normalized fraction and an exponent.
+   * Returns [mantissa, exponent], where x = mantissa * 2**exponent.
+   *
+   * @overload frexp(x)
+   *   @param [Numo::NArray,Numeric]  x
+   *   @return [Numo::DFloat,Numo::Int32]  mantissa and exponent.
+   */
   rb_define_module_function(mTM, "frexp", dfloat_math_s_frexp, 1);
 
   //  how to do this?