numo-narray-alt 0.9.5 → 0.9.6

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

@@ -37,14 +37,23 @@ static ID id_to_a;
 
 #include <numo/types/uint8.h>
 
-VALUE cT;
-extern VALUE cRT;
-
 /*
   class definition: Numo::UInt8
 */
-
 VALUE cT;
+extern VALUE cRT;
+
+#include "mh/mean.h"
+#include "mh/var.h"
+#include "mh/stddev.h"
+#include "mh/rms.h"
+
+typedef u_int8_t uint8; // Type aliases for shorter notation
+                        // following the codebase naming convention.
+DEF_NARRAY_INT_MEAN_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_INT_VAR_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_INT_STDDEV_METHOD_FUNC(uint8, numo_cUInt8)
+DEF_NARRAY_INT_RMS_METHOD_FUNC(uint8, numo_cUInt8)
 
 static VALUE uint8_store(VALUE, VALUE);
 
@@ -152,9 +161,9 @@ static VALUE uint8_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 uint8_extract(VALUE self) {
   volatile VALUE v;
@@ -896,8 +905,8 @@ static VALUE uint8_store_array(VALUE self, VALUE rary) {
 /*
   Store elements to Numo::UInt8 from other.
   @overload store(other)
-  @param [Object] other
-  @return [Numo::UInt8] self
+    @param [Object] other
+    @return [Numo::UInt8] self
 */
 static VALUE uint8_store(VALUE self, VALUE obj) {
   VALUE r, klass;
@@ -1109,9 +1118,9 @@ static VALUE uint8_cast_array(VALUE rary) {
   Cast object to Numo::UInt8.
   @overload [](elements)
   @overload cast(array)
-  @param [Numeric,Array] elements
-  @param [Array] array
-  @return [Numo::UInt8]
+    @param [Numeric,Array] elements
+    @param [Array] array
+    @return [Numo::UInt8]
 */
 static VALUE uint8_s_cast(VALUE type, VALUE obj) {
   VALUE v;
@@ -1151,9 +1160,9 @@ static VALUE uint8_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::UInt8] 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::UInt8] an element or NArray view.
   @see Numo::NArray#[]
   @see #[]=
  */
@@ -1174,10 +1183,10 @@ static VALUE uint8_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 #[]
 */
@@ -1208,7 +1217,7 @@ static VALUE uint8_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 uint8_coerce_cast(VALUE self, VALUE type) {
   return Qnil;
@@ -1243,7 +1252,7 @@ static void iter_uint8_to_a(na_loop_t* const lp) {
 /*
   Convert self to Array.
   @overload to_a
-  @return [Array]
+    @return [Array]
 */
 static VALUE uint8_to_a(VALUE self) {
   ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };
@@ -1276,8 +1285,8 @@ static void iter_uint8_fill(na_loop_t* const lp) {
 /*
   Fill elements with other.
   @overload fill other
-  @param [Numeric] other
-  @return [Numo::UInt8] self.
+    @param [Numeric] other
+    @return [Numo::UInt8] self.
 */
 static VALUE uint8_fill(VALUE self, VALUE val) {
   ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };
@@ -1330,8 +1339,8 @@ static void iter_uint8_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 uint8_format(int argc, VALUE* argv, VALUE self) {
   VALUE fmt = Qnil;
@@ -1377,8 +1386,8 @@ static void iter_uint8_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 uint8_format_to_a(int argc, VALUE* argv, VALUE self) {
   VALUE fmt = Qnil;
@@ -1397,7 +1406,7 @@ static VALUE iter_uint8_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 uint8_inspect(VALUE ary) {
   return na_ndloop_inspect(ary, iter_uint8_inspect, Qnil);
@@ -1431,9 +1440,9 @@ static void iter_uint8_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
 */
@@ -1493,7 +1502,7 @@ static void iter_uint8_map(na_loop_t* const lp) {
 /*
   Unary map.
   @overload map
-  @return [Numo::UInt8] map of self.
+    @return [Numo::UInt8] map of self.
 */
 static VALUE uint8_map(VALUE self) {
   ndfunc_arg_in_t ain[1] = { { cT, 0 } };
@@ -1552,10 +1561,10 @@ static void iter_uint8_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
 */
@@ -1643,10 +1652,10 @@ static void iter_uint8_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
 */
@@ -1702,7 +1711,7 @@ static void iter_uint8_abs(na_loop_t* const lp) {
 /*
   abs of self.
   @overload abs
-  @return [Numo::UInt8] abs of self.
+    @return [Numo::UInt8] abs of self.
 */
 static VALUE uint8_abs(VALUE self) {
   ndfunc_arg_in_t ain[1] = { { cT, 0 } };
@@ -1712,7 +1721,7 @@ static VALUE uint8_abs(VALUE self) {
   return na_ndloop(&ndf, 1, self);
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_add(na_loop_t* const lp) {
@@ -1782,8 +1791,8 @@ static VALUE uint8_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 uint8_add(VALUE self, VALUE other) {
 
@@ -1798,7 +1807,7 @@ static VALUE uint8_add(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_sub(na_loop_t* const lp) {
@@ -1868,8 +1877,8 @@ static VALUE uint8_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 uint8_sub(VALUE self, VALUE other) {
 
@@ -1884,7 +1893,7 @@ static VALUE uint8_sub(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_mul(na_loop_t* const lp) {
@@ -1954,8 +1963,8 @@ static VALUE uint8_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 uint8_mul(VALUE self, VALUE other) {
 
@@ -1970,10 +1979,10 @@ static VALUE uint8_mul(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)          \
-  if ((y) == 0) {                    \
-    lp->err_type = rb_eZeroDivError; \
-    return;                          \
+#define check_intdivzero(y)                                                                    \
+  if ((y) == 0) {                                                                              \
+    lp->err_type = rb_eZeroDivError;                                                           \
+    return;                                                                                    \
   }
 
 static void iter_uint8_div(na_loop_t* const lp) {
@@ -2043,8 +2052,8 @@ static VALUE uint8_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 uint8_div(VALUE self, VALUE other) {
 
@@ -2059,10 +2068,10 @@ static VALUE uint8_div(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y)          \
-  if ((y) == 0) {                    \
-    lp->err_type = rb_eZeroDivError; \
-    return;                          \
+#define check_intdivzero(y)                                                                    \
+  if ((y) == 0) {                                                                              \
+    lp->err_type = rb_eZeroDivError;                                                           \
+    return;                                                                                    \
   }
 
 static void iter_uint8_mod(na_loop_t* const lp) {
@@ -2132,8 +2141,8 @@ static VALUE uint8_mod_self(VALUE self, VALUE other) {
 /*
   Binary mod.
   @overload % other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self % other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self % other
 */
 static VALUE uint8_mod(VALUE self, VALUE other) {
 
@@ -2182,8 +2191,8 @@ static VALUE uint8_divmod_self(VALUE self, VALUE other) {
 /*
   Binary divmod.
   @overload divmod other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] divmod of self and other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] divmod of self and other.
 */
 static VALUE uint8_divmod(VALUE self, VALUE other) {
 
@@ -2250,8 +2259,8 @@ static VALUE uint8_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 uint8_pow(VALUE self, VALUE other) {
 
@@ -2313,7 +2322,7 @@ static void iter_uint8_minus(na_loop_t* const lp) {
 /*
   Unary minus.
   @overload -@
-  @return [Numo::UInt8] minus of self.
+    @return [Numo::UInt8] minus of self.
 */
 static VALUE uint8_minus(VALUE self) {
   ndfunc_arg_in_t ain[1] = { { cT, 0 } };
@@ -2371,7 +2380,7 @@ static void iter_uint8_reciprocal(na_loop_t* const lp) {
 /*
   Unary reciprocal.
   @overload reciprocal
-  @return [Numo::UInt8] reciprocal of self.
+    @return [Numo::UInt8] reciprocal of self.
 */
 static VALUE uint8_reciprocal(VALUE self) {
   ndfunc_arg_in_t ain[1] = { { cT, 0 } };
@@ -2429,7 +2438,7 @@ static void iter_uint8_sign(na_loop_t* const lp) {
 /*
   Unary sign.
   @overload sign
-  @return [Numo::UInt8] sign of self.
+    @return [Numo::UInt8] sign of self.
 */
 static VALUE uint8_sign(VALUE self) {
   ndfunc_arg_in_t ain[1] = { { cT, 0 } };
@@ -2487,7 +2496,7 @@ static void iter_uint8_square(na_loop_t* const lp) {
 /*
   Unary square.
   @overload square
-  @return [Numo::UInt8] square of self.
+    @return [Numo::UInt8] square of self.
 */
 static VALUE uint8_square(VALUE self) {
   ndfunc_arg_in_t ain[1] = { { cT, 0 } };
@@ -2529,8 +2538,8 @@ static VALUE uint8_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 uint8_eq(VALUE self, VALUE other) {
 
@@ -2576,8 +2585,8 @@ static VALUE uint8_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 uint8_ne(VALUE self, VALUE other) {
 
@@ -2591,7 +2600,7 @@ static VALUE uint8_ne(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_bit_and(na_loop_t* const lp) {
@@ -2661,8 +2670,8 @@ static VALUE uint8_bit_and_self(VALUE self, VALUE other) {
 /*
   Binary bit_and.
   @overload & other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self & other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self & other
 */
 static VALUE uint8_bit_and(VALUE self, VALUE other) {
 
@@ -2677,7 +2686,7 @@ static VALUE uint8_bit_and(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_bit_or(na_loop_t* const lp) {
@@ -2747,8 +2756,8 @@ static VALUE uint8_bit_or_self(VALUE self, VALUE other) {
 /*
   Binary bit_or.
   @overload | other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self | other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self | other
 */
 static VALUE uint8_bit_or(VALUE self, VALUE other) {
 
@@ -2763,7 +2772,7 @@ static VALUE uint8_bit_or(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_bit_xor(na_loop_t* const lp) {
@@ -2833,8 +2842,8 @@ static VALUE uint8_bit_xor_self(VALUE self, VALUE other) {
 /*
   Binary bit_xor.
   @overload ^ other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self ^ other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self ^ other
 */
 static VALUE uint8_bit_xor(VALUE self, VALUE other) {
 
@@ -2897,7 +2906,7 @@ static void iter_uint8_bit_not(na_loop_t* const lp) {
 /*
   Unary bit_not.
   @overload ~
-  @return [Numo::UInt8] bit_not of self.
+    @return [Numo::UInt8] bit_not of self.
 */
 static VALUE uint8_bit_not(VALUE self) {
   ndfunc_arg_in_t ain[1] = { { cT, 0 } };
@@ -2907,7 +2916,7 @@ static VALUE uint8_bit_not(VALUE self) {
   return na_ndloop(&ndf, 1, self);
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_left_shift(na_loop_t* const lp) {
@@ -2977,8 +2986,8 @@ static VALUE uint8_left_shift_self(VALUE self, VALUE other) {
 /*
   Binary left_shift.
   @overload << other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self << other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self << other
 */
 static VALUE uint8_left_shift(VALUE self, VALUE other) {
 
@@ -2993,7 +3002,7 @@ static VALUE uint8_left_shift(VALUE self, VALUE other) {
   }
 }
 
-#define check_intdivzero(y) \
+#define check_intdivzero(y)                                                                    \
   {}
 
 static void iter_uint8_right_shift(na_loop_t* const lp) {
@@ -3063,8 +3072,8 @@ static VALUE uint8_right_shift_self(VALUE self, VALUE other) {
 /*
   Binary right_shift.
   @overload >> other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::NArray] self >> other
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::NArray] self >> other
 */
 static VALUE uint8_right_shift(VALUE self, VALUE other) {
 
@@ -3111,8 +3120,8 @@ static VALUE uint8_gt_self(VALUE self, VALUE other) {
 /*
   Comparison gt other.
   @overload gt other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self gt other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self gt other.
 */
 static VALUE uint8_gt(VALUE self, VALUE other) {
 
@@ -3158,8 +3167,8 @@ static VALUE uint8_ge_self(VALUE self, VALUE other) {
 /*
   Comparison ge other.
   @overload ge other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self ge other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self ge other.
 */
 static VALUE uint8_ge(VALUE self, VALUE other) {
 
@@ -3205,8 +3214,8 @@ static VALUE uint8_lt_self(VALUE self, VALUE other) {
 /*
   Comparison lt other.
   @overload lt other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self lt other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self lt other.
 */
 static VALUE uint8_lt(VALUE self, VALUE other) {
 
@@ -3252,8 +3261,8 @@ static VALUE uint8_le_self(VALUE self, VALUE other) {
 /*
   Comparison le other.
   @overload le other
-  @param [Numo::NArray,Numeric] other
-  @return [Numo::Bit] result of self le other.
+    @param [Numo::NArray,Numeric] other
+    @return [Numo::Bit] result of self le other.
 */
 static VALUE uint8_le(VALUE self, VALUE other) {
 
@@ -3336,9 +3345,9 @@ static void iter_uint8_clip_max(na_loop_t* const lp) {
   Clip array elements by [min,max].
   If either of min or max is nil, one side is clipped.
   @overload clip(min,max)
-  @param [Numo::NArray,Numeric] min
-  @param [Numo::NArray,Numeric] max
-  @return [Numo::NArray] result of clip.
+    @param [Numo::NArray,Numeric] min
+    @param [Numo::NArray,Numeric] max
+    @return [Numo::NArray] result of clip.
 
   @example
       a = Numo::Int32.new(10).seq
@@ -3399,10 +3408,10 @@ static void iter_uint8_sum(na_loop_t* const lp) {
 /*
   sum of self.
   @overload sum(axis:nil, keepdims:false)
-  @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::UInt8] returns result of sum.
+    @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::UInt8] returns result of sum.
 */
 static VALUE uint8_sum(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
@@ -3432,10 +3441,10 @@ static void iter_uint8_prod(na_loop_t* const lp) {
 /*
   prod of self.
   @overload prod(axis:nil, keepdims:false)
-  @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::UInt8] returns result of prod.
+    @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::UInt8] returns result of prod.
 */
 static VALUE uint8_prod(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
@@ -3465,10 +3474,10 @@ static void iter_uint8_min(na_loop_t* const lp) {
 /*
   min of self.
   @overload min(axis:nil, keepdims:false)
-  @param [Numeric,Array,Range] axis  Performs min along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-  dimensions with size one.
-  @return [Numo::UInt8] returns result of min.
+    @param [Numeric,Array,Range] axis  Performs min along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::UInt8] returns result of min.
 */
 static VALUE uint8_min(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
@@ -3498,10 +3507,10 @@ static void iter_uint8_max(na_loop_t* const lp) {
 /*
   max of self.
   @overload max(axis:nil, keepdims:false)
-  @param [Numeric,Array,Range] axis  Performs max along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-  dimensions with size one.
-  @return [Numo::UInt8] returns result of max.
+    @param [Numeric,Array,Range] axis  Performs max along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::UInt8] returns result of max.
 */
 static VALUE uint8_max(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
@@ -3531,10 +3540,10 @@ static void iter_uint8_ptp(na_loop_t* const lp) {
 /*
   ptp of self.
   @overload ptp(axis:nil, keepdims:false)
-  @param [Numeric,Array,Range] axis  Performs ptp along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-  dimensions with size one.
-  @return [Numo::UInt8] returns result of ptp.
+    @param [Numeric,Array,Range] axis  Performs ptp along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::UInt8] returns result of ptp.
 */
 static VALUE uint8_ptp(int argc, VALUE* argv, VALUE self) {
   VALUE v, reduce;
@@ -3586,9 +3595,9 @@ static void iter_uint8_max_index_index32(na_loop_t* const lp) {
 /*
   Index of the maximum value.
   @overload max_index(axis:nil)
-  @param [Numeric,Array,Range] axis  Finds maximum values along the axis and returns **flat 1-d
-  indices**.
-  @return [Integer,Numo::Int] returns result indices.
+    @param [Numeric,Array,Range] axis  Finds maximum values along the axis and returns **flat
+    1-d indices**.
+    @return [Integer,Numo::Int] returns result indices.
   @see #argmax
   @see #max
 
@@ -3669,9 +3678,9 @@ static void iter_uint8_min_index_index32(na_loop_t* const lp) {
 /*
   Index of the minimum value.
   @overload min_index(axis:nil)
-  @param [Numeric,Array,Range] axis  Finds minimum values along the axis and returns **flat 1-d
-  indices**.
-  @return [Integer,Numo::Int] returns result indices.
+    @param [Numeric,Array,Range] axis  Finds minimum values along the axis and returns **flat
+    1-d indices**.
+    @return [Integer,Numo::Int] returns result indices.
   @see #argmin
   @see #min
 
@@ -3750,9 +3759,9 @@ static void iter_uint8_argmax_arg32(na_loop_t* const lp) {
 /*
   Index of the maximum value.
   @overload argmax(axis:nil)
-  @param [Numeric,Array,Range] axis  Finds maximum values along the axis and returns **indices
-  along the axis**.
-  @return [Integer,Numo::Int] returns the result indices.
+    @param [Numeric,Array,Range] axis  Finds maximum values along the axis and returns **indices
+    along the axis**.
+    @return [Integer,Numo::Int] returns the result indices.
   @see #max_index
   @see #max
 
@@ -3828,9 +3837,9 @@ static void iter_uint8_argmin_arg32(na_loop_t* const lp) {
 /*
   Index of the minimum value.
   @overload argmin(axis:nil)
-  @param [Numeric,Array,Range] axis  Finds minimum values along the axis and returns **indices
-  along the axis**.
-  @return [Integer,Numo::Int] returns the result indices.
+    @param [Numeric,Array,Range] axis  Finds minimum values along the axis and returns **indices
+    along the axis**.
+    @return [Integer,Numo::Int] returns the result indices.
   @see #min_index
   @see #min
 
@@ -3889,10 +3898,10 @@ static void iter_uint8_minmax(na_loop_t* const lp) {
 /*
   minmax of self.
   @overload minmax(axis:nil, keepdims:false)
-  @param [Numeric,Array,Range] axis  Finds min-max along the axis.
-  @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
-  as dimensions with size one.
-  @return [Numo::UInt8,Numo::UInt8] min and max of self.
+    @param [Numeric,Array,Range] axis  Finds min-max along the axis.
+    @param [TrueClass] keepdims (keyword) If true, the reduced axes are left in the result array
+    as dimensions with size one.
+    @return [Numo::UInt8,Numo::UInt8] min and max of self.
 */
 static VALUE uint8_minmax(int argc, VALUE* argv, VALUE self) {
   VALUE reduce;
@@ -3907,14 +3916,6 @@ static VALUE uint8_minmax(int argc, VALUE* argv, VALUE self) {
   return na_ndloop(&ndf, 2, self, reduce);
 }
 
-/*
-  Element-wise maximum of two arrays.
-
-  @overload maximum(a1, a2)
-  @param [Numo::NArray,Numeric] a1,a2  The arrays holding the elements to be compared.
-  @return [Numo::UInt8]
-*/
-
 static void iter_uint8_s_maximum(na_loop_t* const lp) {
   size_t i, n;
   char *p1, *p2, *p3;
@@ -3947,14 +3948,6 @@ static VALUE uint8_s_maximum(int argc, VALUE* argv, VALUE mod) {
   return na_ndloop(&ndf, 2, a1, a2);
 }
 
-/*
-  Element-wise minimum of two arrays.
-
-  @overload minimum(a1, a2)
-  @param [Numo::NArray,Numeric] a1,a2  The arrays holding the elements to be compared.
-  @return [Numo::UInt8]
-*/
-
 static void iter_uint8_s_minimum(na_loop_t* const lp) {
   size_t i, n;
   char *p1, *p2, *p3;
@@ -4152,13 +4145,13 @@ static VALUE uint8_bincount_df(VALUE self, VALUE weight, size_t length) {
   Only Integer-types has this method.
 
   @overload bincount([weight], minlength:nil)
-  @param [SFloat or DFloat or Array] weight (optional) Array of
-    float values. Its size along last axis should be same as that of self.
-  @param [Integer] minlength (keyword, optional) Minimum size along
-    last axis for the output array.
-  @return [UInt32 or UInt64 or SFloat or DFloat]
-    Returns Float NArray if weight array is supplied,
-    otherwise returns UInt32 or UInt64 depending on the size along last axis.
+    @param [SFloat or DFloat or Array] weight (optional) Array of
+      float values. Its size along last axis should be same as that of self.
+    @param [Integer] minlength (keyword, optional) Minimum size along
+      last axis for the output array.
+    @return [UInt32 or UInt64 or SFloat or DFloat]
+      Returns Float NArray if weight array is supplied,
+      otherwise returns UInt32 or UInt64 depending on the size along last axis.
   @example
     Numo::Int32[0..4].bincount
     # => Numo::UInt32#shape=[5]
@@ -4238,9 +4231,9 @@ static void iter_uint8_cumsum(na_loop_t* const lp) {
 /*
   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::UInt8] 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::UInt8] cumsum of self.
 */
 static VALUE uint8_cumsum(int argc, VALUE* argv, VALUE self) {
   VALUE reduce;
@@ -4277,9 +4270,9 @@ static void iter_uint8_cumprod(na_loop_t* const lp) {
 /*
   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::UInt8] 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::UInt8] cumprod of self.
 */
 static VALUE uint8_cumprod(int argc, VALUE* argv, VALUE self) {
   VALUE reduce;
@@ -4355,11 +4348,11 @@ static VALUE uint8_mulsum_self(int argc, VALUE* argv, VALUE self) {
   Binary mulsum.
 
   @overload mulsum(other, axis:nil, keepdims: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.
-  @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.
+    @return [Numo::NArray] mulsum of self and other.
 */
 static VALUE uint8_mulsum(int argc, VALUE* argv, VALUE self) {
   //
@@ -4428,9 +4421,9 @@ static void iter_uint8_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::UInt8] self.
+    @param [Numeric] beg  beginning of sequence. (default=0)
+    @param [Numeric] step  step of sequence. (default=1)
+    @return [Numo::UInt8] self.
   @example
     Numo::DFloat.new(6).seq(1,-0.2)
     # => Numo::DFloat#shape=[6]
@@ -4440,7 +4433,7 @@ static void iter_uint8_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 uint8_seq(int argc, VALUE* args, VALUE self) {
+static VALUE uint8_seq(int argc, VALUE* argv, VALUE self) {
   seq_opt_t* g;
   VALUE vbeg = Qnil, vstep = Qnil;
   ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
@@ -4450,7 +4443,7 @@ static VALUE uint8_seq(int argc, VALUE* args, VALUE self) {
   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 = NUM2DBL(vbeg);
   }
@@ -4494,11 +4487,11 @@ static void iter_uint8_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::UInt8] 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::UInt8] eye of self.
 */
 static VALUE uint8_eye(int argc, VALUE* argv, VALUE self) {
   ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };
@@ -4630,10 +4623,10 @@ static void iter_uint8_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::UInt8] 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::UInt8] self.
   @example
     Numo::DFloat.new(6).rand
     # => Numo::DFloat#shape=[6]
@@ -4647,14 +4640,14 @@ static void iter_uint8_rand(na_loop_t* const lp) {
     # => Numo::Int32#shape=[6]
     # [4, 3, 3, 2, 4, 2]
 */
-static VALUE uint8_rand(int argc, VALUE* args, VALUE self) {
+static VALUE uint8_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_uint8_rand, FULL_LOOP, 1, 0, ain, 0 };
 
-  rb_scan_args(argc, args, "11", &v1, &v2);
+  rb_scan_args(argc, argv, "11", &v1, &v2);
   if (v2 == Qnil) {
     g.low = m_zero;
     g.max = high = m_num_to_data(v1);
@@ -4693,8 +4686,8 @@ static void iter_uint8_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::UInt8]
+    @param [Numo::NArray,Numeric] a0,a1,...,an
+    @return [Numo::UInt8]
 */
 static VALUE uint8_poly(VALUE self, VALUE args) {
   int argc, i;
@@ -4781,27 +4774,27 @@ static VALUE uint8_poly(VALUE self, VALUE args) {
  * We have modified their original by adding a check for already-sorted input,
  * which seems to be a win per discussions on pgsql-hackers around 2006-03-21.
  */
-#define swapcode(TYPE, parmi, parmj, n) \
-  do {                                  \
-    size_t i = (n) / sizeof(TYPE);      \
-    TYPE* pi = (TYPE*)(void*)(parmi);   \
-    TYPE* pj = (TYPE*)(void*)(parmj);   \
-    do {                                \
-      TYPE t = *pi;                     \
-      *pi++ = *pj;                      \
-      *pj++ = t;                        \
-    } while (--i > 0);                  \
+#define swapcode(TYPE, parmi, parmj, n)                                                        \
+  do {                                                                                         \
+    size_t i = (n) / sizeof(TYPE);                                                             \
+    TYPE* pi = (TYPE*)(void*)(parmi);                                                          \
+    TYPE* pj = (TYPE*)(void*)(parmj);                                                          \
+    do {                                                                                       \
+      TYPE t = *pi;                                                                            \
+      *pi++ = *pj;                                                                             \
+      *pj++ = t;                                                                               \
+    } while (--i > 0);                                                                         \
   } while (0)
 
 #ifdef HAVE_STDINT_H
-#define SWAPINIT(a, es)                                               \
-  swaptype = (uintptr_t)(a) % sizeof(long) || (es) % sizeof(long) ? 2 \
-             : (es) == sizeof(long)                               ? 0 \
+#define SWAPINIT(a, es)                                                                        \
+  swaptype = (uintptr_t)(a) % sizeof(long) || (es) % sizeof(long) ? 2                          \
+             : (es) == sizeof(long)                               ? 0                          \
                                                                   : 1;
 #else
-#define SWAPINIT(a, es)                                                        \
-  swaptype = ((char*)(a) - (char*)0) % sizeof(long) || (es) % sizeof(long) ? 2 \
-             : (es) == sizeof(long)                                        ? 0 \
+#define SWAPINIT(a, es)                                                                        \
+  swaptype = ((char*)(a) - (char*)0) % sizeof(long) || (es) % sizeof(long) ? 2                 \
+             : (es) == sizeof(long)                                        ? 0                 \
                                                                            : 1;
 #endif
 
@@ -4812,19 +4805,19 @@ static inline void swapfunc(char* a, char* b, size_t n, int swaptype) {
     swapcode(char, a, b, n);
 }
 
-#define swap(a, b)                           \
-  if (swaptype == 0) {                       \
-    long t = *(long*)(void*)(a);             \
-    *(long*)(void*)(a) = *(long*)(void*)(b); \
-    *(long*)(void*)(b) = t;                  \
-  } else                                     \
+#define swap(a, b)                                                                             \
+  if (swaptype == 0) {                                                                         \
+    long t = *(long*)(void*)(a);                                                               \
+    *(long*)(void*)(a) = *(long*)(void*)(b);                                                   \
+    *(long*)(void*)(b) = t;                                                                    \
+  } else                                                                                       \
     swapfunc(a, b, es, swaptype)
 
-#define vecswap(a, b, n) \
+#define vecswap(a, b, n)                                                                       \
   if ((n) > 0) swapfunc((a), (b), (size_t)(n), swaptype)
 
-#define med3(a, b, c, _cmp)                                \
-  (cmpgt(b, a) ? (cmpgt(c, b) ? b : (cmpgt(c, a) ? c : a)) \
+#define med3(a, b, c, _cmp)                                                                    \
+  (cmpgt(b, a) ? (cmpgt(c, b) ? b : (cmpgt(c, a) ? c : a))                                     \
                : (cmpgt(b, c) ? b : (cmpgt(c, a) ? a : c)))
 #endif
 
@@ -4915,8 +4908,8 @@ static void iter_uint8_sort(na_loop_t* const lp) {
 /*
   sort of self.
   @overload sort(axis:nil)
-  @param [Numeric,Array,Range] axis  Performs sort along the axis.
-  @return [Numo::UInt8] returns result of sort.
+    @param [Numeric,Array,Range] axis  Performs sort along the axis.
+    @return [Numo::UInt8] returns result of sort.
   @example
       Numo::DFloat[3,4,1,2].sort #=> Numo::DFloat[1,2,3,4]
 */
@@ -5135,8 +5128,8 @@ static void uint8_index32_qsort(na_loop_t* const lp) {
 /*
   sort_index. Returns an index array of sort result.
   @overload sort_index(axis:nil)
-  @param [Numeric,Array,Range] axis  Performs sort_index along the axis.
-  @return [Integer,Numo::Int] returns result index of sort_index.
+    @param [Numeric,Array,Range] axis  Performs sort_index along the axis.
+    @return [Integer,Numo::Int] returns result index of sort_index.
   @example
       Numo::NArray[3,4,1,2].sort_index #=> Numo::Int32[2,3,0,1]
 */
@@ -5200,10 +5193,10 @@ static void iter_uint8_median(na_loop_t* const lp) {
 /*
   median of self.
   @overload median(axis:nil, keepdims:false)
-  @param [Numeric,Array,Range] axis  Finds median along the axis.
-  @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
-  dimensions with size one.
-  @return [Numo::UInt8] returns median of self.
+    @param [Numeric,Array,Range] axis  Finds median along the axis.
+    @param [TrueClass] keepdims  If true, the reduced axes are left in the result array as
+    dimensions with size one.
+    @return [Numo::UInt8] returns median of self.
 */
 
 static VALUE uint8_median(int argc, VALUE* argv, VALUE self) {
@@ -5242,13 +5235,15 @@ void Init_numo_uint8(void) {
   id_ne = rb_intern("ne");
   id_to_a = rb_intern("to_a");
 
-  /*
-    Document-class: Numo::UInt8
-
-  */
+  /**
+   * Document-class: Numo::UInt8
+   *
+   * 8-bit unsigned integer N-dimensional array class.
+   */
   cT = rb_define_class_under(mNumo, "UInt8", cNArray);
 
   hCast = rb_hash_new();
+  /* Upcasting rules of UInt8. */
   rb_define_const(cT, "UPCAST", hCast);
   rb_hash_aset(hCast, rb_cArray, cT);
 
@@ -5275,15 +5270,15 @@ void Init_numo_uint8(void) {
   rb_hash_aset(hCast, numo_cUInt8, cT);
   rb_obj_freeze(hCast);
 
-  /**/
+  /* Element size of UInt8 in bits. */
   rb_define_const(cT, "ELEMENT_BIT_SIZE", INT2FIX(sizeof(dtype) * 8));
-  /**/
+  /* Element size of UInt8 in bytes. */
   rb_define_const(cT, "ELEMENT_BYTE_SIZE", INT2FIX(sizeof(dtype)));
-  /**/
+  /* Stride size of contiguous UInt8 array. */
   rb_define_const(cT, "CONTIGUOUS_STRIDE", INT2FIX(sizeof(dtype)));
-  /**/
+  /* The largest representable value of UInt8. */
   rb_define_const(cT, "MAX", M_MAX);
-  /**/
+  /* The smallest representable value of UInt8. */
   rb_define_const(cT, "MIN", M_MIN);
   rb_define_alloc_func(cT, uint8_s_alloc_func);
   rb_define_method(cT, "allocate", uint8_allocate, 0);
@@ -5354,7 +5349,19 @@ void Init_numo_uint8(void) {
   rb_define_method(cT, "argmax", uint8_argmax, -1);
   rb_define_method(cT, "argmin", uint8_argmin, -1);
   rb_define_method(cT, "minmax", uint8_minmax, -1);
+  /**
+   * Element-wise maximum of two arrays.
+   * @overload maximum(a1, a2)
+   *   @param [Numo::NArray,Numeric] a1,a2  The arrays holding the elements to be compared.
+   *   @return [Numo::UInt8]
+   */
   rb_define_module_function(cT, "maximum", uint8_s_maximum, -1);
+  /**
+   * Element-wise minimum of two arrays.
+   * @overload minimum(a1, a2)
+   *   @param [Numo::NArray,Numeric] a1,a2  The arrays holding the elements to be compared.
+   *   @return [Numo::UInt8]
+   */
   rb_define_module_function(cT, "minimum", uint8_s_minimum, -1);
   rb_define_method(cT, "bincount", uint8_bincount, -1);
   rb_define_method(cT, "cumsum", uint8_cumsum, -1);
@@ -5371,4 +5378,48 @@ void Init_numo_uint8(void) {
   rb_define_method(cT, "sort_index", uint8_sort_index, -1);
   rb_define_method(cT, "median", uint8_median, -1);
   rb_define_singleton_method(cT, "[]", uint8_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", uint8_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", uint8_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", uint8_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", uint8_rms, -1);
 }