numo-narray-alt 0.9.4 → 0.9.6

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

@@ -32,14 +32,21 @@ static ID id_to_a;
 
 #include <numo/types/dcomplex.h>
 
-VALUE cT;
-extern VALUE cRT;
-
 /*
   class definition: Numo::DComplex
 */
-
 VALUE cT;
+extern VALUE cRT;
+
+#include "mh/mean.h"
+#include "mh/var.h"
+#include "mh/stddev.h"
+#include "mh/rms.h"
+
+DEF_NARRAY_FLT_MEAN_METHOD_FUNC(dcomplex, dcomplex, numo_cDComplex, numo_cDComplex)
+DEF_NARRAY_FLT_VAR_METHOD_FUNC(dcomplex, double, numo_cDComplex, numo_cDFloat)
+DEF_NARRAY_FLT_STDDEV_METHOD_FUNC(dcomplex, double, numo_cDComplex, numo_cDFloat)
+DEF_NARRAY_FLT_RMS_METHOD_FUNC(dcomplex, double, numo_cDComplex, numo_cDFloat)
 
 static VALUE dcomplex_store(VALUE, VALUE);
 
@@ -147,8 +154,8 @@ static VALUE dcomplex_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,
+    @return [Numeric,Numo::NArray]
+    --- Extract element value as Ruby Object if self is a dimensionless NArray,
   otherwise returns self.
 */
 static VALUE dcomplex_extract(VALUE self) {
@@ -233,8 +240,8 @@ static void iter_dcomplex_store_bit(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_bit(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_bit, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_bit, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -282,8 +289,8 @@ static void iter_dcomplex_store_dcomplex(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_dcomplex(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_dcomplex, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_dcomplex, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -331,8 +338,8 @@ static void iter_dcomplex_store_scomplex(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_scomplex(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_scomplex, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_scomplex, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -380,8 +387,8 @@ static void iter_dcomplex_store_dfloat(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_dfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_dfloat, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_dfloat, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -429,8 +436,8 @@ static void iter_dcomplex_store_sfloat(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_sfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_sfloat, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_sfloat, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -478,8 +485,8 @@ static void iter_dcomplex_store_int64(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_int64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_int64, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_int64, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -527,8 +534,8 @@ static void iter_dcomplex_store_int32(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_int32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_int32, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_int32, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -576,8 +583,8 @@ static void iter_dcomplex_store_int16(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_int16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_int16, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_int16, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -625,8 +632,8 @@ static void iter_dcomplex_store_int8(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_int8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_int8, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_int8, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -674,8 +681,8 @@ static void iter_dcomplex_store_uint64(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_uint64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_uint64, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_uint64, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -723,8 +730,8 @@ static void iter_dcomplex_store_uint32(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_uint32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_uint32, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_uint32, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -772,8 +779,8 @@ static void iter_dcomplex_store_uint16(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_uint16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_uint16, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_uint16, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -821,8 +828,8 @@ static void iter_dcomplex_store_uint8(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_uint8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_uint8, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_uint8, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -870,8 +877,8 @@ static void iter_dcomplex_store_robject(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_store_robject(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_robject, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_robject, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -979,8 +986,8 @@ loop_end:
 }
 
 static VALUE dcomplex_store_array(VALUE self, VALUE rary) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {rb_cArray, 0}};
-  ndfunc_t ndf = {iter_dcomplex_store_array, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { rb_cArray, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_store_array, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop_store_rarray(&ndf, self, rary);
   return self;
@@ -989,8 +996,8 @@ static VALUE dcomplex_store_array(VALUE self, VALUE rary) {
 /*
   Store elements to Numo::DComplex from other.
   @overload store(other)
-  @param [Object] other
-  @return [Numo::DComplex] self
+    @param [Object] other
+    @return [Numo::DComplex] self
 */
 static VALUE dcomplex_store(VALUE self, VALUE obj) {
   VALUE r, klass;
@@ -1085,8 +1092,10 @@ static VALUE dcomplex_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;
 }
@@ -1196,7 +1205,10 @@ static dtype dcomplex_extract_data(VALUE obj) {
       return dcomplex_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) {
@@ -1223,9 +1235,9 @@ static VALUE dcomplex_cast_array(VALUE rary) {
   Cast object to Numo::DComplex.
   @overload [](elements)
   @overload cast(array)
-  @param [Numeric,Array] elements
-  @param [Array] array
-  @return [Numo::DComplex]
+    @param [Numeric,Array] elements
+    @param [Array] array
+    @return [Numo::DComplex]
 */
 static VALUE dcomplex_s_cast(VALUE type, VALUE obj) {
   VALUE v;
@@ -1265,9 +1277,9 @@ static VALUE dcomplex_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::DComplex] 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::DComplex] an element or NArray view.
   @see Numo::NArray#[]
   @see #[]=
  */
@@ -1288,10 +1300,10 @@ static VALUE dcomplex_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 #[]
 */
@@ -1322,7 +1334,7 @@ static VALUE dcomplex_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 dcomplex_coerce_cast(VALUE self, VALUE type) {
   return Qnil;
@@ -1357,12 +1369,12 @@ static void iter_dcomplex_to_a(na_loop_t* const lp) {
 /*
   Convert self to Array.
   @overload to_a
-  @return [Array]
+    @return [Array]
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
   return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
 }
 
@@ -1390,12 +1402,12 @@ static void iter_dcomplex_fill(na_loop_t* const lp) {
 /*
   Fill elements with other.
   @overload fill other
-  @param [Numeric] other
-  @return [Numo::DComplex] self.
+    @param [Numeric] other
+    @return [Numo::DComplex] self.
 */
 static VALUE dcomplex_fill(VALUE self, VALUE val) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {sym_option}};
-  ndfunc_t ndf = {iter_dcomplex_fill, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };
+  ndfunc_t ndf = { iter_dcomplex_fill, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, val);
   return self;
@@ -1444,15 +1456,15 @@ static void iter_dcomplex_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 dcomplex_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_dcomplex_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_dcomplex_format, FULL_LOOP_NIP, 2, 1, ain, aout };
 
   rb_scan_args(argc, argv, "01", &fmt);
   return na_ndloop(&ndf, 2, self, fmt);
@@ -1491,14 +1503,14 @@ static void iter_dcomplex_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 dcomplex_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_dcomplex_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_dcomplex_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);
@@ -1511,7 +1523,7 @@ static VALUE iter_dcomplex_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 dcomplex_inspect(VALUE ary) {
   return na_ndloop_inspect(ary, iter_dcomplex_inspect, Qnil);
@@ -1545,15 +1557,15 @@ static void iter_dcomplex_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 dcomplex_each(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_each, FULL_LOOP_NIP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_each, FULL_LOOP_NIP, 1, 0, ain, 0 };
 
   na_ndloop(&ndf, 1, self);
   return self;
@@ -1624,12 +1636,12 @@ static void iter_dcomplex_map(na_loop_t* const lp) {
 /*
   Unary map.
   @overload map
-  @return [Numo::DComplex] map of self.
+    @return [Numo::DComplex] map of self.
 */
 static VALUE dcomplex_map(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_map, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -1683,16 +1695,16 @@ static void iter_dcomplex_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 dcomplex_each_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{Qnil, 0}};
-  ndfunc_t ndf = {iter_dcomplex_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0 };
 
   na_ndloop_with_index(&ndf, 1, self);
   return self;
@@ -1774,17 +1786,17 @@ static void iter_dcomplex_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 dcomplex_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_dcomplex_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_dcomplex_map_with_index, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop_with_index(&ndf, 1, self);
 }
@@ -1833,17 +1845,17 @@ static void iter_dcomplex_abs(na_loop_t* const lp) {
 /*
   abs of self.
   @overload abs
-  @return [Numo::DFloat] abs of self.
+    @return [Numo::DFloat] abs of self.
 */
 static VALUE dcomplex_abs(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_abs, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dcomplex_add(na_loop_t* const lp) {
@@ -1858,7 +1870,8 @@ static void iter_dcomplex_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)) {
       if (p1 == p3) { // inplace case
@@ -1875,7 +1888,8 @@ static void iter_dcomplex_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.
@@ -1933,9 +1947,9 @@ static void iter_dcomplex_add(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_add, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -1943,8 +1957,8 @@ static VALUE dcomplex_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 dcomplex_add(VALUE self, VALUE other) {
 
@@ -1959,7 +1973,7 @@ static VALUE dcomplex_add(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dcomplex_sub(na_loop_t* const lp) {
@@ -1974,7 +1988,8 @@ static void iter_dcomplex_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)) {
       if (p1 == p3) { // inplace case
@@ -1991,7 +2006,8 @@ static void iter_dcomplex_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.
@@ -2049,9 +2065,9 @@ static void iter_dcomplex_sub(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_sub, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2059,8 +2075,8 @@ static VALUE dcomplex_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 dcomplex_sub(VALUE self, VALUE other) {
 
@@ -2075,7 +2091,7 @@ static VALUE dcomplex_sub(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dcomplex_mul(na_loop_t* const lp) {
@@ -2090,7 +2106,8 @@ static void iter_dcomplex_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)) {
       if (p1 == p3) { // inplace case
@@ -2107,7 +2124,8 @@ static void iter_dcomplex_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.
@@ -2165,9 +2183,9 @@ static void iter_dcomplex_mul(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_mul, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2175,8 +2193,8 @@ static VALUE dcomplex_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 dcomplex_mul(VALUE self, VALUE other) {
 
@@ -2191,7 +2209,7 @@ static VALUE dcomplex_mul(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dcomplex_div(na_loop_t* const lp) {
@@ -2206,7 +2224,8 @@ static void iter_dcomplex_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)) {
       if (p1 == p3) { // inplace case
@@ -2223,7 +2242,8 @@ static void iter_dcomplex_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.
@@ -2281,9 +2301,9 @@ static void iter_dcomplex_div(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_div, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2291,8 +2311,8 @@ static VALUE dcomplex_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 dcomplex_div(VALUE self, VALUE other) {
 
@@ -2343,11 +2363,11 @@ static void iter_dcomplex_pow_int32(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_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_dcomplex_pow, STRIDE_LOOP, 2, 1, ain, aout};
-  ndfunc_t ndf_i = {iter_dcomplex_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_dcomplex_pow, STRIDE_LOOP, 2, 1, ain, aout };
+  ndfunc_t ndf_i = { iter_dcomplex_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)) {
@@ -2360,8 +2380,8 @@ static VALUE dcomplex_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 dcomplex_pow(VALUE self, VALUE other) {
 
@@ -2440,12 +2460,12 @@ static void iter_dcomplex_minus(na_loop_t* const lp) {
 /*
   Unary minus.
   @overload -@
-  @return [Numo::DComplex] minus of self.
+    @return [Numo::DComplex] minus of self.
 */
 static VALUE dcomplex_minus(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_minus, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2515,12 +2535,12 @@ static void iter_dcomplex_reciprocal(na_loop_t* const lp) {
 /*
   Unary reciprocal.
   @overload reciprocal
-  @return [Numo::DComplex] reciprocal of self.
+    @return [Numo::DComplex] reciprocal of self.
 */
 static VALUE dcomplex_reciprocal(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_reciprocal, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2590,12 +2610,12 @@ static void iter_dcomplex_sign(na_loop_t* const lp) {
 /*
   Unary sign.
   @overload sign
-  @return [Numo::DComplex] sign of self.
+    @return [Numo::DComplex] sign of self.
 */
 static VALUE dcomplex_sign(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_sign, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2665,12 +2685,12 @@ static void iter_dcomplex_square(na_loop_t* const lp) {
 /*
   Unary square.
   @overload square
-  @return [Numo::DComplex] square of self.
+    @return [Numo::DComplex] square of self.
 */
 static VALUE dcomplex_square(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_square, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2740,12 +2760,12 @@ static void iter_dcomplex_conj(na_loop_t* const lp) {
 /*
   Unary conj.
   @overload conj
-  @return [Numo::DComplex] conj of self.
+    @return [Numo::DComplex] conj of self.
 */
 static VALUE dcomplex_conj(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_conj, 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_dcomplex_conj, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2815,12 +2835,12 @@ static void iter_dcomplex_im(na_loop_t* const lp) {
 /*
   Unary im.
   @overload im
-  @return [Numo::DComplex] im of self.
+    @return [Numo::DComplex] im of self.
 */
 static VALUE dcomplex_im(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_im, 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_dcomplex_im, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2869,12 +2889,12 @@ static void iter_dcomplex_real(na_loop_t* const lp) {
 /*
   real of self.
   @overload real
-  @return [Numo::DFloat] real of self.
+    @return [Numo::DFloat] real of self.
 */
 static VALUE dcomplex_real(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_real, 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_dcomplex_real, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2923,12 +2943,12 @@ static void iter_dcomplex_imag(na_loop_t* const lp) {
 /*
   imag of self.
   @overload imag
-  @return [Numo::DFloat] imag of self.
+    @return [Numo::DFloat] imag of self.
 */
 static VALUE dcomplex_imag(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_imag, 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_dcomplex_imag, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -2977,12 +2997,12 @@ static void iter_dcomplex_arg(na_loop_t* const lp) {
 /*
   arg of self.
   @overload arg
-  @return [Numo::DFloat] arg of self.
+    @return [Numo::DFloat] arg of self.
 */
 static VALUE dcomplex_arg(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cRT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_arg, 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_dcomplex_arg, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3033,8 +3053,8 @@ static void iter_dcomplex_set_imag(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_set_imag(VALUE self, VALUE a1) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {cRT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_set_imag, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { cRT, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_set_imag, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, a1);
   return a1;
@@ -3086,8 +3106,8 @@ static void iter_dcomplex_set_real(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_set_real(VALUE self, VALUE a1) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {cRT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_set_real, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { cRT, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_set_real, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, a1);
   return a1;
@@ -3115,9 +3135,9 @@ static void iter_dcomplex_eq(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_eq, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3125,8 +3145,8 @@ static VALUE dcomplex_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 dcomplex_eq(VALUE self, VALUE other) {
 
@@ -3162,9 +3182,9 @@ static void iter_dcomplex_ne(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_ne, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3172,8 +3192,8 @@ static VALUE dcomplex_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 dcomplex_ne(VALUE self, VALUE other) {
 
@@ -3209,9 +3229,9 @@ static void iter_dcomplex_nearly_eq(na_loop_t* const lp) {
 }
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_nearly_eq, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3219,8 +3239,8 @@ static VALUE dcomplex_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 dcomplex_nearly_eq(VALUE self, VALUE other) {
 
@@ -3299,12 +3319,12 @@ static void iter_dcomplex_floor(na_loop_t* const lp) {
 /*
   Unary floor.
   @overload floor
-  @return [Numo::DComplex] floor of self.
+    @return [Numo::DComplex] floor of self.
 */
 static VALUE dcomplex_floor(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_floor, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3374,12 +3394,12 @@ static void iter_dcomplex_round(na_loop_t* const lp) {
 /*
   Unary round.
   @overload round
-  @return [Numo::DComplex] round of self.
+    @return [Numo::DComplex] round of self.
 */
 static VALUE dcomplex_round(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_round, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3449,12 +3469,12 @@ static void iter_dcomplex_ceil(na_loop_t* const lp) {
 /*
   Unary ceil.
   @overload ceil
-  @return [Numo::DComplex] ceil of self.
+    @return [Numo::DComplex] ceil of self.
 */
 static VALUE dcomplex_ceil(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_ceil, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3524,12 +3544,12 @@ static void iter_dcomplex_trunc(na_loop_t* const lp) {
 /*
   Unary trunc.
   @overload trunc
-  @return [Numo::DComplex] trunc of self.
+    @return [Numo::DComplex] trunc of self.
 */
 static VALUE dcomplex_trunc(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_trunc, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3599,17 +3619,17 @@ static void iter_dcomplex_rint(na_loop_t* const lp) {
 /*
   Unary rint.
   @overload rint
-  @return [Numo::DComplex] rint of self.
+    @return [Numo::DComplex] rint of self.
 */
 static VALUE dcomplex_rint(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_rint, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
 
-#define check_intdivzero(y)                                                                                                    \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_dcomplex_copysign(na_loop_t* const lp) {
@@ -3624,7 +3644,8 @@ static void iter_dcomplex_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
@@ -3641,7 +3662,8 @@ static void iter_dcomplex_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.
@@ -3699,9 +3721,9 @@ static void iter_dcomplex_copysign(na_loop_t* const lp) {
 #undef check_intdivzero
 
 static VALUE dcomplex_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_dcomplex_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_dcomplex_copysign, STRIDE_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -3709,8 +3731,8 @@ static VALUE dcomplex_copysign_self(VALUE self, VALUE other) {
 /*
   Binary copysign.
   @overload copysign other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self copysign other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self copysign other
 */
 static VALUE dcomplex_copysign(VALUE self, VALUE other) {
 
@@ -3757,12 +3779,12 @@ static void iter_dcomplex_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 dcomplex_isnan(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_isnan, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3799,12 +3821,12 @@ static void iter_dcomplex_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 dcomplex_isinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_isinf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3841,12 +3863,12 @@ static void iter_dcomplex_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 dcomplex_isposinf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_isposinf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3883,12 +3905,12 @@ static void iter_dcomplex_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 dcomplex_isneginf(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_isneginf, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3925,12 +3947,12 @@ static void iter_dcomplex_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 dcomplex_isfinite(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_dcomplex_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_dcomplex_isfinite, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -3961,16 +3983,18 @@ static void iter_dcomplex_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::DComplex] 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::DComplex] returns result of sum.
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_sum_nan);
 
@@ -4005,16 +4029,18 @@ static void iter_dcomplex_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::DComplex] 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::DComplex] returns result of prod.
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_prod, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_prod_nan);
 
@@ -4049,16 +4075,20 @@ static void iter_dcomplex_kahan_sum_nan(na_loop_t* const lp) {
 /*
   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::DComplex] returns result of kahan_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 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::DComplex] returns result of kahan_sum.
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_kahan_sum, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_kahan_sum_nan);
 
@@ -4067,182 +4097,6 @@ static VALUE dcomplex_kahan_sum(int argc, VALUE* argv, VALUE self) {
   return dcomplex_extract(v);
 }
 
-static void iter_dcomplex_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_dcomplex_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::DComplex] returns result of mean.
-*/
-static VALUE dcomplex_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_dcomplex_mean, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_mean_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return dcomplex_extract(v);
-}
-
-static void iter_dcomplex_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_dcomplex_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::DComplex] returns result of stddev.
-*/
-static VALUE dcomplex_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_dcomplex_stddev, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_stddev_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
-static void iter_dcomplex_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_dcomplex_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::DComplex] returns result of var.
-*/
-static VALUE dcomplex_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_dcomplex_var, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_var_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
-static void iter_dcomplex_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_dcomplex_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::DComplex] returns result of rms.
-*/
-static VALUE dcomplex_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_dcomplex_rms, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout};
-
-  reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_rms_nan);
-
-  v = na_ndloop(&ndf, 2, self, reduce);
-
-  return rb_funcall(v, rb_intern("extract"), 0);
-}
-
 static void iter_dcomplex_cumsum(na_loop_t* const lp) {
   size_t i;
   char *p1, *p2;
@@ -4252,16 +4106,13 @@ static void iter_dcomplex_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_dcomplex_cumsum_nan(na_loop_t* const lp) {
@@ -4273,31 +4124,30 @@ static void iter_dcomplex_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::DComplex] 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::DComplex] cumsum of self.
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_cumsum_nan);
 
@@ -4313,16 +4163,13 @@ static void iter_dcomplex_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_dcomplex_cumprod_nan(na_loop_t* const lp) {
@@ -4334,31 +4181,30 @@ static void iter_dcomplex_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::DComplex] 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::DComplex] cumprod of self.
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout
+  };
 
   reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_dcomplex_cumprod_nan);
 
@@ -4438,9 +4284,9 @@ static void iter_dcomplex_mulsum_nan(na_loop_t* const lp) {
 static VALUE dcomplex_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_dcomplex_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_dcomplex_mulsum, STRIDE_LOOP_NIP, 4, 1, ain, aout };
 
   if (argc < 1) {
     rb_raise(rb_eArgError, "wrong number of arguments (%d for >=1)", argc);
@@ -4460,11 +4306,12 @@ static VALUE dcomplex_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 dcomplex_mulsum(int argc, VALUE* argv, VALUE self) {
   //
@@ -4533,9 +4380,9 @@ static void iter_dcomplex_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::DComplex] self.
+    @param [Numeric] beg  beginning of sequence. (default=0)
+    @param [Numeric] step  step of sequence. (default=1)
+    @return [Numo::DComplex] self.
   @example
     Numo::DFloat.new(6).seq(1,-0.2)
     # => Numo::DFloat#shape=[6]
@@ -4545,17 +4392,17 @@ static void iter_dcomplex_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 dcomplex_seq(int argc, VALUE* args, VALUE self) {
+static VALUE dcomplex_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_dcomplex_seq, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_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);
   }
@@ -4614,10 +4461,10 @@ static void iter_dcomplex_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::DComplex] 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::DComplex] self.
 
   @example
     Numo::DFloat.new(5).logseq(4,-1,2)
@@ -4628,14 +4475,14 @@ static void iter_dcomplex_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 dcomplex_logseq(int argc, VALUE* args, VALUE self) {
+static VALUE dcomplex_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_dcomplex_logseq, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_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) {
@@ -4679,15 +4526,15 @@ static void iter_dcomplex_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::DComplex] 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::DComplex] eye of self.
 */
 static VALUE dcomplex_eye(int argc, VALUE* argv, VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{OVERWRITE, 2}};
-  ndfunc_t ndf = {iter_dcomplex_eye, NO_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
+  ndfunc_t ndf = { iter_dcomplex_eye, NO_LOOP, 1, 0, ain, 0 };
   ssize_t kofs;
   dtype data;
   char* g;
@@ -4717,17 +4564,21 @@ static VALUE dcomplex_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]
+      );
     }
   }
 
@@ -4776,9 +4627,10 @@ static void iter_dcomplex_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::DComplex] 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::DComplex] self.
   @example
     Numo::DFloat.new(6).rand
     # => Numo::DFloat#shape=[6]
@@ -4792,14 +4644,14 @@ static void iter_dcomplex_rand(na_loop_t* const lp) {
     # => Numo::Int32#shape=[6]
     # [4, 3, 3, 2, 4, 2]
 */
-static VALUE dcomplex_rand(int argc, VALUE* args, VALUE self) {
+static VALUE dcomplex_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_dcomplex_rand, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_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) {
@@ -4865,9 +4717,9 @@ static void iter_dcomplex_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::DComplex] self.
+    @param [Numeric] mu  mean of normal distribution. (default=0)
+    @param [Numeric] sigma  standard deviation of normal distribution. (default=1)
+    @return [Numo::DComplex] self.
   @example
     Numo::DFloat.new(5,5).rand_norm
     # => Numo::DFloat#shape=[5,5]
@@ -4891,14 +4743,14 @@ static void iter_dcomplex_rand_norm(na_loop_t* const lp) {
     #  [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 dcomplex_rand_norm(int argc, VALUE* args, VALUE self) {
+static VALUE dcomplex_rand_norm(int argc, VALUE* argv, 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_dcomplex_rand_norm, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_rand_norm, FULL_LOOP, 1, 0, ain, 0 };
 
-  n = rb_scan_args(argc, args, "02", &v1, &v2);
+  n = rb_scan_args(argc, argv, "02", &v1, &v2);
   if (n == 0) {
     g.mu = m_zero;
   } else {
@@ -4933,15 +4785,15 @@ static void iter_dcomplex_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::DComplex]
+    @param [Numo::NArray,Numeric] a0,a1,...,an
+    @return [Numo::DComplex]
 */
 static VALUE dcomplex_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_dcomplex_poly, NO_LOOP, 0, 1, 0, aout};
+  ndfunc_arg_out_t aout[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_dcomplex_poly, NO_LOOP, 0, 1, 0, aout };
 
   argc = (int)RARRAY_LEN(args);
   ndf.nin = argc + 1;
@@ -4959,10 +4811,6 @@ static VALUE dcomplex_poly(VALUE self, VALUE args) {
   return dcomplex_extract(v);
 }
 
-/*
-  module definition: Numo::DComplex::NMath
-*/
-
 VALUE mTM;
 
 static void iter_dcomplex_math_s_sqrt(na_loop_t* const lp) {
@@ -5032,13 +4880,13 @@ static void iter_dcomplex_math_s_sqrt(na_loop_t* const lp) {
 /*
   Calculate sqrt(x).
   @overload sqrt(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of sqrt(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of sqrt(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_sqrt, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5110,13 +4958,13 @@ static void iter_dcomplex_math_s_cbrt(na_loop_t* const lp) {
 /*
   Calculate cbrt(x).
   @overload cbrt(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of cbrt(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of cbrt(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_cbrt, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5188,13 +5036,13 @@ static void iter_dcomplex_math_s_log(na_loop_t* const lp) {
 /*
   Calculate log(x).
   @overload log(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of log(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of log(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_log, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5266,13 +5114,13 @@ static void iter_dcomplex_math_s_log2(na_loop_t* const lp) {
 /*
   Calculate log2(x).
   @overload log2(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of log2(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of log2(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_log2, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5344,13 +5192,13 @@ static void iter_dcomplex_math_s_log10(na_loop_t* const lp) {
 /*
   Calculate log10(x).
   @overload log10(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of log10(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of log10(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_log10, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5422,13 +5270,13 @@ static void iter_dcomplex_math_s_exp(na_loop_t* const lp) {
 /*
   Calculate exp(x).
   @overload exp(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of exp(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of exp(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_exp, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5500,13 +5348,13 @@ static void iter_dcomplex_math_s_exp2(na_loop_t* const lp) {
 /*
   Calculate exp2(x).
   @overload exp2(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of exp2(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of exp2(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_exp2, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5578,13 +5426,13 @@ static void iter_dcomplex_math_s_exp10(na_loop_t* const lp) {
 /*
   Calculate exp10(x).
   @overload exp10(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of exp10(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of exp10(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_exp10, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5656,13 +5504,13 @@ static void iter_dcomplex_math_s_sin(na_loop_t* const lp) {
 /*
   Calculate sin(x).
   @overload sin(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of sin(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of sin(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_sin, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5734,13 +5582,13 @@ static void iter_dcomplex_math_s_cos(na_loop_t* const lp) {
 /*
   Calculate cos(x).
   @overload cos(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of cos(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of cos(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_cos, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5812,13 +5660,13 @@ static void iter_dcomplex_math_s_tan(na_loop_t* const lp) {
 /*
   Calculate tan(x).
   @overload tan(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of tan(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of tan(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_tan, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5890,13 +5738,13 @@ static void iter_dcomplex_math_s_asin(na_loop_t* const lp) {
 /*
   Calculate asin(x).
   @overload asin(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of asin(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of asin(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_asin, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -5968,13 +5816,13 @@ static void iter_dcomplex_math_s_acos(na_loop_t* const lp) {
 /*
   Calculate acos(x).
   @overload acos(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of acos(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of acos(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_acos, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6046,13 +5894,13 @@ static void iter_dcomplex_math_s_atan(na_loop_t* const lp) {
 /*
   Calculate atan(x).
   @overload atan(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of atan(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of atan(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_atan, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6124,13 +5972,13 @@ static void iter_dcomplex_math_s_sinh(na_loop_t* const lp) {
 /*
   Calculate sinh(x).
   @overload sinh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of sinh(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of sinh(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_sinh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6202,13 +6050,13 @@ static void iter_dcomplex_math_s_cosh(na_loop_t* const lp) {
 /*
   Calculate cosh(x).
   @overload cosh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of cosh(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of cosh(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_cosh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6280,13 +6128,13 @@ static void iter_dcomplex_math_s_tanh(na_loop_t* const lp) {
 /*
   Calculate tanh(x).
   @overload tanh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of tanh(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of tanh(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_tanh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6358,13 +6206,13 @@ static void iter_dcomplex_math_s_asinh(na_loop_t* const lp) {
 /*
   Calculate asinh(x).
   @overload asinh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of asinh(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of asinh(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_asinh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6436,13 +6284,13 @@ static void iter_dcomplex_math_s_acosh(na_loop_t* const lp) {
 /*
   Calculate acosh(x).
   @overload acosh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of acosh(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of acosh(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_acosh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6514,13 +6362,13 @@ static void iter_dcomplex_math_s_atanh(na_loop_t* const lp) {
 /*
   Calculate atanh(x).
   @overload atanh(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of atanh(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of atanh(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_atanh, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6592,13 +6440,13 @@ static void iter_dcomplex_math_s_sinc(na_loop_t* const lp) {
 /*
   Calculate sinc(x).
   @overload sinc(x)
-  @param [Numo::NArray,Numeric] x  input value
-  @return [Numo::DComplex] result of sinc(x).
+    @param [Numo::NArray,Numeric] x  input value
+    @return [Numo::DComplex] result of sinc(x).
 */
 static VALUE dcomplex_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_dcomplex_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_dcomplex_math_s_sinc, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, a1);
 }
@@ -6619,16 +6467,18 @@ void Init_numo_dcomplex(void) {
   id_real = rb_intern("real");
   id_to_a = rb_intern("to_a");
 
-  /*
-    Document-class: Numo::DComplex
-
-  */
+  /**
+   * Document-class: Numo::DComplex
+   *
+   * Double precision floating point complex number N-dimensional array class.
+   */
   cT = rb_define_class_under(mNumo, "DComplex", cNArray);
 
   // alias of DComplex
   rb_define_const(mNumo, "Complex64", numo_cDComplex);
 
   hCast = rb_hash_new();
+  /* Upcasting rules of DComplex. */
   rb_define_const(cT, "UPCAST", hCast);
   rb_hash_aset(hCast, rb_cArray, cT);
 
@@ -6655,17 +6505,17 @@ void Init_numo_dcomplex(void) {
   rb_hash_aset(hCast, numo_cUInt8, numo_cDComplex);
   rb_obj_freeze(hCast);
 
-  /**/
+  /* Element size of DComplex in bits. */
   rb_define_const(cT, "ELEMENT_BIT_SIZE", INT2FIX(sizeof(dtype) * 8));
-  /**/
+  /* Element size of DComplex in bytes. */
   rb_define_const(cT, "ELEMENT_BYTE_SIZE", INT2FIX(sizeof(dtype)));
-  /**/
+  /* Stride size of contiguous DComplex array. */
   rb_define_const(cT, "CONTIGUOUS_STRIDE", INT2FIX(sizeof(dtype)));
-  /**/
+  /* Machine epsilon of DComplex. */
   rb_define_const(cT, "EPSILON", M_EPSILON);
-  /**/
+  /* The largest representable value of DComplex. */
   rb_define_const(cT, "MAX", M_MAX);
-  /**/
+  /* The smallest representable value of DComplex. */
   rb_define_const(cT, "MIN", M_MIN);
   rb_define_alloc_func(cT, dcomplex_s_alloc_func);
   rb_define_method(cT, "allocate", dcomplex_allocate, 0);
@@ -6726,9 +6576,49 @@ void Init_numo_dcomplex(void) {
   rb_define_method(cT, "sum", dcomplex_sum, -1);
   rb_define_method(cT, "prod", dcomplex_prod, -1);
   rb_define_method(cT, "kahan_sum", dcomplex_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::DComplex] returns result of mean.
+   */
   rb_define_method(cT, "mean", dcomplex_mean, -1);
-  rb_define_method(cT, "stddev", dcomplex_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", dcomplex_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", dcomplex_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", dcomplex_rms, -1);
   rb_define_method(cT, "cumsum", dcomplex_cumsum, -1);
   rb_define_method(cT, "cumprod", dcomplex_cumprod, -1);
@@ -6742,11 +6632,11 @@ void Init_numo_dcomplex(void) {
   rb_define_method(cT, "poly", dcomplex_poly, -2);
   rb_define_singleton_method(cT, "[]", dcomplex_s_cast, -2);
 
-  /*
-    Document-module: Numo::DComplex::NMath
-
-  */
-
+  /**
+   * Document-module: Numo::DComplex::Math
+   *
+   * This module contains mathematical functions for Numo::DComplex.
+   */
   mTM = rb_define_module_under(cT, "Math");
 
   rb_define_module_function(mTM, "sqrt", dcomplex_math_s_sqrt, 1);