numo-narray-alt 0.9.4 → 0.9.6

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

@@ -54,14 +54,23 @@ static ID id_truncate;
 
 #include <numo/types/robject.h>
 
-VALUE cT;
-extern VALUE cRT;
-
 /*
   class definition: Numo::RObject
 */
-
 VALUE cT;
+extern VALUE cRT;
+
+#include "mh/mean.h"
+#include "mh/var.h"
+#include "mh/stddev.h"
+#include "mh/rms.h"
+
+typedef VALUE robject; // Type aliases for shorter notation
+                       // following the codebase naming convention.
+DEF_NARRAY_FLT_MEAN_METHOD_FUNC(robject, VALUE, numo_cRObject, numo_cRObject)
+DEF_NARRAY_FLT_VAR_METHOD_FUNC(robject, VALUE, numo_cRObject, numo_cRObject)
+DEF_NARRAY_FLT_STDDEV_METHOD_FUNC(robject, VALUE, numo_cRObject, numo_cRObject)
+DEF_NARRAY_FLT_RMS_METHOD_FUNC(robject, VALUE, numo_cRObject, numo_cRObject)
 
 static VALUE robject_store(VALUE, VALUE);
 
@@ -191,9 +200,9 @@ static VALUE robject_allocate(VALUE 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.
+    @return [Numeric,Numo::NArray]
+    --- Extract element value as Ruby Object if self is a dimensionless NArray,
+    otherwise returns self.
 */
 static VALUE robject_extract(VALUE self) {
   volatile VALUE v;
@@ -277,8 +286,8 @@ static void iter_robject_store_bit(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_bit(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_bit, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_bit, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -326,8 +335,8 @@ static void iter_robject_store_dfloat(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_dfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_dfloat, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_dfloat, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -375,8 +384,8 @@ static void iter_robject_store_sfloat(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_sfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_sfloat, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_sfloat, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -424,8 +433,8 @@ static void iter_robject_store_int64(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_int64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_int64, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_int64, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -473,8 +482,8 @@ static void iter_robject_store_int32(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_int32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_int32, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_int32, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -522,8 +531,8 @@ static void iter_robject_store_int16(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_int16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_int16, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_int16, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -571,8 +580,8 @@ static void iter_robject_store_int8(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_int8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_int8, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_int8, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -620,8 +629,8 @@ static void iter_robject_store_uint64(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_uint64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_uint64, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_uint64, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -669,8 +678,8 @@ static void iter_robject_store_uint32(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_uint32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_uint32, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_uint32, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -718,8 +727,8 @@ static void iter_robject_store_uint16(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_uint16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_uint16, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_uint16, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -767,8 +776,8 @@ static void iter_robject_store_uint8(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_uint8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_uint8, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_uint8, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -816,8 +825,8 @@ static void iter_robject_store_robject(na_loop_t* const lp) {
 }
 
 static VALUE robject_store_robject(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_store_robject, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_store_robject, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -925,8 +934,8 @@ loop_end:
 }
 
 static VALUE robject_store_array(VALUE self, VALUE rary) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {rb_cArray, 0}};
-  ndfunc_t ndf = {iter_robject_store_array, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { rb_cArray, 0 } };
+  ndfunc_t ndf = { iter_robject_store_array, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop_store_rarray(&ndf, self, rary);
   return self;
@@ -935,8 +944,8 @@ static VALUE robject_store_array(VALUE self, VALUE rary) {
 /*
   Store elements to Numo::RObject from other.
   @overload store(other)
-  @param [Object] other
-  @return [Numo::RObject] self
+    @param [Object] other
+    @return [Numo::RObject] self
 */
 static VALUE robject_store(VALUE self, VALUE obj) {
   VALUE r, klass;
@@ -1142,9 +1151,9 @@ static VALUE robject_cast_array(VALUE rary) {
   Cast object to Numo::RObject.
   @overload [](elements)
   @overload cast(array)
-  @param [Numeric,Array] elements
-  @param [Array] array
-  @return [Numo::RObject]
+    @param [Numeric,Array] elements
+    @param [Array] array
+    @return [Numo::RObject]
 */
 static VALUE robject_s_cast(VALUE type, VALUE obj) {
   VALUE v;
@@ -1183,9 +1192,9 @@ static VALUE robject_s_cast(VALUE type, VALUE obj) {
 /*
   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::RObject] an element or NArray view.
+    @param [Numeric,Range,Array,Numo::Int32,Numo::Int64,Numo::Bit,TrueClass,FalseClass,Symbol]
+    dim0,...,dimL  multi-dimensional indices.
+    @return [Numeric,Numo::RObject] an element or NArray view.
   @see Numo::NArray#[]
   @see #[]=
  */
@@ -1206,10 +1215,10 @@ static VALUE robject_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).
+    @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 #[]
 */
@@ -1240,7 +1249,7 @@ static VALUE robject_aset(int argc, VALUE* argv, VALUE self) {
 /*
   return NArray with cast to the type of self.
   @overload coerce_cast(type)
-  @return [nil]
+    @return [nil]
 */
 static VALUE robject_coerce_cast(VALUE self, VALUE type) {
   return Qnil;
@@ -1275,12 +1284,12 @@ static void iter_robject_to_a(na_loop_t* const lp) {
 /*
   Convert self to Array.
   @overload to_a
-  @return [Array]
+    @return [Array]
 */
 static VALUE robject_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_robject_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_robject_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
   return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
 }
 
@@ -1308,12 +1317,12 @@ static void iter_robject_fill(na_loop_t* const lp) {
 /*
   Fill elements with other.
   @overload fill other
-  @param [Numeric] other
-  @return [Numo::RObject] self.
+    @param [Numeric] other
+    @return [Numo::RObject] self.
 */
 static VALUE robject_fill(VALUE self, VALUE val) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {sym_option}};
-  ndfunc_t ndf = {iter_robject_fill, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };
+  ndfunc_t ndf = { iter_robject_fill, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, val);
   return self;
@@ -1362,15 +1371,15 @@ static void iter_robject_format(na_loop_t* const lp) {
 /*
   Format elements into strings.
   @overload format format
-  @param [String] format
-  @return [Numo::RObject] array of formatted strings.
+    @param [String] format
+    @return [Numo::RObject] array of formatted strings.
 */
 static VALUE robject_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_robject_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_robject_format, FULL_LOOP_NIP, 2, 1, ain, aout };
 
   rb_scan_args(argc, argv, "01", &fmt);
   return na_ndloop(&ndf, 2, self, fmt);
@@ -1409,14 +1418,14 @@ static void iter_robject_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.
+    @param [String] format
+    @return [Array] array of formatted strings.
 */
 static VALUE robject_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_robject_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_robject_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);
@@ -1429,7 +1438,7 @@ static VALUE iter_robject_inspect(char* ptr, size_t pos, VALUE fmt) {
 /*
   Returns a string containing a human-readable representation of NArray.
   @overload inspect
-  @return [String]
+    @return [String]
 */
 static VALUE robject_inspect(VALUE ary) {
   return na_ndloop_inspect(ary, iter_robject_inspect, Qnil);
@@ -1463,15 +1472,15 @@ static void iter_robject_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.
+    @return [Numo::NArray] self
+    For a block `{|x| ... }`,
+    @yieldparam [Numeric] x  an element of NArray.
   @see #each_with_index
   @see #map
 */
 static VALUE robject_each(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_each, FULL_LOOP_NIP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_each, FULL_LOOP_NIP, 1, 0, ain, 0 };
 
   na_ndloop(&ndf, 1, self);
   return self;
@@ -1525,12 +1534,12 @@ static void iter_robject_map(na_loop_t* const lp) {
 /*
   Unary map.
   @overload map
-  @return [Numo::RObject] map of self.
+    @return [Numo::RObject] map of self.
 */
 static VALUE robject_map(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_map, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -1584,16 +1593,16 @@ static void iter_robject_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
+    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 robject_each_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{Qnil, 0}};
-  ndfunc_t ndf = {iter_robject_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
+  ndfunc_t ndf = { iter_robject_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0 };
 
   na_ndloop_with_index(&ndf, 1, self);
   return self;
@@ -1675,17 +1684,17 @@ static void iter_robject_map_with_index(na_loop_t* const lp) {
   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
+    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 robject_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_robject_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_robject_map_with_index, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop_with_index(&ndf, 1, self);
 }
@@ -1734,17 +1743,17 @@ static void iter_robject_abs(na_loop_t* const lp) {
 /*
   abs of self.
   @overload abs
-  @return [Numo::RObject] abs of self.
+    @return [Numo::RObject] abs of self.
 */
 static VALUE robject_abs(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_abs, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_add(na_loop_t* const lp) {
@@ -1804,9 +1813,9 @@ static void iter_robject_add(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_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_robject_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_robject_add, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -1814,14 +1823,14 @@ static VALUE robject_add_self(VALUE self, VALUE other) {
 /*
   Binary add.
   @overload + other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self + other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self + other
 */
 static VALUE robject_add(VALUE self, VALUE other) {
   return robject_add_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_sub(na_loop_t* const lp) {
@@ -1881,9 +1890,9 @@ static void iter_robject_sub(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_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_robject_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_robject_sub, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -1891,14 +1900,14 @@ static VALUE robject_sub_self(VALUE self, VALUE other) {
 /*
   Binary sub.
   @overload - other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self - other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self - other
 */
 static VALUE robject_sub(VALUE self, VALUE other) {
   return robject_sub_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_mul(na_loop_t* const lp) {
@@ -1958,9 +1967,9 @@ static void iter_robject_mul(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_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_robject_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_robject_mul, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -1968,17 +1977,17 @@ static VALUE robject_mul_self(VALUE self, VALUE other) {
 /*
   Binary mul.
   @overload * other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self * other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self * other
 */
 static VALUE robject_mul(VALUE self, VALUE other) {
   return robject_mul_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
-  if ((y) == 0) {                                                                                                              \
-    lp->err_type = rb_eZeroDivError;                                                                                           \
-    return;                                                                                                                    \
+#define check_intdivzero(y)                                                                    \
+  if ((y) == 0) {                                                                              \
+    lp->err_type = rb_eZeroDivError;                                                           \
+    return;                                                                                    \
   }
 
 static void iter_robject_div(na_loop_t* const lp) {
@@ -2038,9 +2047,9 @@ static void iter_robject_div(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_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_robject_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_robject_div, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2048,17 +2057,17 @@ static VALUE robject_div_self(VALUE self, VALUE other) {
 /*
   Binary div.
   @overload / other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self / other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self / other
 */
 static VALUE robject_div(VALUE self, VALUE other) {
   return robject_div_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
-  if ((y) == 0) {                                                                                                              \
-    lp->err_type = rb_eZeroDivError;                                                                                           \
-    return;                                                                                                                    \
+#define check_intdivzero(y)                                                                    \
+  if ((y) == 0) {                                                                              \
+    lp->err_type = rb_eZeroDivError;                                                           \
+    return;                                                                                    \
   }
 
 static void iter_robject_mod(na_loop_t* const lp) {
@@ -2118,9 +2127,9 @@ static void iter_robject_mod(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_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_robject_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_robject_mod, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2128,8 +2137,8 @@ static VALUE robject_mod_self(VALUE self, VALUE other) {
 /*
   Binary mod.
   @overload % other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self % other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self % other
 */
 static VALUE robject_mod(VALUE self, VALUE other) {
   return robject_mod_self(self, other);
@@ -2159,9 +2168,9 @@ static void iter_robject_divmod(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_divmod, STRIDE_LOOP, 2, 2, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2169,8 +2178,8 @@ static VALUE robject_divmod_self(VALUE self, VALUE other) {
 /*
   Binary divmod.
   @overload divmod other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] divmod of self and other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] divmod of self and other.
 */
 static VALUE robject_divmod(VALUE self, VALUE other) {
   return robject_divmod_self(self, other);
@@ -2212,11 +2221,11 @@ static void iter_robject_pow_int32(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_pow, STRIDE_LOOP, 2, 1, ain, aout};
-  ndfunc_t ndf_i = {iter_robject_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_robject_pow, STRIDE_LOOP, 2, 1, ain, aout };
+  ndfunc_t ndf_i = { iter_robject_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)) {
@@ -2229,8 +2238,8 @@ static VALUE robject_pow_self(VALUE self, VALUE other) {
 /*
   Binary power.
   @overload ** other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self to the other-th power.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self to the other-th power.
 */
 static VALUE robject_pow(VALUE self, VALUE other) {
   return robject_pow_self(self, other);
@@ -2284,12 +2293,12 @@ static void iter_robject_minus(na_loop_t* const lp) {
 /*
   Unary minus.
   @overload -@
-  @return [Numo::RObject] minus of self.
+    @return [Numo::RObject] minus of self.
 */
 static VALUE robject_minus(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_minus, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2342,12 +2351,12 @@ static void iter_robject_reciprocal(na_loop_t* const lp) {
 /*
   Unary reciprocal.
   @overload reciprocal
-  @return [Numo::RObject] reciprocal of self.
+    @return [Numo::RObject] reciprocal of self.
 */
 static VALUE robject_reciprocal(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_reciprocal, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2400,12 +2409,12 @@ static void iter_robject_sign(na_loop_t* const lp) {
 /*
   Unary sign.
   @overload sign
-  @return [Numo::RObject] sign of self.
+    @return [Numo::RObject] sign of self.
 */
 static VALUE robject_sign(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_sign, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2458,12 +2467,12 @@ static void iter_robject_square(na_loop_t* const lp) {
 /*
   Unary square.
   @overload square
-  @return [Numo::RObject] square of self.
+    @return [Numo::RObject] square of self.
 */
 static VALUE robject_square(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_square, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2490,9 +2499,9 @@ static void iter_robject_eq(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_eq, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2500,8 +2509,8 @@ static VALUE robject_eq_self(VALUE self, VALUE other) {
 /*
   Comparison eq other.
   @overload eq other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self eq other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self eq other.
 */
 static VALUE robject_eq(VALUE self, VALUE other) {
   return robject_eq_self(self, other);
@@ -2529,9 +2538,9 @@ static void iter_robject_ne(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_ne, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2539,8 +2548,8 @@ static VALUE robject_ne_self(VALUE self, VALUE other) {
 /*
   Comparison ne other.
   @overload ne other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self ne other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self ne other.
 */
 static VALUE robject_ne(VALUE self, VALUE other) {
   return robject_ne_self(self, other);
@@ -2568,9 +2577,9 @@ static void iter_robject_nearly_eq(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_nearly_eq, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2578,14 +2587,14 @@ static VALUE robject_nearly_eq_self(VALUE self, VALUE other) {
 /*
   Comparison nearly_eq other.
   @overload nearly_eq other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self nearly_eq other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self nearly_eq other.
 */
 static VALUE robject_nearly_eq(VALUE self, VALUE other) {
   return robject_nearly_eq_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_bit_and(na_loop_t* const lp) {
@@ -2645,9 +2654,9 @@ static void iter_robject_bit_and(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_bit_and_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_robject_bit_and, 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_robject_bit_and, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2655,14 +2664,14 @@ static VALUE robject_bit_and_self(VALUE self, VALUE other) {
 /*
   Binary bit_and.
   @overload & other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self & other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self & other
 */
 static VALUE robject_bit_and(VALUE self, VALUE other) {
   return robject_bit_and_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_bit_or(na_loop_t* const lp) {
@@ -2722,9 +2731,9 @@ static void iter_robject_bit_or(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_bit_or_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_robject_bit_or, 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_robject_bit_or, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2732,14 +2741,14 @@ static VALUE robject_bit_or_self(VALUE self, VALUE other) {
 /*
   Binary bit_or.
   @overload | other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self | other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self | other
 */
 static VALUE robject_bit_or(VALUE self, VALUE other) {
   return robject_bit_or_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_bit_xor(na_loop_t* const lp) {
@@ -2799,9 +2808,9 @@ static void iter_robject_bit_xor(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_bit_xor_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_robject_bit_xor, 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_robject_bit_xor, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2809,8 +2818,8 @@ static VALUE robject_bit_xor_self(VALUE self, VALUE other) {
 /*
   Binary bit_xor.
   @overload ^ other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self ^ other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self ^ other
 */
 static VALUE robject_bit_xor(VALUE self, VALUE other) {
   return robject_bit_xor_self(self, other);
@@ -2864,17 +2873,17 @@ static void iter_robject_bit_not(na_loop_t* const lp) {
 /*
   Unary bit_not.
   @overload ~
-  @return [Numo::RObject] bit_not of self.
+    @return [Numo::RObject] bit_not of self.
 */
 static VALUE robject_bit_not(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_bit_not, 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_robject_bit_not, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_left_shift(na_loop_t* const lp) {
@@ -2934,9 +2943,9 @@ static void iter_robject_left_shift(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_left_shift_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_robject_left_shift, 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_robject_left_shift, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2944,14 +2953,14 @@ static VALUE robject_left_shift_self(VALUE self, VALUE other) {
 /*
   Binary left_shift.
   @overload << other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self << other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self << other
 */
 static VALUE robject_left_shift(VALUE self, VALUE other) {
   return robject_left_shift_self(self, other);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_robject_right_shift(na_loop_t* const lp) {
@@ -3011,9 +3020,9 @@ static void iter_robject_right_shift(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE robject_right_shift_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_robject_right_shift, 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_robject_right_shift, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3021,8 +3030,8 @@ static VALUE robject_right_shift_self(VALUE self, VALUE other) {
 /*
   Binary right_shift.
   @overload >> other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self >> other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self >> other
 */
 static VALUE robject_right_shift(VALUE self, VALUE other) {
   return robject_right_shift_self(self, other);
@@ -3076,12 +3085,12 @@ static void iter_robject_floor(na_loop_t* const lp) {
 /*
   Unary floor.
   @overload floor
-  @return [Numo::RObject] floor of self.
+    @return [Numo::RObject] floor of self.
 */
 static VALUE robject_floor(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_floor, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3134,12 +3143,12 @@ static void iter_robject_round(na_loop_t* const lp) {
 /*
   Unary round.
   @overload round
-  @return [Numo::RObject] round of self.
+    @return [Numo::RObject] round of self.
 */
 static VALUE robject_round(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_round, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3192,12 +3201,12 @@ static void iter_robject_ceil(na_loop_t* const lp) {
 /*
   Unary ceil.
   @overload ceil
-  @return [Numo::RObject] ceil of self.
+    @return [Numo::RObject] ceil of self.
 */
 static VALUE robject_ceil(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_ceil, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3250,12 +3259,12 @@ static void iter_robject_trunc(na_loop_t* const lp) {
 /*
   Unary trunc.
   @overload trunc
-  @return [Numo::RObject] trunc of self.
+    @return [Numo::RObject] trunc of self.
 */
 static VALUE robject_trunc(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_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_robject_trunc, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3282,9 +3291,9 @@ static void iter_robject_gt(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_gt, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3292,8 +3301,8 @@ static VALUE robject_gt_self(VALUE self, VALUE other) {
 /*
   Comparison gt other.
   @overload gt other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self gt other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self gt other.
 */
 static VALUE robject_gt(VALUE self, VALUE other) {
   return robject_gt_self(self, other);
@@ -3321,9 +3330,9 @@ static void iter_robject_ge(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_ge, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3331,8 +3340,8 @@ static VALUE robject_ge_self(VALUE self, VALUE other) {
 /*
   Comparison ge other.
   @overload ge other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self ge other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self ge other.
 */
 static VALUE robject_ge(VALUE self, VALUE other) {
   return robject_ge_self(self, other);
@@ -3360,9 +3369,9 @@ static void iter_robject_lt(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_lt, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3370,8 +3379,8 @@ static VALUE robject_lt_self(VALUE self, VALUE other) {
 /*
   Comparison lt other.
   @overload lt other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self lt other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self lt other.
 */
 static VALUE robject_lt(VALUE self, VALUE other) {
   return robject_lt_self(self, other);
@@ -3399,9 +3408,9 @@ static void iter_robject_le(na_loop_t* const lp) {
 }
 
 static VALUE robject_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_robject_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_robject_le, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3409,8 +3418,8 @@ static VALUE robject_le_self(VALUE self, VALUE other) {
 /*
   Comparison le other.
   @overload le other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self le other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self le other.
 */
 static VALUE robject_le(VALUE self, VALUE other) {
   return robject_le_self(self, other);
@@ -3485,9 +3494,9 @@ static void iter_robject_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.
+    @param [Numo::NArray,Numeric] min
+    @param [Numo::NArray,Numeric] max
+    @return [Numo::NArray] result of clip.
 
   @example
       a = Numo::Int32.new(10).seq
@@ -3512,11 +3521,11 @@ static void iter_robject_clip_max(na_loop_t* const lp) {
       # [3, 4, 2, 3, 4, 5, 6, 7, 8, 8]
 */
 static VALUE robject_clip(VALUE self, VALUE min, VALUE max) {
-  ndfunc_arg_in_t ain[3] = {{Qnil, 0}, {cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf_min = {iter_robject_clip_min, STRIDE_LOOP, 2, 1, ain, aout};
-  ndfunc_t ndf_max = {iter_robject_clip_max, STRIDE_LOOP, 2, 1, ain, aout};
-  ndfunc_t ndf_both = {iter_robject_clip, STRIDE_LOOP, 3, 1, ain, aout};
+  ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf_min = { iter_robject_clip_min, STRIDE_LOOP, 2, 1, ain, aout };
+  ndfunc_t ndf_max = { iter_robject_clip_max, STRIDE_LOOP, 2, 1, ain, aout };
+  ndfunc_t ndf_both = { iter_robject_clip, STRIDE_LOOP, 3, 1, ain, aout };
 
   if (RTEST(min)) {
     if (RTEST(max)) {
@@ -3565,12 +3574,12 @@ static void iter_robject_isnan(na_loop_t* const lp) {
 /*
   Condition of isnan.
   @overload isnan
-  @return [Numo::Bit] Condition of isnan.
+    @return [Numo::Bit] Condition of isnan.
 */
 static VALUE robject_isnan(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_robject_isnan, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isnan, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3607,12 +3616,12 @@ static void iter_robject_isinf(na_loop_t* const lp) {
 /*
   Condition of isinf.
   @overload isinf
-  @return [Numo::Bit] Condition of isinf.
+    @return [Numo::Bit] Condition of isinf.
 */
 static VALUE robject_isinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_robject_isinf, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isinf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3649,12 +3658,12 @@ static void iter_robject_isposinf(na_loop_t* const lp) {
 /*
   Condition of isposinf.
   @overload isposinf
-  @return [Numo::Bit] Condition of isposinf.
+    @return [Numo::Bit] Condition of isposinf.
 */
 static VALUE robject_isposinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_robject_isposinf, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isposinf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3691,12 +3700,12 @@ static void iter_robject_isneginf(na_loop_t* const lp) {
 /*
   Condition of isneginf.
   @overload isneginf
-  @return [Numo::Bit] Condition of isneginf.
+    @return [Numo::Bit] Condition of isneginf.
 */
 static VALUE robject_isneginf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_robject_isneginf, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isneginf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3733,12 +3742,12 @@ static void iter_robject_isfinite(na_loop_t* const lp) {
 /*
   Condition of isfinite.
   @overload isfinite
-  @return [Numo::Bit] Condition of isfinite.
+    @return [Numo::Bit] Condition of isfinite.
 */
 static VALUE robject_isfinite(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_robject_isfinite, FULL_LOOP, 1, 1, ain, aout};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_robject_isfinite, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3769,16 +3778,18 @@ static void iter_robject_sum_nan(na_loop_t* const lp) {
 /*
   sum of self.
   @overload sum(axis:nil, keepdims:false, nan:false)
-  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
-  @param [Numeric,Array,Range] axis  Performs sum along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::RObject] returns result of sum.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
+    return NaN for min/max etc).
+    @param [Numeric,Array,Range] axis  Performs sum along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::RObject] returns result of sum.
 */
 static VALUE robject_sum(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_sum_nan);
 
@@ -3813,16 +3824,18 @@ static void iter_robject_prod_nan(na_loop_t* const lp) {
 /*
   prod of self.
   @overload prod(axis:nil, keepdims:false, nan:false)
-  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
-  @param [Numeric,Array,Range] axis  Performs prod along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::RObject] returns result of prod.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
+    return NaN for min/max etc).
+    @param [Numeric,Array,Range] axis  Performs prod along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::RObject] returns result of prod.
 */
 static VALUE robject_prod(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_prod, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_prod, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_prod_nan);
 
@@ -3831,182 +3844,6 @@ static VALUE robject_prod(int argc, VALUE* argv, VALUE self) {
   return robject_extract(v);
 }
 
-static void iter_robject_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_robject_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::RObject] returns result of mean.
-*/
-static VALUE robject_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_robject_mean, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_mean_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return robject_extract(v);
-}
-
-static void iter_robject_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_robject_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::RObject] returns result of stddev.
-*/
-static VALUE robject_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_robject_stddev, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_stddev_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
-static void iter_robject_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_robject_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::RObject] returns result of var.
-*/
-static VALUE robject_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_robject_var, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_var_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
-static void iter_robject_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_robject_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::RObject] returns result of rms.
-*/
-static VALUE robject_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_robject_rms, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_rms_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
 static void iter_robject_min(na_loop_t* const lp) {
   size_t n;
   char *p1, *p2;
@@ -4033,16 +3870,18 @@ static void iter_robject_min_nan(na_loop_t* const lp) {
 /*
   min of self.
   @overload min(axis:nil, keepdims:false, nan:false)
-  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
-  @param [Numeric,Array,Range] axis  Performs min along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::RObject] returns result of min.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
+    return NaN for min/max etc).
+    @param [Numeric,Array,Range] axis  Performs min along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::RObject] returns result of min.
 */
 static VALUE robject_min(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_min, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_min, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_nan);
 
@@ -4077,16 +3916,18 @@ static void iter_robject_max_nan(na_loop_t* const lp) {
 /*
   max of self.
   @overload max(axis:nil, keepdims:false, nan:false)
-  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
-  @param [Numeric,Array,Range] axis  Performs max along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::RObject] returns result of max.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
+    return NaN for min/max etc).
+    @param [Numeric,Array,Range] axis  Performs max along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::RObject] returns result of max.
 */
 static VALUE robject_max(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_max, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_max, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_nan);
 
@@ -4121,16 +3962,18 @@ static void iter_robject_ptp_nan(na_loop_t* const lp) {
 /*
   ptp of self.
   @overload ptp(axis:nil, keepdims:false, nan:false)
-  @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or, return NaN for min/max etc).
-  @param [Numeric,Array,Range] axis  Performs ptp along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::RObject] returns result of ptp.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN for sum/mean etc, or,
+    return NaN for min/max etc).
+    @param [Numeric,Array,Range] axis  Performs ptp along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::RObject] returns result of ptp.
 */
 static VALUE robject_ptp(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_ptp, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_ptp, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_ptp_nan);
 
@@ -4210,9 +4053,10 @@ static void iter_robject_max_index_index32_nan(na_loop_t* const lp) {
 /*
   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.
+    @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
 
@@ -4229,9 +4073,9 @@ static void iter_robject_max_index_index32_nan(na_loop_t* const lp) {
 static VALUE robject_max_index(int argc, VALUE* argv, VALUE self) {
   narray_t* na;
   VALUE idx, reduce;
-  ndfunc_arg_in_t ain[3] = {{Qnil, 0}, {Qnil, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{0, 0, 0}};
-  ndfunc_t ndf = {0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 3, 1, ain, aout};
+  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) {
@@ -4242,14 +4086,16 @@ static VALUE robject_max_index(int argc, VALUE* argv, VALUE self) {
     idx = nary_new(numo_cInt64, na->ndim, na->shape);
     ndf.func = iter_robject_max_index_index64;
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_index_index64_nan);
+    reduce =
+      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_index_index64_nan);
 
   } else {
     aout[0].type = numo_cInt32;
     idx = nary_new(numo_cInt32, na->ndim, na->shape);
     ndf.func = iter_robject_max_index_index32;
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_index_index32_nan);
+    reduce =
+      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_max_index_index32_nan);
   }
   rb_funcall(idx, rb_intern("seq"), 0);
 
@@ -4327,9 +4173,10 @@ static void iter_robject_min_index_index32_nan(na_loop_t* const lp) {
 /*
   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.
+    @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
 
@@ -4346,9 +4193,9 @@ static void iter_robject_min_index_index32_nan(na_loop_t* const lp) {
 static VALUE robject_min_index(int argc, VALUE* argv, VALUE self) {
   narray_t* na;
   VALUE idx, reduce;
-  ndfunc_arg_in_t ain[3] = {{Qnil, 0}, {Qnil, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{0, 0, 0}};
-  ndfunc_t ndf = {0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 3, 1, ain, aout};
+  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) {
@@ -4359,14 +4206,16 @@ static VALUE robject_min_index(int argc, VALUE* argv, VALUE self) {
     idx = nary_new(numo_cInt64, na->ndim, na->shape);
     ndf.func = iter_robject_min_index_index64;
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_index_index64_nan);
+    reduce =
+      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_index_index64_nan);
 
   } else {
     aout[0].type = numo_cInt32;
     idx = nary_new(numo_cInt32, na->ndim, na->shape);
     ndf.func = iter_robject_min_index_index32;
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_index_index32_nan);
+    reduce =
+      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_min_index_index32_nan);
   }
   rb_funcall(idx, rb_intern("seq"), 0);
 
@@ -4440,9 +4289,10 @@ static void iter_robject_argmax_arg32_nan(na_loop_t* const lp) {
 /*
   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.
+    @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
 
@@ -4459,9 +4309,9 @@ static void iter_robject_argmax_arg32_nan(na_loop_t* const lp) {
 static VALUE robject_argmax(int argc, VALUE* argv, VALUE self) {
   narray_t* na;
   VALUE reduce;
-  ndfunc_arg_in_t ain[2] = {{Qnil, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{0, 0, 0}};
-  ndfunc_t ndf = {0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout};
+  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) {
@@ -4550,9 +4400,10 @@ static void iter_robject_argmin_arg32_nan(na_loop_t* const lp) {
 /*
   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.
+    @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
 
@@ -4569,9 +4420,9 @@ static void iter_robject_argmin_arg32_nan(na_loop_t* const lp) {
 static VALUE robject_argmin(int argc, VALUE* argv, VALUE self) {
   narray_t* na;
   VALUE reduce;
-  ndfunc_arg_in_t ain[2] = {{Qnil, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{0, 0, 0}};
-  ndfunc_t ndf = {0, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 1, ain, aout};
+  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) {
@@ -4625,32 +4476,25 @@ static void iter_robject_minmax_nan(na_loop_t* const lp) {
 /*
   minmax of self.
   @overload minmax(axis:nil, keepdims:false, nan:false)
-  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
-  @param [Numeric,Array,Range] axis  Finds min-max along the axis.
-  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::RObject,Numo::RObject] min and max of self.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+    @param [Numeric,Array,Range] axis  Finds min-max along the axis.
+    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
+    as dimensions with size one.
+    @return [Numo::RObject,Numo::RObject] min and max of self.
 */
 static VALUE robject_minmax(int argc, VALUE* argv, VALUE self) {
   VALUE reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_t ndf = {iter_robject_minmax, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 2, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_t ndf = {
+    iter_robject_minmax, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE | NDF_EXTRACT, 2, 2, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_minmax_nan);
 
   return na_ndloop(&ndf, 2, self, reduce);
 }
 
-/*
-  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::RObject]
-*/
-
 static void iter_robject_s_maximum(na_loop_t* const lp) {
   size_t i, n;
   char *p1, *p2, *p3;
@@ -4693,13 +4537,13 @@ static void iter_robject_s_maximum_nan(na_loop_t* const lp) {
 static VALUE robject_s_maximum(int argc, VALUE* argv, VALUE mod) {
   VALUE a1 = Qnil;
   VALUE a2 = Qnil;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_s_maximum, STRIDE_LOOP_NIP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_s_maximum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
 
   VALUE kw_hash = Qnil;
-  ID kw_table[1] = {id_nan};
-  VALUE opts[1] = {Qundef};
+  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);
@@ -4714,10 +4558,10 @@ static VALUE robject_s_maximum(int argc, VALUE* argv, VALUE mod) {
   Element-wise minimum of two arrays.
 
   @overload minimum(a1, a2, nan:false)
-  @param [Numo::NArray,Numeric] a1  The array to be compared.
-  @param [Numo::NArray,Numeric] a2  The array to be compared.
-  @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
-  @return [Numo::RObject]
+    @param [Numo::NArray,Numeric] a1  The array to be compared.
+    @param [Numo::NArray,Numeric] a2  The array to be compared.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (return NaN if exist).
+    @return [Numo::RObject]
 */
 
 static void iter_robject_s_minimum(na_loop_t* const lp) {
@@ -4762,13 +4606,13 @@ static void iter_robject_s_minimum_nan(na_loop_t* const lp) {
 static VALUE robject_s_minimum(int argc, VALUE* argv, VALUE mod) {
   VALUE a1 = Qnil;
   VALUE a2 = Qnil;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_s_minimum, STRIDE_LOOP_NIP, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { cT, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_s_minimum, STRIDE_LOOP_NIP, 2, 1, ain, aout };
 
   VALUE kw_hash = Qnil;
-  ID kw_table[1] = {id_nan};
-  VALUE opts[1] = {Qundef};
+  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);
@@ -4788,16 +4632,13 @@ static void iter_robject_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_robject_cumsum_nan(na_loop_t* const lp) {
@@ -4809,31 +4650,30 @@ static void iter_robject_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::RObject] cumsum of self.
+    @param [Numeric,Array,Range] axis  Performs cumsum along the axis.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
+    @return [Numo::RObject] cumsum of self.
 */
 static VALUE robject_cumsum(int argc, VALUE* argv, VALUE self) {
   VALUE reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = {
+    iter_robject_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_cumsum_nan);
 
@@ -4849,16 +4689,13 @@ static void iter_robject_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_robject_cumprod_nan(na_loop_t* const lp) {
@@ -4870,31 +4707,30 @@ static void iter_robject_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::RObject] cumprod of self.
+    @param [Numeric,Array,Range] axis  Performs cumprod along the axis.
+    @param [TrueClass] nan  If true, apply NaN-aware algorithm (avoid NaN if exists).
+    @return [Numo::RObject] cumprod of self.
 */
 static VALUE robject_cumprod(int argc, VALUE* argv, VALUE self) {
   VALUE reduce;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {sym_reduce, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { sym_reduce, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = {
+    iter_robject_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_robject_cumprod_nan);
 
@@ -4974,9 +4810,9 @@ static void iter_robject_mulsum_nan(na_loop_t* const lp) {
 static VALUE robject_mulsum_self(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
   VALUE naryv[2];
-  ndfunc_arg_in_t ain[4] = {{cT, 0}, {cT, 0}, {sym_reduce, 0}, {sym_init, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_robject_mulsum, STRIDE_LOOP_NIP, 4, 1, ain, aout};
+  ndfunc_arg_in_t ain[4] = { { cT, 0 }, { cT, 0 }, { sym_reduce, 0 }, { sym_init, 0 } };
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_mulsum, STRIDE_LOOP_NIP, 4, 1, ain, aout };
 
   if (argc < 1) {
     rb_raise(rb_eArgError, "wrong number of arguments (%d for >=1)", argc);
@@ -4996,11 +4832,12 @@ static VALUE robject_mulsum_self(int argc, VALUE* argv, VALUE self) {
   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.
+    @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 robject_mulsum(int argc, VALUE* argv, VALUE self) {
   //
@@ -5059,9 +4896,9 @@ static void iter_robject_seq(na_loop_t* const lp) {
      beg+i*step
   where i is 1-dimensional index.
   @overload seq([beg,[step]])
-  @param [Numeric] beg  beginning of sequence. (default=0)
-  @param [Numeric] step  step of sequence. (default=1)
-  @return [Numo::RObject] self.
+    @param [Numeric] beg  beginning of sequence. (default=0)
+    @param [Numeric] step  step of sequence. (default=1)
+    @return [Numo::RObject] self.
   @example
     Numo::DFloat.new(6).seq(1,-0.2)
     # => Numo::DFloat#shape=[6]
@@ -5071,17 +4908,17 @@ static void iter_robject_seq(na_loop_t* const lp) {
     # => 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 robject_seq(int argc, VALUE* args, VALUE self) {
+static VALUE robject_seq(int argc, VALUE* argv, VALUE self) {
   seq_opt_t* g;
   VALUE vbeg = Qnil, vstep = Qnil;
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 0}};
-  ndfunc_t ndf = {iter_robject_seq, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_robject_seq, FULL_LOOP, 1, 0, ain, 0 };
 
   g = ALLOCA_N(seq_opt_t, 1);
   g->beg = m_zero;
   g->step = m_one;
   g->count = 0;
-  rb_scan_args(argc, args, "02", &vbeg, &vstep);
+  rb_scan_args(argc, argv, "02", &vbeg, &vstep);
   if (vbeg != Qnil) {
     g->beg = m_num_to_data(vbeg);
   }
@@ -5140,10 +4977,10 @@ static void iter_robject_logseq(na_loop_t* const lp) {
   Applicable classes: DFloat, SFloat, DComplex, SCopmplex.
 
   @overload logseq(beg,step,[base])
-  @param [Numeric] beg  The beginning of sequence.
-  @param [Numeric] step  The step of sequence.
-  @param [Numeric] base  The base of log space. (default=10)
-  @return [Numo::RObject] self.
+    @param [Numeric] beg  The beginning of sequence.
+    @param [Numeric] step  The step of sequence.
+    @param [Numeric] base  The base of log space. (default=10)
+    @return [Numo::RObject] self.
 
   @example
     Numo::DFloat.new(5).logseq(4,-1,2)
@@ -5154,14 +4991,14 @@ static void iter_robject_logseq(na_loop_t* const lp) {
     # => Numo::DComplex#shape=[5]
     # [1+7.26156e-310i, 0.5+0.866025i, -0.5+0.866025i, -1+1.22465e-16i, ...]
 */
-static VALUE robject_logseq(int argc, VALUE* args, VALUE self) {
+static VALUE robject_logseq(int argc, VALUE* argv, VALUE self) {
   logseq_opt_t* g;
   VALUE vbeg, vstep, vbase;
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 0}};
-  ndfunc_t ndf = {iter_robject_logseq, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_robject_logseq, FULL_LOOP, 1, 0, ain, 0 };
 
   g = ALLOCA_N(logseq_opt_t, 1);
-  rb_scan_args(argc, args, "21", &vbeg, &vstep, &vbase);
+  rb_scan_args(argc, argv, "21", &vbeg, &vstep, &vbase);
   g->beg = m_num_to_data(vbeg);
   g->step = m_num_to_data(vstep);
   if (vbase == Qnil) {
@@ -5205,15 +5042,15 @@ static void iter_robject_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::RObject] eye of self.
+    @param [Numeric] element  Diagonal element to be stored. Default is 1.
+    @param [Integer] offset Diagonal offset from the main diagonal.  The
+        default is 0. k>0 for diagonals above the main diagonal, and k<0
+        for diagonals below the main diagonal.
+    @return [Numo::RObject] eye of self.
 */
 static VALUE robject_eye(int argc, VALUE* argv, VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 2}};
-  ndfunc_t ndf = {iter_robject_eye, NO_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+  ndfunc_t ndf = { iter_robject_eye, NO_LOOP, 1, 0, ain, 0 };
   ssize_t kofs;
   dtype data;
   char* g;
@@ -5243,17 +5080,21 @@ static VALUE robject_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]
+      );
     }
   }
 
@@ -5302,9 +5143,10 @@ static void iter_robject_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::RObject] self.
+    @param [Numeric] low  lower inclusive boundary of random numbers. (default=0)
+    @param [Numeric] high  upper exclusive boundary of random numbers. (default=1 or 1+1i for
+    complex types)
+    @return [Numo::RObject] self.
   @example
     Numo::DFloat.new(6).rand
     # => Numo::DFloat#shape=[6]
@@ -5318,14 +5160,14 @@ static void iter_robject_rand(na_loop_t* const lp) {
     # => Numo::Int32#shape=[6]
     # [4, 3, 3, 2, 4, 2]
 */
-static VALUE robject_rand(int argc, VALUE* args, VALUE self) {
+static VALUE robject_rand(int argc, VALUE* argv, VALUE self) {
   rand_opt_t g;
   VALUE v1 = Qnil, v2 = Qnil;
   dtype high;
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 0}};
-  ndfunc_t ndf = {iter_robject_rand, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_robject_rand, FULL_LOOP, 1, 0, ain, 0 };
 
-  rb_scan_args(argc, args, "02", &v1, &v2);
+  rb_scan_args(argc, argv, "02", &v1, &v2);
   if (v2 == Qnil) {
     g.low = m_zero;
     if (v1 == Qnil) {
@@ -5366,15 +5208,15 @@ static void iter_robject_poly(na_loop_t* const lp) {
   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::RObject]
+    @param [Numo::NArray,Numeric] a0,a1,...,an
+    @return [Numo::RObject]
 */
 static VALUE robject_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_robject_poly, NO_LOOP, 0, 1, 0, aout};
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_robject_poly, NO_LOOP, 0, 1, 0, aout };
 
   argc = (int)RARRAY_LEN(args);
   ndf.nin = argc + 1;
@@ -5430,13 +5272,15 @@ void Init_numo_robject(void) {
   id_to_a = rb_intern("to_a");
   id_truncate = rb_intern("truncate");
 
-  /*
-    Document-class: Numo::RObject
-
-  */
+  /**
+   * Document-class: Numo::RObject
+   *
+   * Ruby object N-dimensional array class.
+   */
   cT = rb_define_class_under(mNumo, "RObject", cNArray);
 
   hCast = rb_hash_new();
+  /* Upcasting rules of RObject. */
   rb_define_const(cT, "UPCAST", hCast);
   rb_hash_aset(hCast, rb_cArray, cT);
 
@@ -5462,11 +5306,11 @@ void Init_numo_robject(void) {
   rb_hash_aset(hCast, numo_cUInt8, numo_cRObject);
   rb_obj_freeze(hCast);
 
-  /**/
+  /* Element size of RObject in bits. */
   rb_define_const(cT, "ELEMENT_BIT_SIZE", INT2FIX(sizeof(dtype) * 8));
-  /**/
+  /* Element size of RObject in bytes. */
   rb_define_const(cT, "ELEMENT_BYTE_SIZE", INT2FIX(sizeof(dtype)));
-  /**/
+  /* Stride size of contiguous RObject array. */
   rb_define_const(cT, "CONTIGUOUS_STRIDE", INT2FIX(sizeof(dtype)));
   rb_undef_method(rb_singleton_class(cT), "from_binary");
   rb_undef_method(cT, "to_binary");
@@ -5540,9 +5384,49 @@ void Init_numo_robject(void) {
   rb_define_method(cT, "isfinite", robject_isfinite, 0);
   rb_define_method(cT, "sum", robject_sum, -1);
   rb_define_method(cT, "prod", robject_prod, -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::RObject] returns result of mean.
+   */
   rb_define_method(cT, "mean", robject_mean, -1);
-  rb_define_method(cT, "stddev", robject_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::RObject] returns result of var.
+   */
   rb_define_method(cT, "var", robject_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::RObject] returns result of stddev.
+   */
+  rb_define_method(cT, "stddev", robject_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::RObject] returns result of rms.
+   */
   rb_define_method(cT, "rms", robject_rms, -1);
   rb_define_method(cT, "min", robject_min, -1);
   rb_define_method(cT, "max", robject_max, -1);
@@ -5552,7 +5436,23 @@ void Init_numo_robject(void) {
   rb_define_method(cT, "argmax", robject_argmax, -1);
   rb_define_method(cT, "argmin", robject_argmin, -1);
   rb_define_method(cT, "minmax", robject_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::RObject]
+   */
   rb_define_module_function(cT, "maximum", robject_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::RObject]
+   */
   rb_define_module_function(cT, "minimum", robject_s_minimum, -1);
   rb_define_method(cT, "cumsum", robject_cumsum, -1);
   rb_define_method(cT, "cumprod", robject_cumprod, -1);