numo-narray-alt 0.9.5 → 0.9.6

data/ext/numo/narray/narray.c

@@ -77,8 +77,6 @@ void Init_nary_math();
 void Init_nary_rand();
 void Init_nary_array();
 void Init_nary_struct();
-// define mean method for integer array
-void Init_nary_mean();
 
 const rb_data_type_t na_data_type = {
   "Numo::NArray",
@@ -323,9 +321,9 @@ static void na_setup(VALUE self, int ndim, size_t* shape) {
 /*
   @overload initialize(shape)
   @overload initialize(size0, size1, ...)
-  @param [Array] shape (array of sizes along each dimension)
-  @param [Integer] sizeN (size along Nth-dimension)
-  @return [Numo::NArray] unallocated narray.
+    @param [Array] shape (array of sizes along each dimension)
+    @param [Integer] sizeN (size along Nth-dimension)
+    @return [Numo::NArray] unallocated narray.
 
   Constructs an instance of NArray class using the given
   and <i>shape</i> or <i>sizes</i>.
@@ -400,8 +398,8 @@ nary_view_new(VALUE klass, int ndim, size_t* shape) {
   Replaces the contents of self with the contents of other narray.
   Used in dup and clone method.
   @overload initialize_copy(other)
-  @param [Numo::NArray] other
-  @return [Numo::NArray] self
+    @param [Numo::NArray] other
+    @return [Numo::NArray] self
  */
 static VALUE na_initialize_copy(VALUE self, VALUE orig) {
   narray_t* na;
@@ -461,10 +459,10 @@ static VALUE na_s_ones(int argc, VALUE* argv, VALUE klass) {
   but for typed NArray subclasses, e.g., DFloat, Int64.
 
   @overload linspace(x1, x2, [n])
-  @param [Numeric] x1   The start value
-  @param [Numeric] x2   The end value
-  @param [Integer] n    The number of elements. (default is 100).
-  @return [Numo::NArray]  result array.
+    @param [Numeric] x1   The start value
+    @param [Numeric] x2   The end value
+    @param [Integer] n    The number of elements. (default is 100).
+    @return [Numo::NArray]  result array.
 
   @example
     a = Numo::DFloat.linspace(-5,5,7)
@@ -497,11 +495,11 @@ static VALUE na_s_linspace(int argc, VALUE* argv, VALUE klass) {
   i.e., DFloat, SFloat, DComplex, and SComplex.
 
   @overload logspace(a, b, [n, base])
-  @param [Numeric] a  The start value
-  @param [Numeric] b  The end value
-  @param [Integer] n  The number of elements. (default is 50)
-  @param [Numeric] base  The base of log space. (default is 10)
-  @return [Numo::NArray]  result array.
+    @param [Numeric] a  The start value
+    @param [Numeric] b  The end value
+    @param [Integer] n  The number of elements. (default is 50)
+    @param [Numeric] base  The base of log space. (default is 10)
+    @return [Numo::NArray]  result array.
 
   @example
     Numo::DFloat.logspace(4,0,5,2)
@@ -537,8 +535,8 @@ static VALUE na_s_logspace(int argc, VALUE* argv, VALUE klass) {
 /*
   Returns a NArray with shape=(n,n) whose diagonal elements are 1, otherwise 0.
   @overload  eye(n)
-  @param [Integer] n  Size of NArray. Creates 2-D NArray with shape=(n,n)
-  @return [Numo::NArray]  created NArray.
+    @param [Integer] n  Size of NArray. Creates 2-D NArray with shape=(n,n)
+    @return [Numo::NArray]  created NArray.
   @example
     a = Numo::DFloat.eye(3)
     # => Numo::DFloat#shape=[3,3]
@@ -1024,8 +1022,9 @@ na_make_view(VALUE self) {
  *
  *  Expand the shape of an array. Insert a new axis with size=1
  *  at a given dimension.
- *  @param [Integer] dim  dimension at which new axis is inserted.
- *  @return [Numo::NArray]  result narray view.
+ *  @overload expand_dims(dim)
+ *    @param [Integer] dim  dimension at which new axis is inserted.
+ *    @return [Numo::NArray]  result narray view.
  */
 static VALUE na_expand_dims(VALUE self, VALUE vdim) {
   int i, j, nd, dim;
@@ -1191,8 +1190,8 @@ numo_na_upcast(VALUE type1, VALUE type2) {
   Note that NArray has distinct UPCAST mechanism.
   Coerce is used for operation between non-NArray and NArray.
   @overload coerce(other)
-  @param [Object] other  numeric object.
-  @return [Array]  NArray-casted [other,self]
+    @param [Object] other  numeric object.
+    @return [Array]  NArray-casted [other,self]
 */
 static VALUE nary_coerce(VALUE x, VALUE y) {
   VALUE type;
@@ -1229,9 +1228,9 @@ static VALUE nary_s_byte_size(VALUE type) {
 /*
   Returns a new 1-D array initialized from binary raw data in a string.
   @overload from_binary(string,[shape])
-  @param [String] string  Binary raw data.
-  @param [Array] shape  array of integers representing array shape.
-  @return [Numo::NArray] NArray containing binary data.
+    @param [String] string  Binary raw data.
+    @param [Array] shape  array of integers representing array shape.
+    @return [Numo::NArray] NArray containing binary data.
  */
 static VALUE nary_s_from_binary(int argc, VALUE* argv, VALUE type) {
   size_t len, str_len, byte_size;
@@ -1304,9 +1303,9 @@ static VALUE nary_s_from_binary(int argc, VALUE* argv, VALUE type) {
 /*
   Returns a new 1-D array initialized from binary raw data in a string.
   @overload store_binary(string,[offset])
-  @param [String] string  Binary raw data.
-  @param [Integer] (optional) offset  Byte offset in string.
-  @return [Integer] stored length.
+    @param [String] string  Binary raw data.
+    @param [Integer] (optional) offset  Byte offset in string.
+    @return [Integer] stored length.
  */
 static VALUE nary_store_binary(int argc, VALUE* argv, VALUE self) {
   size_t size, str_len, byte_size, offset;
@@ -1353,7 +1352,7 @@ static VALUE nary_store_binary(int argc, VALUE* argv, VALUE self) {
 /*
   Returns string containing the raw data bytes in NArray.
   @overload to_binary()
-  @return [String] String object containing binary raw data.
+    @return [String] String object containing binary raw data.
  */
 static VALUE nary_to_binary(VALUE self) {
   size_t len, offset = 0;
@@ -1379,7 +1378,7 @@ static VALUE nary_to_binary(VALUE self) {
 /*
   Dump marshal data.
   @overload marshal_dump()
-  @return [Array] Array containing marshal data.
+    @return [Array] Array containing marshal data.
  */
 static VALUE nary_marshal_dump(VALUE self) {
   VALUE a;
@@ -1413,8 +1412,8 @@ static VALUE na_inplace(VALUE self);
 /*
   Load marshal data.
   @overload marshal_load(data)
-  @param [Array] Array containing marshal data.
-  @return [nil]
+    @param [Array] Array containing marshal data.
+    @return [nil]
  */
 static VALUE nary_marshal_load(VALUE self, VALUE a) {
   VALUE v;
@@ -1463,8 +1462,8 @@ static VALUE nary_marshal_load(VALUE self, VALUE a) {
 /*
   Cast self to another NArray datatype.
   @overload cast_to(datatype)
-  @param [Class] datatype NArray datatype.
-  @return [Numo::NArray]
+    @param [Class] datatype NArray datatype.
+    @return [Numo::NArray]
  */
 static VALUE nary_cast_to(VALUE obj, VALUE type) {
   return rb_funcall(type, id_cast, 1, obj);
@@ -1732,7 +1731,7 @@ static VALUE na_profile_set(VALUE mod, VALUE val) {
 /*
   Returns the number of rows used for NArray#inspect
   @overload inspect_rows
-  @return [Integer or nil]  the number of rows.
+    @return [Integer or nil]  the number of rows.
 */
 static VALUE na_inspect_rows(VALUE mod) {
   if (numo_na_inspect_rows > 0) {
@@ -1745,8 +1744,8 @@ static VALUE na_inspect_rows(VALUE mod) {
 /*
   Set the number of rows used for NArray#inspect
   @overload inspect_rows=(rows)
-  @param [Integer or nil] rows  the number of rows
-  @return [nil]
+    @param [Integer or nil] rows  the number of rows
+    @return [nil]
 */
 static VALUE na_inspect_rows_set(VALUE mod, VALUE num) {
   if (RTEST(num)) {
@@ -1760,7 +1759,7 @@ static VALUE na_inspect_rows_set(VALUE mod, VALUE num) {
 /*
   Returns the number of cols used for NArray#inspect
   @overload inspect_cols
-  @return [Integer or nil]  the number of cols.
+    @return [Integer or nil]  the number of cols.
 */
 static VALUE na_inspect_cols(VALUE mod) {
   if (numo_na_inspect_cols > 0) {
@@ -1773,8 +1772,8 @@ static VALUE na_inspect_cols(VALUE mod) {
 /*
   Set the number of cols used for NArray#inspect
   @overload inspect_cols=(cols)
-  @param [Integer or nil] cols  the number of cols
-  @return [nil]
+    @param [Integer or nil] cols  the number of cols
+    @return [nil]
 */
 static VALUE na_inspect_cols_set(VALUE mod, VALUE num) {
   if (RTEST(num)) {
@@ -1789,8 +1788,8 @@ static VALUE na_inspect_cols_set(VALUE mod, VALUE num) {
   Equality of self and other in view of numerical array.
   i.e., both arrays have same shape and corresponding elements are equal.
   @overload == other
-  @param [Object] other
-  @return [Boolean] true if self and other is equal.
+    @param [Object] other
+    @return [Boolean] true if self and other is equal.
 */
 static VALUE na_equal(VALUE self, volatile VALUE other) {
   volatile VALUE vbool;
@@ -1825,16 +1824,21 @@ void Init_narray(void) {
   rb_ext_ractor_safe(true);
 #endif
 
+  /**
+   * Document-module: Numo
+   *
+   * Ruby/Numo (NUmerical MOdules)
+   */
   mNumo = rb_define_module("Numo");
 
-  /*
-    Document-class: Numo::NArray
-
-    Numo::NArray is the abstract super class for
-    Numerical N-dimensional Array in the Ruby/Numo module.
-    Use Typed Subclasses of NArray (Numo::DFloat, Int32, etc)
-    to create data array instances.
-  */
+  /**
+   * Document-class: Numo::NArray
+   *
+   * Numo::NArray is the abstract super class for
+   * Numerical N-dimensional Array in the Ruby/Numo module.
+   * Use Typed Subclasses of NArray (Numo::DFloat, Int32, etc)
+   * to create data array instances.
+   */
   cNArray = rb_define_class_under(mNumo, "NArray", rb_cObject);
 
 #ifndef HAVE_RB_CCOMPLEX
@@ -1845,12 +1849,38 @@ void Init_narray(void) {
   rb_cArithSeq = rb_path2class("Enumerator::ArithmeticSequence");
 #endif
 
+  /* The version of Numo::NArray Alternative. */
   rb_define_const(cNArray, "VERSION", rb_str_new2(NARRAY_VERSION));
 
+  /**
+   * Document-class: Numo::NArray::CastError
+   *
+   * Exception raised when type casting is not possible.
+   */
   nary_eCastError = rb_define_class_under(cNArray, "CastError", rb_eStandardError);
+  /**
+   * Document-class: Numo::NArray::ShapeError
+   *
+   * Exception raised when shape is invalid.
+   */
   nary_eShapeError = rb_define_class_under(cNArray, "ShapeError", rb_eStandardError);
+  /**
+   * Document-class: Numo::NArray::OperationError
+   *
+   * Exception raised when operation is not appropriate.
+   */
   nary_eOperationError = rb_define_class_under(cNArray, "OperationError", rb_eStandardError);
+  /**
+   * Document-class: Numo::NArray::DimensionError
+   *
+   * Exception raised when dimension is invalid.
+   */
   nary_eDimensionError = rb_define_class_under(cNArray, "DimensionError", rb_eStandardError);
+  /**
+   * Document-class: Numo::NArray::ValueError
+   *
+   * Exception raised when occurred value error.
+   */
   nary_eValueError = rb_define_class_under(cNArray, "ValueError", rb_eStandardError);
 
   rb_define_singleton_method(cNArray, "debug=", na_debug_set, 1);
@@ -1973,8 +2003,6 @@ void Init_narray(void) {
   Init_numo_bit();
   Init_numo_robject();
 
-  Init_nary_mean();
-
   Init_nary_math();
 
   Init_nary_rand();

data/ext/numo/narray/numo/narray.h

@@ -13,8 +13,8 @@ extern "C" {
 #endif
 #endif
 
-#define NARRAY_VERSION "0.9.5"
-#define NARRAY_VERSION_CODE 950
+#define NARRAY_VERSION "0.9.6"
+#define NARRAY_VERSION_CODE 960
 
 #include <math.h>
 #include "numo/compat.h"
@@ -343,31 +343,31 @@ static inline narray_t* _na_get_narray_t(VALUE obj, unsigned char na_type) {
 #define NA_FL0_TEST(x, f) (NA_FLAG0(x) & (f))
 #define NA_FL1_TEST(x, f) (NA_FLAG1(x) & (f))
 
-#define NA_FL0_SET(x, f) \
-  do {                   \
-    NA_FLAG0(x) |= (f);  \
+#define NA_FL0_SET(x, f)                                                                       \
+  do {                                                                                         \
+    NA_FLAG0(x) |= (f);                                                                        \
   } while (0)
-#define NA_FL1_SET(x, f) \
-  do {                   \
-    NA_FLAG1(x) |= (f);  \
+#define NA_FL1_SET(x, f)                                                                       \
+  do {                                                                                         \
+    NA_FLAG1(x) |= (f);                                                                        \
   } while (0)
 
-#define NA_FL0_UNSET(x, f) \
-  do {                     \
-    NA_FLAG0(x) &= ~(f);   \
+#define NA_FL0_UNSET(x, f)                                                                     \
+  do {                                                                                         \
+    NA_FLAG0(x) &= ~(f);                                                                       \
   } while (0)
-#define NA_FL1_UNSET(x, f) \
-  do {                     \
-    NA_FLAG1(x) &= ~(f);   \
+#define NA_FL1_UNSET(x, f)                                                                     \
+  do {                                                                                         \
+    NA_FLAG1(x) &= ~(f);                                                                       \
   } while (0)
 
-#define NA_FL0_REVERSE(x, f) \
-  do {                       \
-    NA_FLAG0(x) ^= (f);      \
+#define NA_FL0_REVERSE(x, f)                                                                   \
+  do {                                                                                         \
+    NA_FLAG0(x) ^= (f);                                                                        \
   } while (0)
-#define NA_FL1_REVERSE(x, f) \
-  do {                       \
-    NA_FLAG1(x) ^= (f);      \
+#define NA_FL1_REVERSE(x, f)                                                                   \
+  do {                                                                                         \
+    NA_FLAG1(x) ^= (f);                                                                        \
   } while (0)
 
 /* FLAGS

data/ext/numo/narray/numo/ndloop.h

@@ -56,7 +56,7 @@ typedef struct NA_LOOP {
 #define OVERWRITE Qtrue // used for CASTABLE(t)
 
 #define NDF_TEST(nf, fl) ((nf)->flag & (fl))
-#define NDF_SET(nf, fl) \
+#define NDF_SET(nf, fl)                                                                        \
   { (nf)->flag |= (fl); }
 
 #define NDF_ARG_READ_ONLY 1

data/ext/numo/narray/numo/template.h

@@ -6,7 +6,7 @@
 #ifndef TEMPLATE_H
 #define TEMPLATE_H
 
-#define INIT_COUNTER(lp, c) \
+#define INIT_COUNTER(lp, c)                                                                    \
   { c = (lp)->n[0]; }
 
 #define NDL_CNT(lp) ((lp)->n[0])
@@ -16,113 +16,113 @@
 #define NDL_ESZ(lp, i) ((lp)->args[i].elmsz)
 #define NDL_SHAPE(lp, i) ((lp)->args[i].shape)
 
-#define INIT_PTR(lp, i, pt, st)                             \
-  {                                                         \
-    pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos; \
-    st = ((lp)->args[i].iter[0]).step;                      \
+#define INIT_PTR(lp, i, pt, st)                                                                \
+  {                                                                                            \
+    pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos;                                    \
+    st = ((lp)->args[i].iter[0]).step;                                                         \
   }
 
-#define INIT_PTR_IDX(lp, i, pt, st, id)                     \
-  {                                                         \
-    pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos; \
-    st = ((lp)->args[i].iter[0]).step;                      \
-    id = ((lp)->args[i].iter[0]).idx;                       \
+#define INIT_PTR_IDX(lp, i, pt, st, id)                                                        \
+  {                                                                                            \
+    pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos;                                    \
+    st = ((lp)->args[i].iter[0]).step;                                                         \
+    id = ((lp)->args[i].iter[0]).idx;                                                          \
   }
 
-#define INIT_ELMSIZE(lp, i, es) \
+#define INIT_ELMSIZE(lp, i, es)                                                                \
   { es = ((lp)->args[i]).elmsz; }
 
-#define INIT_PTR_BIT(lp, i, ad, ps, st)     \
-  {                                         \
-    ps = ((lp)->args[i].iter[0]).pos;       \
-    ad = (BIT_DIGIT*)(((lp)->args[i]).ptr); \
-    st = ((lp)->args[i].iter[0]).step;      \
+#define INIT_PTR_BIT(lp, i, ad, ps, st)                                                        \
+  {                                                                                            \
+    ps = ((lp)->args[i].iter[0]).pos;                                                          \
+    ad = (BIT_DIGIT*)(((lp)->args[i]).ptr);                                                    \
+    st = ((lp)->args[i].iter[0]).step;                                                         \
   }
 
-#define INIT_PTR_BIT_IDX(lp, i, ad, ps, st, id) \
-  {                                             \
-    ps = ((lp)->args[i].iter[0]).pos;           \
-    ad = (BIT_DIGIT*)(((lp)->args[i]).ptr);     \
-    st = ((lp)->args[i].iter[0]).step;          \
-    id = ((lp)->args[i].iter[0]).idx;           \
+#define INIT_PTR_BIT_IDX(lp, i, ad, ps, st, id)                                                \
+  {                                                                                            \
+    ps = ((lp)->args[i].iter[0]).pos;                                                          \
+    ad = (BIT_DIGIT*)(((lp)->args[i]).ptr);                                                    \
+    st = ((lp)->args[i].iter[0]).step;                                                         \
+    id = ((lp)->args[i].iter[0]).idx;                                                          \
   }
 
-#define GET_DATA(ptr, type, val) \
+#define GET_DATA(ptr, type, val)                                                               \
   { val = *(type*)(ptr); }
 
-#define SET_DATA(ptr, type, val) \
+#define SET_DATA(ptr, type, val)                                                               \
   { *(type*)(ptr) = val; }
 
-#define GET_DATA_STRIDE(ptr, step, type, val) \
-  {                                           \
-    val = *(type*)(ptr);                      \
-    ptr += step;                              \
+#define GET_DATA_STRIDE(ptr, step, type, val)                                                  \
+  {                                                                                            \
+    val = *(type*)(ptr);                                                                       \
+    ptr += step;                                                                               \
   }
 
-#define GET_DATA_INDEX(ptr, idx, type, val) \
-  {                                         \
-    val = *(type*)(ptr + *idx);             \
-    idx++;                                  \
+#define GET_DATA_INDEX(ptr, idx, type, val)                                                    \
+  {                                                                                            \
+    val = *(type*)(ptr + *idx);                                                                \
+    idx++;                                                                                     \
   }
 
-#define SET_DATA_STRIDE(ptr, step, type, val) \
-  {                                           \
-    *(type*)(ptr) = val;                      \
-    ptr += step;                              \
+#define SET_DATA_STRIDE(ptr, step, type, val)                                                  \
+  {                                                                                            \
+    *(type*)(ptr) = val;                                                                       \
+    ptr += step;                                                                               \
   }
 
-#define SET_DATA_INDEX(ptr, idx, type, val) \
-  {                                         \
-    *(type*)(ptr + *idx) = val;             \
-    idx++;                                  \
+#define SET_DATA_INDEX(ptr, idx, type, val)                                                    \
+  {                                                                                            \
+    *(type*)(ptr + *idx) = val;                                                                \
+    idx++;                                                                                     \
   }
 
-#define LOAD_BIT(adr, pos, val)                     \
-  {                                                 \
-    size_t dig = (pos) / NB;                        \
-    int bit = (pos) % NB;                           \
-    val = (((BIT_DIGIT*)(adr))[dig] >> (bit)) & 1u; \
+#define LOAD_BIT(adr, pos, val)                                                                \
+  {                                                                                            \
+    size_t dig = (pos) / NB;                                                                   \
+    int bit = (pos) % NB;                                                                      \
+    val = (((BIT_DIGIT*)(adr))[dig] >> (bit)) & 1u;                                            \
   }
 
-#define LOAD_BIT_STEP(adr, pos, step, idx, val)   \
-  {                                               \
-    size_t dig;                                   \
-    int bit;                                      \
-    if (idx) {                                    \
-      dig = ((pos) + *(idx)) / NB;                \
-      bit = ((pos) + *(idx)) % NB;                \
-      idx++;                                      \
-    } else {                                      \
-      dig = (pos) / NB;                           \
-      bit = (pos) % NB;                           \
-      pos += step;                                \
-    }                                             \
-    val = (((BIT_DIGIT*)(adr))[dig] >> bit) & 1u; \
+#define LOAD_BIT_STEP(adr, pos, step, idx, val)                                                \
+  {                                                                                            \
+    size_t dig;                                                                                \
+    int bit;                                                                                   \
+    if (idx) {                                                                                 \
+      dig = ((pos) + *(idx)) / NB;                                                             \
+      bit = ((pos) + *(idx)) % NB;                                                             \
+      idx++;                                                                                   \
+    } else {                                                                                   \
+      dig = (pos) / NB;                                                                        \
+      bit = (pos) % NB;                                                                        \
+      pos += step;                                                                             \
+    }                                                                                          \
+    val = (((BIT_DIGIT*)(adr))[dig] >> bit) & 1u;                                              \
   }
 
-#define STORE_BIT(adr, pos, val)                                             \
-  {                                                                          \
-    size_t dig = (pos) / NB;                                                 \
-    int bit = (pos) % NB;                                                    \
-    ((BIT_DIGIT*)(adr))[dig] =                                               \
-      (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit)); \
+#define STORE_BIT(adr, pos, val)                                                               \
+  {                                                                                            \
+    size_t dig = (pos) / NB;                                                                   \
+    int bit = (pos) % NB;                                                                      \
+    ((BIT_DIGIT*)(adr))[dig] =                                                                 \
+      (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit));                   \
   }
 
-#define STORE_BIT_STEP(adr, pos, step, idx, val)                             \
-  {                                                                          \
-    size_t dig;                                                              \
-    int bit;                                                                 \
-    if (idx) {                                                               \
-      dig = ((pos) + *(idx)) / NB;                                           \
-      bit = ((pos) + *(idx)) % NB;                                           \
-      idx++;                                                                 \
-    } else {                                                                 \
-      dig = (pos) / NB;                                                      \
-      bit = (pos) % NB;                                                      \
-      pos += step;                                                           \
-    }                                                                        \
-    ((BIT_DIGIT*)(adr))[dig] =                                               \
-      (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit)); \
+#define STORE_BIT_STEP(adr, pos, step, idx, val)                                               \
+  {                                                                                            \
+    size_t dig;                                                                                \
+    int bit;                                                                                   \
+    if (idx) {                                                                                 \
+      dig = ((pos) + *(idx)) / NB;                                                             \
+      bit = ((pos) + *(idx)) % NB;                                                             \
+      idx++;                                                                                   \
+    } else {                                                                                   \
+      dig = (pos) / NB;                                                                        \
+      bit = (pos) % NB;                                                                        \
+      pos += step;                                                                             \
+    }                                                                                          \
+    ((BIT_DIGIT*)(adr))[dig] =                                                                 \
+      (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit));                   \
   }
 
 static inline int is_aligned(const void* ptr, const size_t alignment) {

data/ext/numo/narray/numo/types/bit.h

@@ -19,6 +19,9 @@ typedef BIT_DIGIT rtype;
 #define m_data_to_num(x) INT2FIX(x)
 #define m_sprintf(s, x) sprintf(s, "%1d", (int)(x))
 
+#define m_add(x, y) ((x) + (y))
+#define m_div(x, y) ((x) / (y))
+
 #define m_copy(x) (x)
 #define m_not(x) (~(x))
 #define m_and(x, y) ((x) & (y))
@@ -36,3 +39,76 @@ static inline BIT_DIGIT m_num_to_data(VALUE num) {
   }
   return 0;
 }
+
+static inline double f_mean(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
+  size_t count = 0;
+  double sum = 0.0;
+  BIT_DIGIT x;
+  if (idx) {
+    for (size_t i = n; i--;) {
+      LOAD_BIT(p, pos + *idx, x);
+      idx++;
+      sum += (double)x;
+      count++;
+    }
+  } else {
+    for (size_t i = n; i--;) {
+      LOAD_BIT(p, pos, x);
+      pos += stride;
+      sum += (double)x;
+      count++;
+    }
+  }
+  return sum / (double)count;
+}
+
+static inline double f_var(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
+  size_t count = 0;
+  double sum = 0.0;
+  BIT_DIGIT x;
+  const double mean = f_mean(n, p, pos, stride, idx);
+  if (idx) {
+    for (size_t i = n; i--;) {
+      LOAD_BIT(p, pos + *idx, x);
+      const double d = (double)x - mean;
+      idx++;
+      sum += d * d;
+      count++;
+    }
+  } else {
+    for (size_t i = n; i--;) {
+      LOAD_BIT(p, pos, x);
+      const double d = (double)x - mean;
+      pos += stride;
+      sum += d * d;
+      count++;
+    }
+  }
+  return sum / (double)(count - 1);
+}
+
+static inline double f_stddev(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
+  return sqrt(f_var(n, p, pos, stride, idx));
+}
+
+static inline double f_rms(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
+  size_t count = 0;
+  double sum = 0.0;
+  BIT_DIGIT x;
+  if (idx) {
+    for (size_t i = n; i--;) {
+      LOAD_BIT(p, pos + *idx, x);
+      idx++;
+      sum += (double)(x * x);
+      count++;
+    }
+  } else {
+    for (size_t i = n; i--;) {
+      LOAD_BIT(p, pos, x);
+      pos += stride;
+      sum += (double)(x * x);
+      count++;
+    }
+  }
+  return sqrt(sum / (double)count);
+}

data/ext/numo/narray/numo/types/complex.h

@@ -41,9 +41,9 @@ static inline dtype NUM2COMP(VALUE v) {
 #define c_ne(x, y) (REAL(x) != REAL(y) || IMAG(x) != IMAG(y))
 #define c_isnan(x) (isnan(REAL(x)) || isnan(IMAG(x)))
 #define c_isinf(x) (isinf(REAL(x)) || isinf(IMAG(x)))
-#define c_isposinf(x) \
+#define c_isposinf(x)                                                                          \
   ((isinf(REAL(x)) && signbit(REAL(x)) == 0) || (isinf(IMAG(x)) && signbit(IMAG(x)) == 0))
-#define c_isneginf(x) \
+#define c_isneginf(x)                                                                          \
   ((isinf(REAL(x)) && signbit(REAL(x))) || (isinf(IMAG(x)) && signbit(IMAG(x))))
 #define c_isfinite(x) (isfinite(REAL(x)) && isfinite(IMAG(x)))