numo-narray-alt 0.9.11 → 0.9.12

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

@@ -0,0 +1,225 @@
+#ifndef NUMO_NARRAY_MH_BIT_XOR_H
+#define NUMO_NARRAY_MH_BIT_XOR_H 1
+
+#define DEF_NARRAY_INT_BIT_XOR_METHOD_FUNC(tDType, tNAryClass)                                 \
+  static void iter_##tDType##_bit_xor(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_xor(((tDType*)p1)[i], ((tDType*)p2)[i]);                  \
+          }                                                                                    \
+        } else {                                                                               \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((tDType*)p3)[i] = m_bit_xor(((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_xor(((tDType*)p1)[i], *(tDType*)p2);                  \
+              }                                                                                \
+            } else {                                                                           \
+              for (size_t i = 0; i < n; i++) {                                                 \
+                ((tDType*)p3)[i] = m_bit_xor(((tDType*)p1)[i], *(tDType*)p2);                  \
+              }                                                                                \
+            }                                                                                  \
+          } else {                                                                             \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              *(tDType*)p3 = m_bit_xor(*(tDType*)p1, *(tDType*)p2);                            \
+              p1 += s1;                                                                        \
+              p3 += s3;                                                                        \
+            }                                                                                  \
+          }                                                                                    \
+        } else {                                                                               \
+          if (p1 == p3) {                                                                      \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              *(tDType*)p1 = m_bit_xor(*(tDType*)p1, *(tDType*)p2);                            \
+              p1 += s1;                                                                        \
+              p2 += s2;                                                                        \
+            }                                                                                  \
+          } else {                                                                             \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              *(tDType*)p3 = m_bit_xor(*(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_xor(x, y);                                                        \
+      SET_DATA_STRIDE(p3, s3, tDType, z);                                                      \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_xor_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_xor, STRIDE_LOOP, 2, 1, ain, aout };                  \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_xor(VALUE self, VALUE other) {                                     \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_bit_xor_self(self, other);                                               \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, '^', 1, other);                                                     \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_INT8_BIT_XOR_METHOD_FUNC(tDType, tNAryClass)                                \
+  static void iter_##tDType##_bit_xor(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_xor(((tDType*)p1)[i], *(tDType*)p2);                      \
+          }                                                                                    \
+        } else {                                                                               \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((tDType*)p3)[i] = m_bit_xor(((tDType*)p1)[i], *(tDType*)p2);                      \
+          }                                                                                    \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(tDType*)p3 = m_bit_xor(*(tDType*)p1, *(tDType*)p2);                                \
+          p1 += s1;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (p1 == p3) {                                                                          \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(tDType*)p1 = m_bit_xor(*(tDType*)p1, *(tDType*)p2);                                \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(tDType*)p3 = m_bit_xor(*(tDType*)p1, *(tDType*)p2);                                \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    }                                                                                          \
+    return;                                                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_xor_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_xor, STRIDE_LOOP, 2, 1, ain, aout };                  \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_bit_xor(VALUE self, VALUE other) {                                     \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_bit_xor_self(self, other);                                               \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, '^', 1, other);                                                     \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_BIT_XOR_METHOD_FUNC()                                                  \
+  static void iter_robject_bit_xor(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_xor(((robject*)p1)[i], *(robject*)p2);                   \
+          }                                                                                    \
+        } else {                                                                               \
+          for (size_t i = 0; i < n; i++) {                                                     \
+            ((robject*)p3)[i] = m_bit_xor(((robject*)p1)[i], *(robject*)p2);                   \
+          }                                                                                    \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(robject*)p3 = m_bit_xor(*(robject*)p1, *(robject*)p2);                             \
+          p1 += s1;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (p1 == p3) {                                                                          \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(robject*)p1 = m_bit_xor(*(robject*)p1, *(robject*)p2);                             \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(robject*)p3 = m_bit_xor(*(robject*)p1, *(robject*)p2);                             \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+          p3 += s3;                                                                            \
+        }                                                                                      \
+      }                                                                                        \
+    }                                                                                          \
+    return;                                                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_bit_xor_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_xor, STRIDE_LOOP, 2, 1, ain, aout };                     \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_bit_xor(VALUE self, VALUE other) {                                      \
+    return robject_bit_xor_self(self, other);                                                  \
+  }
+
+#endif /* NUMO_NARRAY_MH_BIT_XOR_H */

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

@@ -0,0 +1,9 @@
+#ifndef NUMO_NARRAY_MH_COERCE_CAST_H
+#define NUMO_NARRAY_MH_COERCE_CAST_H 1
+
+#define DEF_NARRAY_COERCE_CAST_METHOD_FUNC(tDType)                                             \
+  static VALUE tDType##_coerce_cast(VALUE self, VALUE type) {                                  \
+    return Qnil;                                                                               \
+  }
+
+#endif /* NUMO_NARRAY_MH_COERCE_CAST_H */

data/ext/numo/narray/src/mh/comp/binary_func.h

@@ -0,0 +1,37 @@
+#ifndef NUMO_NARRAY_MH_COMP_BINARY_FUNC_H
+#define NUMO_NARRAY_MH_COMP_BINARY_FUNC_H 1
+
+#define DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(fCompFunc, tDType, tNAryClass)                \
+  static void iter_##tDType##_##fCompFunc(na_loop_t* const lp) {                               \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    BIT_DIGIT* a3;                                                                             \
+    size_t p3;                                                                                 \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    ssize_t s3;                                                                                \
+    tDType x;                                                                                  \
+    tDType y;                                                                                  \
+    BIT_DIGIT b;                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR(lp, 0, p1, s1);                                                                   \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+    INIT_PTR_BIT(lp, 2, a3, p3, s3);                                                           \
+    for (size_t i = 0; i < n; i++) {                                                           \
+      GET_DATA_STRIDE(p1, s1, tDType, x);                                                      \
+      GET_DATA_STRIDE(p2, s2, tDType, y);                                                      \
+      b = (m_##fCompFunc(x, y)) ? 1 : 0;                                                       \
+      STORE_BIT(a3, p3, b);                                                                    \
+      p3 += s3;                                                                                \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_##fCompFunc##_self(VALUE self, VALUE other) {                          \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_##fCompFunc, STRIDE_LOOP, 2, 1, ain, aout };              \
+    return na_ndloop(&ndf, 2, self, other);                                                    \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_BINARY_FUNC_H */

data/ext/numo/narray/src/mh/comp/eq.h

@@ -0,0 +1,26 @@
+#ifndef NUMO_NARRAY_MH_COMP_EQ_H
+#define NUMO_NARRAY_MH_COMP_EQ_H 1
+
+#include "binary_func.h"
+
+#define DEF_NARRAY_EQ_METHOD_FUNC(tDType, tNAryClass)                                          \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(eq, tDType, tNAryClass)                             \
+                                                                                               \
+  static VALUE tDType##_eq(VALUE self, VALUE other) {                                          \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_eq_self(self, other);                                                    \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, id_eq, 1, other);                                                   \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_EQ_METHOD_FUNC()                                                       \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(eq, robject, numo_cRObject)                         \
+                                                                                               \
+  static VALUE robject_eq(VALUE self, VALUE other) {                                           \
+    return robject_eq_self(self, other);                                                       \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_EQ_H */

data/ext/numo/narray/src/mh/comp/ge.h

@@ -0,0 +1,26 @@
+#ifndef NUMO_NARRAY_MH_COMP_GE_H
+#define NUMO_NARRAY_MH_COMP_GE_H 1
+
+#include "binary_func.h"
+
+#define DEF_NARRAY_GE_METHOD_FUNC(tDType, tNAryClass)                                          \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(ge, tDType, tNAryClass)                             \
+                                                                                               \
+  static VALUE tDType##_ge(VALUE self, VALUE other) {                                          \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_ge_self(self, other);                                                    \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, id_ge, 1, other);                                                   \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_GE_METHOD_FUNC()                                                       \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(ge, robject, numo_cRObject)                         \
+                                                                                               \
+  static VALUE robject_ge(VALUE self, VALUE other) {                                           \
+    return robject_ge_self(self, other);                                                       \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_GE_H */

data/ext/numo/narray/src/mh/comp/gt.h

@@ -0,0 +1,26 @@
+#ifndef NUMO_NARRAY_MH_COMP_GT_H
+#define NUMO_NARRAY_MH_COMP_GT_H 1
+
+#include "binary_func.h"
+
+#define DEF_NARRAY_GT_METHOD_FUNC(tDType, tNAryClass)                                          \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(gt, tDType, tNAryClass)                             \
+                                                                                               \
+  static VALUE tDType##_gt(VALUE self, VALUE other) {                                          \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_gt_self(self, other);                                                    \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, id_gt, 1, other);                                                   \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_GT_METHOD_FUNC()                                                       \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(gt, robject, numo_cRObject)                         \
+                                                                                               \
+  static VALUE robject_gt(VALUE self, VALUE other) {                                           \
+    return robject_gt_self(self, other);                                                       \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_GT_H */

data/ext/numo/narray/src/mh/comp/le.h

@@ -0,0 +1,26 @@
+#ifndef NUMO_NARRAY_MH_COMP_LE_H
+#define NUMO_NARRAY_MH_COMP_LE_H 1
+
+#include "binary_func.h"
+
+#define DEF_NARRAY_LE_METHOD_FUNC(tDType, tNAryClass)                                          \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(le, tDType, tNAryClass)                             \
+                                                                                               \
+  static VALUE tDType##_le(VALUE self, VALUE other) {                                          \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_le_self(self, other);                                                    \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, id_le, 1, other);                                                   \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_LE_METHOD_FUNC()                                                       \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(le, robject, numo_cRObject)                         \
+                                                                                               \
+  static VALUE robject_le(VALUE self, VALUE other) {                                           \
+    return robject_le_self(self, other);                                                       \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_LE_H */

data/ext/numo/narray/src/mh/comp/lt.h

@@ -0,0 +1,26 @@
+#ifndef NUMO_NARRAY_MH_COMP_LT_H
+#define NUMO_NARRAY_MH_COMP_LT_H 1
+
+#include "binary_func.h"
+
+#define DEF_NARRAY_LT_METHOD_FUNC(tDType, tNAryClass)                                          \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(lt, tDType, tNAryClass)                             \
+                                                                                               \
+  static VALUE tDType##_lt(VALUE self, VALUE other) {                                          \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_lt_self(self, other);                                                    \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, id_lt, 1, other);                                                   \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_LT_METHOD_FUNC()                                                       \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(lt, robject, numo_cRObject)                         \
+                                                                                               \
+  static VALUE robject_lt(VALUE self, VALUE other) {                                           \
+    return robject_lt_self(self, other);                                                       \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_LT_H */

data/ext/numo/narray/src/mh/comp/ne.h

@@ -0,0 +1,26 @@
+#ifndef NUMO_NARRAY_MH_COMP_NE_H
+#define NUMO_NARRAY_MH_COMP_NE_H 1
+
+#include "binary_func.h"
+
+#define DEF_NARRAY_NE_METHOD_FUNC(tDType, tNAryClass)                                          \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(ne, tDType, tNAryClass)                             \
+                                                                                               \
+  static VALUE tDType##_ne(VALUE self, VALUE other) {                                          \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_ne_self(self, other);                                                    \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, id_ne, 1, other);                                                   \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_NE_METHOD_FUNC()                                                       \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(ne, robject, numo_cRObject)                         \
+                                                                                               \
+  static VALUE robject_ne(VALUE self, VALUE other) {                                           \
+    return robject_ne_self(self, other);                                                       \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_NE_H */

data/ext/numo/narray/src/mh/comp/nearly_eq.h

@@ -0,0 +1,26 @@
+#ifndef NUMO_NARRAY_MH_COMP_NEARLY_EQ_H
+#define NUMO_NARRAY_MH_COMP_NEARLY_EQ_H 1
+
+#include "binary_func.h"
+
+#define DEF_NARRAY_NEARLY_EQ_METHOD_FUNC(tDType, tNAryClass)                                   \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(nearly_eq, tDType, tNAryClass)                      \
+                                                                                               \
+  static VALUE tDType##_nearly_eq(VALUE self, VALUE other) {                                   \
+    VALUE klass = na_upcast(rb_obj_class(self), rb_obj_class(other));                          \
+    if (klass == tNAryClass) {                                                                 \
+      return tDType##_nearly_eq_self(self, other);                                             \
+    } else {                                                                                   \
+      VALUE v = rb_funcall(klass, id_cast, 1, self);                                           \
+      return rb_funcall(v, id_nearly_eq, 1, other);                                            \
+    }                                                                                          \
+  }
+
+#define DEF_NARRAY_ROBJ_NEARLY_EQ_METHOD_FUNC()                                                \
+  DEF_NARRAY_BINARY_COMPARISON_METHOD_FUNC(nearly_eq, robject, numo_cRObject)                  \
+                                                                                               \
+  static VALUE robject_nearly_eq(VALUE self, VALUE other) {                                    \
+    return robject_nearly_eq_self(self, other);                                                \
+  }
+
+#endif /* NUMO_NARRAY_MH_COMP_NEARLY_EQ_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

@@ -73,7 +73,7 @@
                                                                                                \
     g = ALLOCA_N(char, sizeof(ssize_t) + sizeof(tDType));                                      \
     *(ssize_t*)g = kofs;                                                                       \
-    *(dtype*)(g + sizeof(ssize_t)) = data;                                                     \
+    *(tDType*)(g + sizeof(ssize_t)) = data;                                                    \
                                                                                                \
     na_ndloop3(&ndf, g, 1, self);                                                              \
     return self;                                                                               \