numo-narray-alt 0.9.11 → 0.9.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f5745729ac9808d98856b30963b19d93cfec3ca0502b4b9db35023094ceb009
-  data.tar.gz: 38252691a0d86e3f7d3e5280bec28081effce8f40596e56b21d3e23205198350
+  metadata.gz: 51d818d5b1d990bb12a358f15adae53ef1b5d488d172dd275abd2d96d4c74ab4
+  data.tar.gz: 8f521c4247a54185936fa6f06ebcd322cc90babde98c093ac7287ccc93f443fd
 SHA512:
-  metadata.gz: 94c876a77295498c07aea51465e193eb054d0b9936df76ff709ae6e6c677d908a705d9692595af6e60faaddd517b91cdb42356828bee6b40e8b3bcff1c9e114e
-  data.tar.gz: cf8005eff8efc53fc55641869cc18824dd11ae4be4f93618ba586e632f6aa94643b500fcdf4239b47eaec9b6870dcf080900e35484309101bb34557d9f289bec
+  metadata.gz: d01294b516c33ac3173da16947700e8ae5e0db4e5d99bcb9f4c279c98a4880fb6c23a6559426aaae197b6b066400964b77aa2689b797907b52f16f78af4aff56
+  data.tar.gz: 6ca130060197c3a3a1a9c2191e820dd7fb0c1d9c514058356bf0b4851a20eb1ac3db5fb0b7e65d161ac606948147b555090a94436febee83a89261829a312bba

data/Gemfile

@@ -15,7 +15,6 @@ gem 'rubocop-minitest', '~> 0.38.2'
 gem 'rubocop-performance', '~> 1.26'
 gem 'rubocop-rake', '~> 0.7.1'
 gem 'simplecov', '~> 0.22.0'
-gem 'test-unit', '~> 3.7'
 gem 'yard', '~> 0.9.37'
 
 group :memcheck, optional: true do

data/README.md

@@ -43,6 +43,13 @@ Numo::DFloat#shape=[2,2]
 irb(main):004>
 ```
 
+If you want to explicitly load numo-narray-alt, write the require method as follows:
+
+```ruby
+irb(main):001> require 'numo/narray/alt'
+=> true
+```
+
 ## Documentation
 
 - [API Documentation on Gemdocs](https://gemdocs.org/gems/numo-narray-alt/)

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

@@ -13,8 +13,8 @@ extern "C" {
 #endif
 #endif
 
-#define NARRAY_VERSION "0.9.11"
-#define NARRAY_VERSION_CODE 9110
+#define NARRAY_VERSION "0.9.13"
+#define NARRAY_VERSION_CODE 9130
 
 #include <math.h>
 #include "numo/compat.h"

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

@@ -22,7 +22,7 @@
   {                                                                                            \
     x = rb_funcall(x, id_divmod, 1, y);                                                        \
     a = RARRAY_PTR(x)[0];                                                                      \
-    b = RARRAY_PTR(x)[0];                                                                      \
+    b = RARRAY_PTR(x)[1];                                                                      \
   }
 #define m_pow(x, y) rb_funcall(x, id_pow, 1, y)
 #define m_pow_int(x, y) rb_funcall(x, id_pow, 1, y)

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

@@ -0,0 +1,233 @@
+#ifndef NUMO_NARRAY_MH_BINCOUNT_H
+#define NUMO_NARRAY_MH_BINCOUNT_H 1
+
+#define DEF_BINCOUNT_FUNCS(tDType, tNAryClass)                                                 \
+  static void iter_##tDType##_bincount_32(na_loop_t* const lp) {                               \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    const size_t m = lp->args[0].shape[0];                                                     \
+    const size_t n = lp->args[1].shape[0];                                                     \
+                                                                                               \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      *(u_int32_t*)(p2 + s2 * i) = 0;                                                          \
+    }                                                                                          \
+                                                                                               \
+    size_t x;                                                                                  \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < m; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        (*(u_int32_t*)(p2 + s2 * x))++;                                                        \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < m; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        (*(u_int32_t*)(p2 + s2 * x))++;                                                        \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bincount_32(VALUE self, size_t length) {                               \
+    size_t shape_out[1] = { length };                                                          \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 1 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cUInt32, 1, shape_out } };                             \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_bincount_32, NO_LOOP | NDF_STRIDE_LOOP | NDF_INDEX_LOOP, 1, 1, ain, aout \
+    };                                                                                         \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_bincount_64(na_loop_t* const lp) {                               \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    const size_t m = lp->args[0].shape[0];                                                     \
+    const size_t n = lp->args[1].shape[0];                                                     \
+                                                                                               \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      *(u_int64_t*)(p2 + s2 * i) = 0;                                                          \
+    }                                                                                          \
+                                                                                               \
+    size_t x;                                                                                  \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < m; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        (*(u_int64_t*)(p2 + s2 * x))++;                                                        \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < m; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        (*(u_int64_t*)(p2 + s2 * x))++;                                                        \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bincount_64(VALUE self, size_t length) {                               \
+    size_t shape_out[1] = { length };                                                          \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 1 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cUInt64, 1, shape_out } };                             \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_bincount_64, NO_LOOP | NDF_STRIDE_LOOP | NDF_INDEX_LOOP, 1, 1, ain, aout \
+    };                                                                                         \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_bincount_sf(na_loop_t* const lp) {                               \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    const size_t l = lp->args[0].shape[0];                                                     \
+    const size_t m = lp->args[1].shape[0];                                                     \
+    const size_t n = lp->args[2].shape[0];                                                     \
+                                                                                               \
+    if (l != m) {                                                                              \
+      rb_raise(nary_eShapeError, "size mismatch along last axis between self and weight");     \
+    }                                                                                          \
+                                                                                               \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      *(float*)(p3 + s3 * i) = 0;                                                              \
+    }                                                                                          \
+    size_t x;                                                                                  \
+    float w;                                                                                   \
+    for (size_t i = 0; i < l; i++) {                                                           \
+      GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
+      GET_DATA_STRIDE(p2, s2, float, w);                                                       \
+      (*(float*)(p3 + s3 * x)) += w;                                                           \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bincount_sf(VALUE self, VALUE weight, size_t length) {                 \
+    size_t shape_out[1] = { length };                                                          \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 1 }, { numo_cSFloat, 1 } };                       \
+    ndfunc_arg_out_t aout[1] = { { numo_cSFloat, 1, shape_out } };                             \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_bincount_sf, NO_LOOP | NDF_STRIDE_LOOP, 2, 1, ain, aout                  \
+    };                                                                                         \
+    return na_ndloop(&ndf, 2, self, weight);                                                   \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_bincount_df(na_loop_t* const lp) {                               \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    const size_t l = lp->args[0].shape[0];                                                     \
+    const size_t m = lp->args[1].shape[0];                                                     \
+    const size_t n = lp->args[2].shape[0];                                                     \
+                                                                                               \
+    if (l != m) {                                                                              \
+      rb_raise(nary_eShapeError, "size mismatch along last axis between self and weight");     \
+    }                                                                                          \
+                                                                                               \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      *(double*)(p3 + s3 * i) = 0;                                                             \
+    }                                                                                          \
+    size_t x;                                                                                  \
+    double w;                                                                                  \
+    for (size_t i = 0; i < l; i++) {                                                           \
+      GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
+      GET_DATA_STRIDE(p2, s2, double, w);                                                      \
+      (*(double*)(p3 + s3 * x)) += w;                                                          \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bincount_df(VALUE self, VALUE weight, size_t length) {                 \
+    size_t shape_out[1] = { length };                                                          \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 1 }, { numo_cDFloat, 1 } };                       \
+    ndfunc_arg_out_t aout[1] = { { numo_cDFloat, 1, shape_out } };                             \
+    ndfunc_t ndf = {                                                                           \
+      iter_##tDType##_bincount_df, NO_LOOP | NDF_STRIDE_LOOP, 2, 1, ain, aout                  \
+    };                                                                                         \
+    return na_ndloop(&ndf, 2, self, weight);                                                   \
+  }
+
+#define DEF_NARRAY_INT_BINCOUNT_METHOD_FUNC(tDType, tNAryClass)                                \
+  DEF_BINCOUNT_FUNCS(tDType, tNAryClass)                                                       \
+  static VALUE tDType##_bincount(int argc, VALUE* argv, VALUE self) {                          \
+    VALUE weight = Qnil;                                                                       \
+    VALUE kw = Qnil;                                                                           \
+    VALUE opts[1] = { Qundef };                                                                \
+    ID table[1] = { id_minlength };                                                            \
+    rb_scan_args(argc, argv, "01:", &weight, &kw);                                             \
+    rb_get_kwargs(kw, table, 0, 1, opts);                                                      \
+                                                                                               \
+    VALUE v = tDType##_minmax(0, 0, self);                                                     \
+    if (m_num_to_data(RARRAY_AREF(v, 0)) < 0) {                                                \
+      rb_raise(rb_eArgError, "array items must be non-netagive");                              \
+    }                                                                                          \
+    v = RARRAY_AREF(v, 1);                                                                     \
+                                                                                               \
+    size_t length = NUM2SIZET(v) + 1;                                                          \
+    if (opts[0] != Qundef) {                                                                   \
+      const size_t minlength = NUM2SIZET(opts[0]);                                             \
+      if (minlength > length) {                                                                \
+        length = minlength;                                                                    \
+      }                                                                                        \
+    }                                                                                          \
+                                                                                               \
+    if (NIL_P(weight)) {                                                                       \
+      if (length > 4294967295ul) {                                                             \
+        return tDType##_bincount_64(self, length);                                             \
+      }                                                                                        \
+      return tDType##_bincount_32(self, length);                                               \
+    } else {                                                                                   \
+      if (rb_obj_class(weight) == numo_cSFloat) {                                              \
+        return tDType##_bincount_sf(self, weight, length);                                     \
+      }                                                                                        \
+      return tDType##_bincount_df(self, weight, length);                                       \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_UINT_BINCOUNT_METHOD_FUNC(tDType, tNAryClass)                               \
+  DEF_BINCOUNT_FUNCS(tDType, tNAryClass)                                                       \
+  static VALUE tDType##_bincount(int argc, VALUE* argv, VALUE self) {                          \
+    VALUE weight = Qnil;                                                                       \
+    VALUE kw = Qnil;                                                                           \
+    VALUE opts[1] = { Qundef };                                                                \
+    ID table[1] = { id_minlength };                                                            \
+    rb_scan_args(argc, argv, "01:", &weight, &kw);                                             \
+    rb_get_kwargs(kw, table, 0, 1, opts);                                                      \
+                                                                                               \
+    VALUE v = tDType##_max(0, 0, self);                                                        \
+                                                                                               \
+    size_t length = NUM2SIZET(v) + 1;                                                          \
+    if (opts[0] != Qundef) {                                                                   \
+      const size_t minlength = NUM2SIZET(opts[0]);                                             \
+      if (minlength > length) {                                                                \
+        length = minlength;                                                                    \
+      }                                                                                        \
+    }                                                                                          \
+                                                                                               \
+    if (NIL_P(weight)) {                                                                       \
+      if (length > 4294967295ul) {                                                             \
+        return tDType##_bincount_64(self, length);                                             \
+      }                                                                                        \
+      return tDType##_bincount_32(self, length);                                               \
+    } else {                                                                                   \
+      if (rb_obj_class(weight) == numo_cSFloat) {                                              \
+        return tDType##_bincount_sf(self, weight, length);                                     \
+      }                                                                                        \
+      return tDType##_bincount_df(self, weight, length);                                       \
+    }                                                                                          \
+  }
+
+#endif /* NUMO_NARRAY_MH_BINCOUNT_H */

data/ext/numo/narray/src/mh/bit/and.h

@@ -0,0 +1,225 @@
+#ifndef NUMO_NARRAY_MH_BIT_AND_H
+#define NUMO_NARRAY_MH_BIT_AND_H 1
+
+#define DEF_NARRAY_INT_BIT_AND_METHOD_FUNC(tDType, tNAryClass)                                 \
+  static void iter_##tDType##_bit_and(na_loop_t* const lp) {                                   \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    if (is_aligned(p1, sizeof(tDType)) && is_aligned(p2, sizeof(tDType)) &&                    \
+        is_aligned(p3, sizeof(tDType))) {                                                      \
+      if (s1 == sizeof(tDType) && s2 == sizeof(tDType) && s3 == sizeof(tDType)) {              \
+        if (p1 == p3) {                                                                        \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((tDType*)p1)[i] = m_bit_and(((tDType*)p1)[i], ((tDType*)p2)[i]);                  \
+          }                                                                                    \
+        } else {                                                                               \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((tDType*)p3)[i] = m_bit_and(((tDType*)p1)[i], ((tDType*)p2)[i]);                  \
+          }                                                                                    \
+        }                                                                                      \
+        return;                                                                                \
+      }                                                                                        \
+      if (is_aligned_step(s1, sizeof(tDType)) && is_aligned_step(s2, sizeof(tDType)) &&        \
+          is_aligned_step(s3, sizeof(tDType))) {                                               \
+        if (s2 == 0) {                                                                         \
+          if (s1 == sizeof(tDType) && s3 == sizeof(tDType)) {                                  \
+            if (p1 == p3) {                                                                    \
+              for (size_t i = 0; i < n; i++) {                                                 \
+                ((tDType*)p1)[i] = m_bit_and(((tDType*)p1)[i], *(tDType*)p2);                  \
+              }                                                                                \
+            } else {                                                                           \
+              for (size_t i = 0; i < n; i++) {                                                 \
+                ((tDType*)p3)[i] = m_bit_and(((tDType*)p1)[i], *(tDType*)p2);                  \
+              }                                                                                \
+            }                                                                                  \
+          } else {                                                                             \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              *(tDType*)p3 = m_bit_and(*(tDType*)p1, *(tDType*)p2);                            \
+              p1 += s1;                                                                        \
+              p3 += s3;                                                                        \
+            }                                                                                  \
+          }                                                                                    \
+        } else {                                                                               \
+          if (p1 == p3) {                                                                      \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              *(tDType*)p1 = m_bit_and(*(tDType*)p1, *(tDType*)p2);                            \
+              p1 += s1;                                                                        \
+              p2 += s2;                                                                        \
+            }                                                                                  \
+          } else {                                                                             \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              *(tDType*)p3 = m_bit_and(*(tDType*)p1, *(tDType*)p2);                            \
+              p1 += s1;                                                                        \
+              p2 += s2;                                                                        \
+              p3 += s3;                                                                        \
+            }                                                                                  \
+          }                                                                                    \
+        }                                                                                      \
+        return;                                                                                \
+      }                                                                                        \
+    }                                                                                          \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      tDType x;                                                                                \
+      tDType y;                                                                                \
+      GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
+      GET_DATA_STRIDE(p2, s2, tDType, y);                                                      \
+      const tDType z = m_bit_and(x, y);                                                        \
+      SET_DATA_STRIDE(p3, s3, tDType, z);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_and_self(VALUE self, VALUE other) {                                \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = { iter_##tDType##_bit_and, STRIDE_LOOP, 2, 1, ain, aout };                  \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_and(VALUE self, VALUE other) {                                     \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_bit_and_self(self, other);                                               \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, '&', 1, other);                                                     \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_INT8_BIT_AND_METHOD_FUNC(tDType, tNAryClass)                                \
+  static void iter_##tDType##_bit_and(na_loop_t* const lp) {                                   \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    if (s2 == 0) {                                                                             \
+      if (s1 == sizeof(tDType) && s3 == sizeof(tDType)) {                                      \
+        if (p1 == p3) {                                                                        \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((tDType*)p1)[i] = m_bit_and(((tDType*)p1)[i], *(tDType*)p2);                      \
+          }                                                                                    \
+        } else {                                                                               \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((tDType*)p3)[i] = m_bit_and(((tDType*)p1)[i], *(tDType*)p2);                      \
+          }                                                                                    \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(tDType*)p3 = m_bit_and(*(tDType*)p1, *(tDType*)p2);                                \
+          p1 += s1;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (p1 == p3) {                                                                          \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(tDType*)p1 = m_bit_and(*(tDType*)p1, *(tDType*)p2);                                \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(tDType*)p3 = m_bit_and(*(tDType*)p1, *(tDType*)p2);                                \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    }                                                                                          \
+    return;                                                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_and_self(VALUE self, VALUE other) {                                \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = { iter_##tDType##_bit_and, STRIDE_LOOP, 2, 1, ain, aout };                  \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_and(VALUE self, VALUE other) {                                     \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_bit_and_self(self, other);                                               \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, '&', 1, other);                                                     \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_BIT_AND_METHOD_FUNC()                                                  \
+  static void iter_robject_bit_and(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    char* p3;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR(lp, 2, p3, s3);                                                                   \
+    if (s2 == 0) {                                                                             \
+      if (s1 == sizeof(robject) && s3 == sizeof(robject)) {                                    \
+        if (p1 == p3) {                                                                        \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((robject*)p1)[i] = m_bit_and(((robject*)p1)[i], *(robject*)p2);                   \
+          }                                                                                    \
+        } else {                                                                               \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((robject*)p3)[i] = m_bit_and(((robject*)p1)[i], *(robject*)p2);                   \
+          }                                                                                    \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(robject*)p3 = m_bit_and(*(robject*)p1, *(robject*)p2);                             \
+          p1 += s1;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (p1 == p3) {                                                                          \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(robject*)p1 = m_bit_and(*(robject*)p1, *(robject*)p2);                             \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(robject*)p3 = m_bit_and(*(robject*)p1, *(robject*)p2);                             \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    }                                                                                          \
+    return;                                                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_bit_and_self(VALUE self, VALUE other) {                                 \
+    ndfunc_arg_in_t ain[2] = { { numo_cRObject, 0 }, { numo_cRObject, 0 } };                   \
+    ndfunc_arg_out_t aout[1] = { { numo_cRObject, 0 } };                                       \
+    ndfunc_t ndf = { iter_robject_bit_and, STRIDE_LOOP, 2, 1, ain, aout };                     \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_bit_and(VALUE self, VALUE other) {                                      \
+    return robject_bit_and_self(self, other);                                                  \
+  }
+
+#endif /* NUMO_NARRAY_MH_BIT_AND_H */