numo-narray-alt 0.9.4 → 0.9.6

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

@@ -31,11 +31,15 @@ static ID id_to_a;
 VALUE cT;
 extern VALUE cRT;
 
-/*
-  class definition: Numo::Bit
-*/
+#include "mh/mean.h"
+#include "mh/var.h"
+#include "mh/stddev.h"
+#include "mh/rms.h"
 
-VALUE cT;
+DEF_NARRAY_BIT_MEAN_METHOD_FUNC()
+DEF_NARRAY_BIT_VAR_METHOD_FUNC()
+DEF_NARRAY_BIT_STDDEV_METHOD_FUNC()
+DEF_NARRAY_BIT_RMS_METHOD_FUNC()
 
 static VALUE bit_store(VALUE, VALUE);
 
@@ -139,9 +143,9 @@ static VALUE bit_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 bit_extract(VALUE self) {
@@ -255,8 +259,8 @@ static void iter_bit_store_bit(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_bit(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_bit, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_bit, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -311,8 +315,8 @@ static void iter_bit_store_dfloat(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_dfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_dfloat, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_dfloat, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -367,8 +371,8 @@ static void iter_bit_store_sfloat(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_sfloat(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_sfloat, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_sfloat, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -423,8 +427,8 @@ static void iter_bit_store_int64(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_int64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_int64, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_int64, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -479,8 +483,8 @@ static void iter_bit_store_int32(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_int32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_int32, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_int32, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -535,8 +539,8 @@ static void iter_bit_store_int16(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_int16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_int16, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_int16, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -591,8 +595,8 @@ static void iter_bit_store_int8(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_int8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_int8, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_int8, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -647,8 +651,8 @@ static void iter_bit_store_uint64(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_uint64(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_uint64, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_uint64, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -703,8 +707,8 @@ static void iter_bit_store_uint32(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_uint32(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_uint32, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_uint32, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -759,8 +763,8 @@ static void iter_bit_store_uint16(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_uint16(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_uint16, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_uint16, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -815,8 +819,8 @@ static void iter_bit_store_uint8(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_uint8(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_uint8, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_uint8, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -871,8 +875,8 @@ static void iter_bit_store_robject(na_loop_t* const lp) {
 }
 
 static VALUE bit_store_robject(VALUE self, VALUE obj) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_store_robject, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_store_robject, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, obj);
   return self;
@@ -990,8 +994,8 @@ loop_end:
 }
 
 static VALUE bit_store_array(VALUE self, VALUE rary) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {rb_cArray, 0}};
-  ndfunc_t ndf = {iter_bit_store_array, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { rb_cArray, 0 } };
+  ndfunc_t ndf = { iter_bit_store_array, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop_store_rarray(&ndf, self, rary);
   return self;
@@ -1000,8 +1004,8 @@ static VALUE bit_store_array(VALUE self, VALUE rary) {
 /*
   Store elements to Numo::Bit from other.
   @overload store(other)
-  @param [Object] other
-  @return [Numo::Bit] self
+    @param [Object] other
+    @return [Numo::Bit] self
 */
 static VALUE bit_store(VALUE self, VALUE obj) {
   VALUE r, klass;
@@ -1086,8 +1090,10 @@ static VALUE bit_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;
 }
@@ -1181,7 +1187,10 @@ static dtype bit_extract_data(VALUE obj) {
       return bit_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) {
@@ -1208,9 +1217,9 @@ static VALUE bit_cast_array(VALUE rary) {
   Cast object to Numo::Bit.
   @overload [](elements)
   @overload cast(array)
-  @param [Numeric,Array] elements
-  @param [Array] array
-  @return [Numo::Bit]
+    @param [Numeric,Array] elements
+    @param [Array] array
+    @return [Numo::Bit]
 */
 static VALUE bit_s_cast(VALUE type, VALUE obj) {
   VALUE v;
@@ -1250,9 +1259,9 @@ static VALUE bit_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::Bit] 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::Bit] an element or NArray view.
   @see Numo::NArray#[]
   @see #[]=
 
@@ -1297,10 +1306,10 @@ static VALUE bit_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 #[]
 
@@ -1347,7 +1356,7 @@ static VALUE bit_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 bit_coerce_cast(VALUE self, VALUE type) {
   return Qnil;
@@ -1386,12 +1395,12 @@ static void iter_bit_to_a(na_loop_t* const lp) {
 /*
   Convert self to Array.
   @overload to_a
-  @return [Array]
+    @return [Array]
 */
 static VALUE bit_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_bit_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_bit_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };
   return na_ndloop_cast_narray_to_rarray(&ndf, self, Qnil);
 }
 
@@ -1447,12 +1456,12 @@ static void iter_bit_fill(na_loop_t* const lp) {
 /*
   Fill elements with other.
   @overload fill other
-  @param [Numeric] other
-  @return [Numo::Bit] self.
+    @param [Numeric] other
+    @return [Numo::Bit] self.
 */
 static VALUE bit_fill(VALUE self, VALUE val) {
-  ndfunc_arg_in_t ain[2] = {{OVERWRITE, 0}, {sym_option}};
-  ndfunc_t ndf = {iter_bit_fill, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };
+  ndfunc_t ndf = { iter_bit_fill, FULL_LOOP, 2, 0, ain, 0 };
 
   na_ndloop(&ndf, 2, self, val);
   return self;
@@ -1502,15 +1511,15 @@ static void iter_bit_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 bit_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_bit_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_bit_format, FULL_LOOP_NIP, 2, 1, ain, aout };
 
   rb_scan_args(argc, argv, "01", &fmt);
   return na_ndloop(&ndf, 2, self, fmt);
@@ -1550,14 +1559,14 @@ static void iter_bit_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 bit_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_bit_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_bit_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);
@@ -1572,7 +1581,7 @@ static VALUE iter_bit_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 bit_inspect(VALUE ary) {
   return na_ndloop_inspect(ary, iter_bit_inspect, Qnil);
@@ -1609,13 +1618,13 @@ static void iter_bit_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| ... }
-  @yield [x]  x is element of NArray.
+    @return [Numo::NArray] self
+    For a block {|x| ... }
+    @yield [x]  x is element of NArray.
 */
 static VALUE bit_each(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_each, FULL_LOOP_NIP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_each, FULL_LOOP_NIP, 1, 0, ain, 0 };
 
   na_ndloop(&ndf, 1, self);
   return self;
@@ -1671,13 +1680,13 @@ static void iter_bit_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
-  @return [Numo::NArray] self
-  For a block {|x,i,j,...| ... }
-  @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
+    @return [Numo::NArray] self
+    For a block {|x,i,j,...| ... }
+    @yield [x,i,j,...]  x is an element, i,j,... are multidimensional indices.
 */
 static VALUE bit_each_with_index(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_each_with_index, FULL_LOOP_NIP, 1, 0, ain, 0 };
 
   na_ndloop_with_index(&ndf, 1, self);
   return self;
@@ -1767,12 +1776,12 @@ static void iter_bit_copy(na_loop_t* const lp) {
 /*
   Unary copy.
   @overload copy
-  @return [Numo::Bit] copy of self.
+    @return [Numo::Bit] copy of self.
 */
 static VALUE bit_copy(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_bit_copy, 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_bit_copy, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -1861,12 +1870,12 @@ static void iter_bit_not(na_loop_t* const lp) {
 /*
   Unary not.
   @overload not
-  @return [Numo::Bit] not of self.
+    @return [Numo::Bit] not of self.
 */
 static VALUE bit_not(VALUE self) {
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_arg_out_t aout[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_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_bit_not, FULL_LOOP, 1, 1, ain, aout };
 
   return na_ndloop(&ndf, 1, self);
 }
@@ -1989,13 +1998,13 @@ static void iter_bit_and(na_loop_t* const lp) {
 /*
   Binary and.
   @overload & other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] and of self and other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] and of self and other.
 */
 static VALUE bit_and(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_bit_and, FULL_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_bit_and, FULL_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2118,13 +2127,13 @@ static void iter_bit_or(na_loop_t* const lp) {
 /*
   Binary or.
   @overload | other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] or of self and other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] or of self and other.
 */
 static VALUE bit_or(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_bit_or, FULL_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_bit_or, FULL_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2247,13 +2256,13 @@ static void iter_bit_xor(na_loop_t* const lp) {
 /*
   Binary xor.
   @overload ^ other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] xor of self and other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] xor of self and other.
 */
 static VALUE bit_xor(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_bit_xor, FULL_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_bit_xor, FULL_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2376,13 +2385,13 @@ static void iter_bit_eq(na_loop_t* const lp) {
 /*
   Binary eq.
   @overload eq other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] eq of self and other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] eq of self and other.
 */
 static VALUE bit_eq(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_bit_eq, FULL_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_bit_eq, FULL_LOOP, 2, 1, ain, aout };
 
   return na_ndloop(&ndf, 2, self, other);
 }
@@ -2454,16 +2463,17 @@ static void iter_bit_count_true(na_loop_t* const lp) {
   Returns the number of bits.
   If argument is supplied, return Int-array counted along the axes.
   @overload count_true(axis:nil, keepdims:false)
-  @param [Integer,Array,Range] axis (keyword) axes to be counted.
-  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::Int64]
+    @param [Integer,Array,Range] axis (keyword) axes to be counted.
+    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
+    as dimensions with size one.
+    @return [Numo::Int64]
 */
 static VALUE bit_count_true(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
   narray_t* na;
-  ndfunc_arg_in_t ain[3] = {{cT, 0}, {sym_reduce, 0}, {sym_init, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cInt64, 0}};
-  ndfunc_t ndf = {iter_bit_count_true, FULL_LOOP_NIP, 3, 1, ain, aout};
+  ndfunc_arg_in_t ain[3] = { { cT, 0 }, { sym_reduce, 0 }, { sym_init, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cInt64, 0 } };
+  ndfunc_t ndf = { iter_bit_count_true, FULL_LOOP_NIP, 3, 1, ain, aout };
 
   GetNArray(self, na);
   if (NA_SIZE(na) == 0) {
@@ -2541,16 +2551,17 @@ static void iter_bit_count_false(na_loop_t* const lp) {
   Returns the number of bits.
   If argument is supplied, return Int-array counted along the axes.
   @overload count_false(axis:nil, keepdims:false)
-  @param [Integer,Array,Range] axis (keyword) axes to be counted.
-  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::Int64]
+    @param [Integer,Array,Range] axis (keyword) axes to be counted.
+    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
+    as dimensions with size one.
+    @return [Numo::Int64]
 */
 static VALUE bit_count_false(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
   narray_t* na;
-  ndfunc_arg_in_t ain[3] = {{cT, 0}, {sym_reduce, 0}, {sym_init, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cInt64, 0}};
-  ndfunc_t ndf = {iter_bit_count_false, FULL_LOOP_NIP, 3, 1, ain, aout};
+  ndfunc_arg_in_t ain[3] = { { cT, 0 }, { sym_reduce, 0 }, { sym_init, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cInt64, 0 } };
+  ndfunc_t ndf = { iter_bit_count_false, FULL_LOOP_NIP, 3, 1, ain, aout };
 
   GetNArray(self, na);
   if (NA_SIZE(na) == 0) {
@@ -2655,16 +2666,17 @@ static void iter_bit_all_p(na_loop_t* const lp) {
   Return true if all of bits are one (true).
   If argument is supplied, return Bit-array reduced along the axes.
   @overload all?(axis:nil, keepdims:false)
-  @param [Integer,Array,Range] axis (keyword) axes to be reduced.
-  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::Bit] .
+    @param [Integer,Array,Range] axis (keyword) axes to be reduced.
+    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
+    as dimensions with size one.
+    @return [Numo::Bit] .
 */
 static VALUE bit_all_p(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
   narray_t* na;
-  ndfunc_arg_in_t ain[3] = {{cT, 0}, {sym_reduce, 0}, {sym_init, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_bit_all_p, FULL_LOOP_NIP, 3, 1, ain, aout};
+  ndfunc_arg_in_t ain[3] = { { cT, 0 }, { sym_reduce, 0 }, { sym_init, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_bit_all_p, FULL_LOOP_NIP, 3, 1, ain, aout };
 
   GetNArray(self, na);
   if (NA_SIZE(na) == 0) {
@@ -2782,16 +2794,17 @@ static void iter_bit_any_p(na_loop_t* const lp) {
   Return true if any of bits is one (true).
   If argument is supplied, return Bit-array reduced along the axes.
   @overload any?(axis:nil, keepdims:false)
-  @param [Integer,Array,Range] axis (keyword) axes to be reduced.
-  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array as dimensions with size one.
-  @return [Numo::Bit] .
+    @param [Integer,Array,Range] axis (keyword) axes to be reduced.
+    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
+    as dimensions with size one.
+    @return [Numo::Bit] .
 */
 static VALUE bit_any_p(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
   narray_t* na;
-  ndfunc_arg_in_t ain[3] = {{cT, 0}, {sym_reduce, 0}, {sym_init, 0}};
-  ndfunc_arg_out_t aout[1] = {{numo_cBit, 0}};
-  ndfunc_t ndf = {iter_bit_any_p, FULL_LOOP_NIP, 3, 1, ain, aout};
+  ndfunc_arg_in_t ain[3] = { { cT, 0 }, { sym_reduce, 0 }, { sym_init, 0 } };
+  ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };
+  ndfunc_t ndf = { iter_bit_any_p, FULL_LOOP_NIP, 3, 1, ain, aout };
 
   GetNArray(self, na);
   if (NA_SIZE(na) == 0) {
@@ -2882,15 +2895,15 @@ static void iter_bit_where(na_loop_t* const lp) {
 /*
   Returns the array of index where the bit is one (true).
   @overload where
-  @return [Numo::Int32,Numo::Int64]
+    @return [Numo::Int32,Numo::Int64]
 */
 static VALUE bit_where(VALUE self) {
   volatile VALUE idx_1;
   size_t size, n_1;
   where_opt_t* g;
 
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_bit_where, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_bit_where, FULL_LOOP, 1, 0, ain, 0 };
 
   size = RNARRAY_SIZE(self);
   n_1 = NUM2SIZET(bit_count_true(0, NULL, self));
@@ -2966,15 +2979,15 @@ static void iter_bit_where2(na_loop_t* const lp) {
   The first array contains index where the bit is one (true).
   The second array contains index where the bit is zero (false).
   @overload where2
-  @return [Numo::Int32,Numo::Int64]*2
+    @return [Numo::Int32,Numo::Int64]*2
 */
 static VALUE bit_where2(VALUE self) {
   VALUE idx_1, idx_0;
   size_t size, n_1, n_0;
   where_opt_t* g;
 
-  ndfunc_arg_in_t ain[1] = {{cT, 0}};
-  ndfunc_t ndf = {iter_bit_where2, FULL_LOOP, 1, 0, ain, 0};
+  ndfunc_arg_in_t ain[1] = { { cT, 0 } };
+  ndfunc_t ndf = { iter_bit_where2, FULL_LOOP, 1, 0, ain, 0 };
 
   size = RNARRAY_SIZE(self);
   n_1 = NUM2SIZET(bit_count_true(0, NULL, self));
@@ -3080,8 +3093,8 @@ static void shape_error(void) {
 /*
   Return subarray of argument masked with self bit array.
   @overload mask(array)
-  @param [Numo::NArray] array  narray to be masked.
-  @return [Numo::NArray]  view of masked array.
+    @param [Numo::NArray] array  narray to be masked.
+    @return [Numo::NArray]  view of masked array.
 */
 static VALUE bit_mask(VALUE mask, VALUE val) {
   int i;
@@ -3092,8 +3105,8 @@ static VALUE bit_mask(VALUE mask, VALUE val) {
   stridx_t stridx0;
   size_t n_1;
   where_opt_t g;
-  ndfunc_arg_in_t ain[2] = {{cT, 0}, {Qnil, 0}};
-  ndfunc_t ndf = {iter_bit_mask, FULL_LOOP, 2, 0, ain, 0};
+  ndfunc_arg_in_t ain[2] = { { cT, 0 }, { Qnil, 0 } };
+  ndfunc_t ndf = { iter_bit_mask, FULL_LOOP, 2, 0, ain, 0 };
 
   // cast val to NArray
   if (!rb_obj_is_kind_of(val, numo_cNArray)) {
@@ -3159,13 +3172,15 @@ void Init_numo_bit(void) {
   id_ne = rb_intern("ne");
   id_to_a = rb_intern("to_a");
 
-  /*
-    Document-class: Numo::Bit
-
-  */
+  /**
+   * Document-class: Numo::Bit
+   *
+   * Binary digit (bit) N-dimensional array class.
+   */
   cT = rb_define_class_under(mNumo, "Bit", cNArray);
 
   hCast = rb_hash_new();
+  /* Upcasting rules of Bit. */
   rb_define_const(cT, "UPCAST", hCast);
   rb_hash_aset(hCast, rb_cArray, cT);
 
@@ -3192,11 +3207,11 @@ void Init_numo_bit(void) {
   rb_hash_aset(hCast, numo_cUInt8, numo_cUInt8);
   rb_obj_freeze(hCast);
 
-  /**/
+  /* Element size of Bit in bits. */
   rb_define_const(cT, "ELEMENT_BIT_SIZE", INT2FIX(1));
-  /**/
+  /* Element size of Bit in bytes. */
   rb_define_const(cT, "ELEMENT_BYTE_SIZE", rb_float_new(1.0 / 8));
-  /**/
+  /* Stride size of contiguous Bit array. */
   rb_define_const(cT, "CONTIGUOUS_STRIDE", INT2FIX(1));
   rb_define_alloc_func(cT, bit_s_alloc_func);
   rb_define_method(cT, "allocate", bit_allocate, 0);
@@ -3233,4 +3248,48 @@ void Init_numo_bit(void) {
   rb_define_method(cT, "where2", bit_where2, 0);
   rb_define_method(cT, "mask", bit_mask, 1);
   rb_define_singleton_method(cT, "[]", bit_s_cast, -2);
+  /**
+   * mean of self.
+   * @overload mean(axis: nil, keepdims: false, nan: false)
+   *   @param axis [Numeric, Array, Range] Performs mean along the axis.
+   *   @param keepdims [Boolean] If true, the reduced axes are left in the result array as
+   *     dimensions with size one.
+   *   @param nan [Boolean] If true, apply NaN-aware algorithm
+   *     (avoid NaN for sum/mean etc, or return NaN for min/max etc).
+   *   @return [Numo::DFloat] returns result of mean.
+   */
+  rb_define_method(cT, "mean", bit_mean, -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", bit_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", bit_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", bit_rms, -1);
 }