numo-narray-alt 0.9.10 → 0.9.12

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

@@ -0,0 +1,98 @@
+#ifndef NUMO_NARRAY_MH_CUMPROD_H
+#define NUMO_NARRAY_MH_CUMPROD_H 1
+
+#define DEF_NARRAY_FLT_CUMPROD_METHOD_FUNC(tDType, tNAryClass)                                 \
+  static void iter_##tDType##_cumprod(na_loop_t* const lp) {                                   \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    GET_DATA_STRIDE(p1, s1, tDType, x);                                                        \
+    SET_DATA_STRIDE(p2, s2, tDType, x);                                                        \
+    for (size_t i = 0; i < n - 1; i++) {                                                       \
+      GET_DATA_STRIDE(p1, s1, tDType, y);                                                      \
+      m_cumprod(x, y);                                                                         \
+      SET_DATA_STRIDE(p2, s2, tDType, x);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_cumprod_nan(na_loop_t* const lp) {                               \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    GET_DATA_STRIDE(p1, s1, tDType, x);                                                        \
+    SET_DATA_STRIDE(p2, s2, tDType, x);                                                        \
+    for (size_t i = 0; i < n - 1; i++) {                                                       \
+      GET_DATA_STRIDE(p1, s1, tDType, y);                                                      \
+      m_cumprod_nan(x, y);                                                                     \
+      SET_DATA_STRIDE(p2, s2, tDType, x);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_cumprod(int argc, VALUE* argv, VALUE self) {                           \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout        \
+    };                                                                                         \
+                                                                                               \
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_cumprod_nan);     \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#define DEF_NARRAY_INT_CUMPROD_METHOD_FUNC(tDType, tNAryClass)                                 \
+  static void iter_##tDType##_cumprod(na_loop_t* const lp) {                                   \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    GET_DATA_STRIDE(p1, s1, tDType, x);                                                        \
+    SET_DATA_STRIDE(p2, s2, tDType, x);                                                        \
+    for (size_t i = 0; i < n - 1; i++) {                                                       \
+      GET_DATA_STRIDE(p1, s1, tDType, y);                                                      \
+      m_cumprod(x, y);                                                                         \
+      SET_DATA_STRIDE(p2, s2, tDType, x);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_cumprod(int argc, VALUE* argv, VALUE self) {                           \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_cumprod, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout        \
+    };                                                                                         \
+                                                                                               \
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                               \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#endif /* NUMO_NARRAY_MH_CUMPROD_H */

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

@@ -0,0 +1,98 @@
+#ifndef NUMO_NARRAY_MH_CUMSUM_H
+#define NUMO_NARRAY_MH_CUMSUM_H 1
+
+#define DEF_NARRAY_FLT_CUMSUM_METHOD_FUNC(tDType, tNAryClass)                                  \
+  static void iter_##tDType##_cumsum(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    GET_DATA_STRIDE(p1, s1, tDType, x);                                                        \
+    SET_DATA_STRIDE(p2, s2, tDType, x);                                                        \
+    for (size_t i = 0; i < n - 1; i++) {                                                       \
+      GET_DATA_STRIDE(p1, s1, tDType, y);                                                      \
+      m_cumsum(x, y);                                                                          \
+      SET_DATA_STRIDE(p2, s2, tDType, x);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_cumsum_nan(na_loop_t* const lp) {                                \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    GET_DATA_STRIDE(p1, s1, tDType, x);                                                        \
+    SET_DATA_STRIDE(p2, s2, tDType, x);                                                        \
+    for (size_t i = 0; i < n - 1; i++) {                                                       \
+      GET_DATA_STRIDE(p1, s1, tDType, y);                                                      \
+      m_cumsum_nan(x, y);                                                                      \
+      SET_DATA_STRIDE(p2, s2, tDType, x);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_cumsum(int argc, VALUE* argv, VALUE self) {                            \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout         \
+    };                                                                                         \
+                                                                                               \
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, iter_##tDType##_cumsum_nan);      \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#define DEF_NARRAY_INT_CUMSUM_METHOD_FUNC(tDType, tNAryClass)                                  \
+  static void iter_##tDType##_cumsum(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    GET_DATA_STRIDE(p1, s1, tDType, x);                                                        \
+    SET_DATA_STRIDE(p2, s2, tDType, x);                                                        \
+    for (size_t i = 0; i < n - 1; i++) {                                                       \
+      GET_DATA_STRIDE(p1, s1, tDType, y);                                                      \
+      m_cumsum(x, y);                                                                          \
+      SET_DATA_STRIDE(p2, s2, tDType, x);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_cumsum(int argc, VALUE* argv, VALUE self) {                            \
+    VALUE reduce;                                                                              \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { sym_reduce, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_cumsum, STRIDE_LOOP | NDF_FLAT_REDUCE | NDF_CUM, 2, 1, ain, aout         \
+    };                                                                                         \
+                                                                                               \
+    reduce = na_reduce_dimension(argc, argv, 1, &self, &ndf, 0);                               \
+                                                                                               \
+    return na_ndloop(&ndf, 2, self, reduce);                                                   \
+  }
+
+#endif /* NUMO_NARRAY_MH_CUMSUM_H */

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

@@ -0,0 +1,142 @@
+#ifndef NUMO_NARRAY_MH_DIVMOD_H
+#define NUMO_NARRAY_MH_DIVMOD_H 1
+
+#define DEF_NARRAY_FLT_DIVMOD_METHOD_FUNC(tDType, tNAryClass)                                  \
+  static void iter_##tDType##_divmod(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    char* p4;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    ssize_t s4;                                                                                \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    INIT_PTR(lp, 3, p4, s4);                                                                   \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+    tDType a;                                                                                  \
+    tDType b;                                                                                  \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
+      GET_DATA_STRIDE(p2, s2, tDType, y);                                                      \
+      m_divmod(x, y, a, b);                                                                    \
+      SET_DATA_STRIDE(p3, s3, tDType, a);                                                      \
+      SET_DATA_STRIDE(p4, s4, tDType, b);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_divmod_self(VALUE self, VALUE other) {                                 \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                         \
+    ndfunc_arg_out_t aout[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                       \
+    ndfunc_t ndf = { iter_##tDType##_divmod, STRIDE_LOOP, 2, 2, ain, aout };                   \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_divmod(VALUE self, VALUE other) {                                      \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_divmod_self(self, other);                                                \
+    }                                                                                          \
+    VALUE v = rb_funcall(klass, id_cast, 1, self);                                             \
+    return rb_funcall(v, id_divmod, 1, other);                                                 \
+  }
+
+#define DEF_NARRAY_INT_DIVMOD_METHOD_FUNC(tDType, tNAryClass)                                  \
+  static void iter_##tDType##_divmod(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    char* p4;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    ssize_t s4;                                                                                \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    INIT_PTR(lp, 3, p4, s4);                                                                   \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+    tDType a;                                                                                  \
+    tDType b;                                                                                  \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
+      GET_DATA_STRIDE(p2, s2, tDType, y);                                                      \
+      if (y == 0) {                                                                            \
+        lp->err_type = rb_eZeroDivError;                                                       \
+        return;                                                                                \
+      }                                                                                        \
+      m_divmod(x, y, a, b);                                                                    \
+      SET_DATA_STRIDE(p3, s3, tDType, a);                                                      \
+      SET_DATA_STRIDE(p4, s4, tDType, b);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_divmod_self(VALUE self, VALUE other) {                                 \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                         \
+    ndfunc_arg_out_t aout[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                       \
+    ndfunc_t ndf = { iter_##tDType##_divmod, STRIDE_LOOP, 2, 2, ain, aout };                   \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_divmod(VALUE self, VALUE other) {                                      \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_divmod_self(self, other);                                                \
+    }                                                                                          \
+    VALUE v = rb_funcall(klass, id_cast, 1, self);                                             \
+    return rb_funcall(v, id_divmod, 1, other);                                                 \
+  }
+
+#define DEF_NARRAY_ROBJ_DIVMOD_METHOD_FUNC()                                                   \
+  static void iter_robject_divmod(na_loop_t* const lp) {                                       \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    char* p4;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    ssize_t s4;                                                                                \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    INIT_PTR(lp, 3, p4, s4);                                                                   \
+    robject x;                                                                                 \
+    robject y;                                                                                 \
+    robject a;                                                                                 \
+    robject b;                                                                                 \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      GET_DATA_STRIDE(p1, s1, robject, x);                                                     \
+      GET_DATA_STRIDE(p2, s2, robject, y);                                                     \
+      if (y == 0) {                                                                            \
+        lp->err_type = rb_eZeroDivError;                                                       \
+        return;                                                                                \
+      }                                                                                        \
+      m_divmod(x, y, a, b);                                                                    \
+      SET_DATA_STRIDE(p3, s3, robject, a);                                                     \
+      SET_DATA_STRIDE(p4, s4, robject, b);                                                     \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_divmod_self(VALUE self, VALUE other) {                                  \
+    ndfunc_arg_in_t ain[2] = { { numo_cRObject, 0 }, { numo_cRObject, 0 } };                   \
+    ndfunc_arg_out_t aout[2] = { { numo_cRObject, 0 }, { numo_cRObject, 0 } };                 \
+    ndfunc_t ndf = { iter_robject_divmod, STRIDE_LOOP, 2, 2, ain, aout };                      \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_divmod(VALUE self, VALUE other) {                                       \
+    return robject_divmod_self(self, other);                                                   \
+  }
+
+#endif /* NUMO_NARRAY_MH_DIVMOD_H */

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

@@ -0,0 +1,82 @@
+#ifndef NUMO_NARRAY_MH_EYE_H
+#define NUMO_NARRAY_MH_EYE_H 1
+
+#define DEF_NARRAY_EYE_METHOD_FUNC(tDType)                                                     \
+  static void iter_##tDType##_eye(na_loop_t* const lp) {                                       \
+    char* g = (char*)(lp->opt_ptr);                                                            \
+    ssize_t kofs = *(ssize_t*)g;                                                               \
+    tDType data = *(tDType*)(g + sizeof(ssize_t));                                             \
+                                                                                               \
+    size_t n0 = lp->args[0].shape[0];                                                          \
+    size_t n1 = lp->args[0].shape[1];                                                          \
+    ssize_t s0 = lp->args[0].iter[0].step;                                                     \
+    ssize_t s1 = lp->args[0].iter[1].step;                                                     \
+    char* p0 = NDL_PTR(lp, 0);                                                                 \
+                                                                                               \
+    for (size_t i0 = 0; i0 < n0; i0++) {                                                       \
+      char* p1 = p0;                                                                           \
+      for (size_t i1 = 0; i1 < n1; i1++) {                                                     \
+        *(tDType*)p1 = (i0 + kofs == i1) ? data : m_zero;                                      \
+        p1 += s1;                                                                              \
+      }                                                                                        \
+      p0 += s0;                                                                                \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_eye(int argc, VALUE* argv, VALUE self) {                               \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 2 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_eye, NO_LOOP, 1, 0, ain, 0 };                             \
+    ssize_t kofs;                                                                              \
+    tDType data;                                                                               \
+    char* g;                                                                                   \
+    int nd;                                                                                    \
+    narray_t* na;                                                                              \
+                                                                                               \
+    if (argc > 2) {                                                                            \
+      rb_raise(rb_eArgError, "too many arguments (%d for 0..2)", argc);                        \
+    } else if (argc == 2) {                                                                    \
+      data = m_num_to_data(argv[0]);                                                           \
+      kofs = NUM2SSIZET(argv[1]);                                                              \
+    } else if (argc == 1) {                                                                    \
+      data = m_num_to_data(argv[0]);                                                           \
+      kofs = 0;                                                                                \
+    } else {                                                                                   \
+      data = m_one;                                                                            \
+      kofs = 0;                                                                                \
+    }                                                                                          \
+                                                                                               \
+    GetNArray(self, na);                                                                       \
+    nd = na->ndim;                                                                             \
+    if (nd < 2) {                                                                              \
+      rb_raise(nary_eDimensionError, "less than 2-d array");                                   \
+    }                                                                                          \
+                                                                                               \
+    if (kofs >= 0) {                                                                           \
+      if ((size_t)(kofs) >= na->shape[nd - 1]) {                                               \
+        rb_raise(                                                                              \
+          rb_eArgError,                                                                        \
+          "invalid diagonal offset(%" SZF "d) for "                                            \
+          "last dimension size(%" SZF "d)",                                                    \
+          kofs, na->shape[nd - 1]                                                              \
+        );                                                                                     \
+      }                                                                                        \
+    } else {                                                                                   \
+      if ((size_t)(-kofs) >= na->shape[nd - 2]) {                                              \
+        rb_raise(                                                                              \
+          rb_eArgError,                                                                        \
+          "invalid diagonal offset(%" SZF "d) for "                                            \
+          "last-1 dimension size(%" SZF "d)",                                                  \
+          kofs, na->shape[nd - 2]                                                              \
+        );                                                                                     \
+      }                                                                                        \
+    }                                                                                          \
+                                                                                               \
+    g = ALLOCA_N(char, sizeof(ssize_t) + sizeof(tDType));                                      \
+    *(ssize_t*)g = kofs;                                                                       \
+    *(tDType*)(g + sizeof(ssize_t)) = data;                                                    \
+                                                                                               \
+    na_ndloop3(&ndf, g, 1, self);                                                              \
+    return self;                                                                               \
+  }
+
+#endif /* NUMO_NARRAY_MH_EYE_H */

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

@@ -0,0 +1,94 @@
+#ifndef NUMO_NARRAY_MH_FILL_H
+#define NUMO_NARRAY_MH_FILL_H 1
+
+#define DEF_NARRAY_FILL_METHOD_FUNC(tDType)                                                    \
+  static void iter_##tDType##_fill(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    VALUE x = lp->option;                                                                      \
+    tDType y;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    y = m_num_to_data(x);                                                                      \
+                                                                                               \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        SET_DATA_INDEX(p1, idx1, tDType, y);                                                   \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        SET_DATA_STRIDE(p1, s1, tDType, y);                                                    \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_fill(VALUE self, VALUE val) {                                          \
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };                             \
+    ndfunc_t ndf = { iter_##tDType##_fill, FULL_LOOP, 2, 0, ain, 0 };                          \
+    na_ndloop(&ndf, 2, self, val);                                                             \
+    return self;                                                                               \
+  }
+
+#define DEF_NARRAY_BIT_FILL_METHOD_FUNC()                                                      \
+  static void iter_bit_fill(na_loop_t* const lp) {                                             \
+    size_t n;                                                                                  \
+    size_t p3;                                                                                 \
+    ssize_t s3;                                                                                \
+    size_t* idx3;                                                                              \
+    int len;                                                                                   \
+    BIT_DIGIT* a3;                                                                             \
+    BIT_DIGIT y;                                                                               \
+    VALUE x = lp->option;                                                                      \
+                                                                                               \
+    if (x == INT2FIX(0) || x == Qfalse) {                                                      \
+      y = 0;                                                                                   \
+    } else if (x == INT2FIX(1) || x == Qtrue) {                                                \
+      y = ~(BIT_DIGIT)0;                                                                       \
+    } else {                                                                                   \
+      rb_raise(rb_eArgError, "invalid value for Bit");                                         \
+    }                                                                                          \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_BIT_IDX(lp, 0, a3, p3, s3, idx3);                                                 \
+    if (idx3) {                                                                                \
+      y = y & 1;                                                                               \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        STORE_BIT(a3, p3 + *idx3, y);                                                          \
+        idx3++;                                                                                \
+      }                                                                                        \
+    } else if (s3 != 1) {                                                                      \
+      y = y & 1;                                                                               \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        STORE_BIT(a3, p3, y);                                                                  \
+        p3 += s3;                                                                              \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (p3 > 0 || n < NB) {                                                                  \
+        len = (int)(NB - p3);                                                                  \
+        if ((int)n < len) {                                                                    \
+          len = (int)n;                                                                        \
+        }                                                                                      \
+        *a3 = (y & (SLB(len) << p3)) | (*a3 & ~(SLB(len) << p3));                              \
+        a3++;                                                                                  \
+        n -= len;                                                                              \
+      }                                                                                        \
+      for (; n >= NB; n -= NB) {                                                               \
+        *(a3++) = y;                                                                           \
+      }                                                                                        \
+      if (n > 0) {                                                                             \
+        *a3 = (y & SLB(n)) | (*a3 & BALL << n);                                                \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE bit_fill(VALUE self, VALUE val) {                                               \
+    ndfunc_arg_in_t ain[2] = { { OVERWRITE, 0 }, { sym_option } };                             \
+    ndfunc_t ndf = { iter_bit_fill, FULL_LOOP, 2, 0, ain, 0 };                                 \
+    na_ndloop(&ndf, 2, self, val);                                                             \
+    return self;                                                                               \
+  }
+
+#endif /* NUMO_NARRAY_MH_FILL_H */