numo-narray-alt 0.9.5 → 0.9.6

data/ext/numo/narray/src/mh/stddev.h

@@ -0,0 +1,103 @@
+/*
+  stddev.h
+  Numo::NArray Alternative
+
+  created on: 2025-10-15
+  Copyright (C) 2025 Atsushi Tatsuma
+*/
+#ifndef NUMO_NARRAY_MH_STDDEV_H
+#define NUMO_NARRAY_MH_STDDEV_H 1
+
+#define DEF_NARRAY_FLT_STDDEV_METHOD_FUNC(tDType, tRtDType, tNAryClass, tRtNAryClass)          \
+  static void iter_##tDType##_stddev(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(tRtDType*)p2 = f_stddev(n, p1, s1);                                                      \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_stddev_nan(na_loop_t* const lp) {                                \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(tRtDType*)p2 = f_stddev_nan(n, p1, s1);                                                  \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_stddev(int argc, VALUE* argv, VALUE self) {                            \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tRtNAryClass, 0 } };                                        \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_stddev, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout               \
+    };                                                                                         \
+    VALUE reduce =                                                                             \
+      na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_stddev_nan);             \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#define DEF_NARRAY_INT_STDDEV_METHOD_FUNC(tDType, tNAryClass)                                  \
+  static void iter_##tDType##_stddev(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(double*)p2 = f_stddev(n, p1, s1);                                                        \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_stddev(int argc, VALUE* argv, VALUE self) {                            \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { numo_cDFloat, 0 } };                                        \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_stddev, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout               \
+    };                                                                                         \
+    VALUE reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                         \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#define DEF_NARRAY_BIT_STDDEV_METHOD_FUNC()                                                    \
+  static void iter_bit_stddev(na_loop_t* const lp) {                                           \
+    size_t n;                                                                                  \
+    BIT_DIGIT* p1;                                                                             \
+    size_t ps1;                                                                                \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    char* p2;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_BIT_IDX(lp, 0, p1, ps1, s1, idx1);                                                \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(double*)p2 = f_stddev(n, p1, ps1, s1, idx1);                                             \
+  }                                                                                            \
+                                                                                               \
+  static VALUE bit_stddev(int argc, VALUE* argv, VALUE self) {                                 \
+    ndfunc_arg_in_t ain[2] = { { numo_cBit, 0 }, { sym_reduce, 0 } };                          \
+    ndfunc_arg_out_t aout[1] = { { numo_cDFloat, 0 } };                                        \
+    ndfunc_t ndf = { iter_bit_stddev, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };    \
+    VALUE reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                         \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#endif // NUMO_NARRAY_MH_STDDEV_H

data/ext/numo/narray/src/mh/var.h

@@ -0,0 +1,102 @@
+/*
+  var.h
+  Numo::NArray Alternative
+
+  created on: 2025-10-15
+  Copyright (C) 2025 Atsushi Tatsuma
+*/
+#ifndef NUMO_NARRAY_MH_VAR_H
+#define NUMO_NARRAY_MH_VAR_H 1
+
+#define DEF_NARRAY_FLT_VAR_METHOD_FUNC(tDType, tRtDType, tNAryClass, tRtNAryClass)             \
+  static void iter_##tDType##_var(na_loop_t* const lp) {                                       \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(tRtDType*)p2 = f_var(n, p1, s1);                                                         \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_var_nan(na_loop_t* const lp) {                                   \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(tRtDType*)p2 = f_var_nan(n, p1, s1);                                                     \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_var(int argc, VALUE* argv, VALUE self) {                               \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tRtNAryClass, 0 } };                                        \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_var, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout                  \
+    };                                                                                         \
+    VALUE reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_var_nan);   \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#define DEF_NARRAY_INT_VAR_METHOD_FUNC(tDType, tNAryClass)                                     \
+  static void iter_##tDType##_var(na_loop_t* const lp) {                                       \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(double*)p2 = f_var(n, p1, s1);                                                           \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_var(int argc, VALUE* argv, VALUE self) {                               \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { numo_cDFloat, 0 } };                                        \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_var, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout                  \
+    };                                                                                         \
+    VALUE reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                         \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#define DEF_NARRAY_BIT_VAR_METHOD_FUNC()                                                       \
+  static void iter_bit_var(na_loop_t* const lp) {                                              \
+    size_t n;                                                                                  \
+    BIT_DIGIT* p1;                                                                             \
+    size_t ps1;                                                                                \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    char* p2;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_BIT_IDX(lp, 0, p1, ps1, s1, idx1);                                                \
+    p2 = NDL_PTR(lp, 1);                                                                       \
+                                                                                               \
+    *(double*)p2 = f_var(n, p1, ps1, s1, idx1);                                                \
+  }                                                                                            \
+                                                                                               \
+  static VALUE bit_var(int argc, VALUE* argv, VALUE self) {                                    \
+    ndfunc_arg_in_t ain[2] = { { numo_cBit, 0 }, { sym_reduce, 0 } };                          \
+    ndfunc_arg_out_t aout[1] = { { numo_cDFloat, 0 } };                                        \
+    ndfunc_t ndf = { iter_bit_var, STRIDE_LOOP_NIP | NDF_FLAT_REDUCE, 2, 1, ain, aout };       \
+    VALUE reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                         \
+    VALUE v = na_ndloop(&ndf, 2, self, reduce);                                                \
+                                                                                               \
+    return rb_funcall(v, rb_intern("extract"), 0);                                             \
+  }
+
+#endif // NUMO_NARRAY_MH_VAR_H

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) {
@@ -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;
@@ -1213,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;
@@ -1255,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 #[]=
 
@@ -1302,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 #[]
 
@@ -1352,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;
@@ -1391,7 +1395,7 @@ 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 } };
@@ -1452,8 +1456,8 @@ 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 } };
@@ -1507,8 +1511,8 @@ 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;
@@ -1555,8 +1559,8 @@ 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;
@@ -1577,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);
@@ -1614,9 +1618,9 @@ 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 } };
@@ -1676,9 +1680,9 @@ 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 } };
@@ -1772,7 +1776,7 @@ 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 } };
@@ -1866,7 +1870,7 @@ 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 } };
@@ -1994,8 +1998,8 @@ 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 } };
@@ -2123,8 +2127,8 @@ 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 } };
@@ -2252,8 +2256,8 @@ 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 } };
@@ -2381,8 +2385,8 @@ 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 } };
@@ -2459,10 +2463,10 @@ 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;
@@ -2547,10 +2551,10 @@ 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;
@@ -2662,10 +2666,10 @@ 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;
@@ -2790,10 +2794,10 @@ 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;
@@ -2891,7 +2895,7 @@ 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;
@@ -2975,7 +2979,7 @@ 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;
@@ -3089,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;
@@ -3168,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);
 
@@ -3201,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);
@@ -3242,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);
 }