numo-narray-alt 0.9.11 → 0.9.12

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

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

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

@@ -0,0 +1,108 @@
+#ifndef NUMO_NARRAY_MH_FORMAT_H
+#define NUMO_NARRAY_MH_FORMAT_H 1
+
+#define DEF_NARRAY_FORMAT_METHOD_FUNC(tDType)                                                  \
+  static VALUE format_##tDType(VALUE fmt, tDType* x) {                                         \
+    if (NIL_P(fmt)) {                                                                          \
+      char s[48];                                                                              \
+      int n = m_sprintf(s, *x);                                                                \
+      return rb_str_new(s, n);                                                                 \
+    }                                                                                          \
+    return rb_funcall(fmt, '%', 1, m_data_to_num(*x));                                         \
+  }                                                                                            \
+                                                                                               \
+  static void iter_##tDType##_format(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType* x;                                                                                 \
+    VALUE y;                                                                                   \
+    VALUE fmt = lp->option;                                                                    \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = (tDType*)(p1 + *idx1);                                                             \
+        idx1++;                                                                                \
+        y = format_##tDType(fmt, x);                                                           \
+        SET_DATA_STRIDE(p2, s2, VALUE, y);                                                     \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = (tDType*)p1;                                                                       \
+        p1 += s1;                                                                              \
+        y = format_##tDType(fmt, x);                                                           \
+        SET_DATA_STRIDE(p2, s2, VALUE, y);                                                     \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_format(int argc, VALUE* argv, VALUE self) {                            \
+    VALUE fmt = Qnil;                                                                          \
+    ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_option } };                                  \
+    ndfunc_arg_out_t aout[1] = { { numo_cRObject, 0 } };                                       \
+    ndfunc_t ndf = { iter_##tDType##_format, FULL_LOOP_NIP, 2, 1, ain, aout };                 \
+    rb_scan_args(argc, argv, "01", &fmt);                                                      \
+    return na_ndloop(&ndf, 2, self, fmt);                                                      \
+  }
+
+#define DEF_NARRAY_BIT_FORMAT_METHOD_FUNC()                                                    \
+  static VALUE format_bit(VALUE fmt, BIT_DIGIT x) {                                            \
+    if (NIL_P(fmt)) {                                                                          \
+      char s[4];                                                                               \
+      int n;                                                                                   \
+      n = m_sprintf(s, x);                                                                     \
+      return rb_str_new(s, n);                                                                 \
+    }                                                                                          \
+    return rb_funcall(fmt, '%', 1, m_data_to_num(x));                                          \
+  }                                                                                            \
+                                                                                               \
+  static void iter_bit_format(na_loop_t* const lp) {                                           \
+    size_t n;                                                                                  \
+    BIT_DIGIT* a1;                                                                             \
+    BIT_DIGIT x = 0;                                                                           \
+    size_t p1;                                                                                 \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    VALUE y;                                                                                   \
+    VALUE fmt = lp->option;                                                                    \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);                                                 \
+    INIT_PTR(lp, 1, p2, s2);                                                                   \
+                                                                                               \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        LOAD_BIT(a1, p1 + *idx1, x);                                                           \
+        idx1++;                                                                                \
+        y = format_bit(fmt, x);                                                                \
+        SET_DATA_STRIDE(p2, s2, VALUE, y);                                                     \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        LOAD_BIT(a1, p1, x);                                                                   \
+        p1 += s1;                                                                              \
+        y = format_bit(fmt, x);                                                                \
+        SET_DATA_STRIDE(p2, s2, VALUE, y);                                                     \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE bit_format(int argc, VALUE* argv, VALUE self) {                                 \
+    VALUE fmt = Qnil;                                                                          \
+    ndfunc_arg_in_t ain[2] = { { Qnil, 0 }, { sym_option } };                                  \
+    ndfunc_arg_out_t aout[1] = { { numo_cRObject, 0 } };                                       \
+    ndfunc_t ndf = { iter_bit_format, FULL_LOOP_NIP, 2, 1, ain, aout };                        \
+    rb_scan_args(argc, argv, "01", &fmt);                                                      \
+    return na_ndloop(&ndf, 2, self, fmt);                                                      \
+  }
+
+#endif /* NUMO_NARRAY_MH_FORMAT_H */

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

@@ -0,0 +1,89 @@
+#ifndef NUMO_NARRAY_MH_FORMAT_TO_A_H
+#define NUMO_NARRAY_MH_FORMAT_TO_A_H 1
+
+#define DEF_NARRAY_FORMAT_TO_A_METHOD_FUNC(tDType)                                             \
+  static void iter_##tDType##_format_to_a(na_loop_t* const lp) {                               \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType* x;                                                                                 \
+    VALUE y;                                                                                   \
+    volatile VALUE a;                                                                          \
+    VALUE fmt = lp->option;                                                                    \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+                                                                                               \
+    a = rb_ary_new2(n);                                                                        \
+    rb_ary_push(lp->args[1].value, a);                                                         \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = (tDType*)(p1 + *idx1);                                                             \
+        idx1++;                                                                                \
+        y = format_##tDType(fmt, x);                                                           \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = (tDType*)p1;                                                                       \
+        p1 += s1;                                                                              \
+        y = format_##tDType(fmt, x);                                                           \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_format_to_a(int argc, VALUE* argv, VALUE self) {                       \
+    VALUE fmt = Qnil;                                                                          \
+    ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };                \
+    ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_format_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };            \
+    rb_scan_args(argc, argv, "01", &fmt);                                                      \
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);                                   \
+  }
+
+#define DEF_NARRAY_BIT_FORMAT_TO_A_METHOD_FUNC()                                               \
+  static void iter_bit_format_to_a(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    BIT_DIGIT* a1;                                                                             \
+    BIT_DIGIT x = 0;                                                                           \
+    size_t p1;                                                                                 \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    VALUE y;                                                                                   \
+    VALUE fmt = lp->option;                                                                    \
+    volatile VALUE a;                                                                          \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_BIT_IDX(lp, 0, a1, p1, s1, idx1);                                                 \
+                                                                                               \
+    a = rb_ary_new2(n);                                                                        \
+    rb_ary_push(lp->args[1].value, a);                                                         \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        LOAD_BIT(a1, p1 + *idx1, x);                                                           \
+        idx1++;                                                                                \
+        y = format_bit(fmt, x);                                                                \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        LOAD_BIT(a1, p1, x);                                                                   \
+        p1 += s1;                                                                              \
+        y = format_bit(fmt, x);                                                                \
+        rb_ary_push(a, y);                                                                     \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE bit_format_to_a(int argc, VALUE* argv, VALUE self) {                            \
+    VALUE fmt = Qnil;                                                                          \
+    ndfunc_arg_in_t ain[3] = { { Qnil, 0 }, { sym_loop_opt }, { sym_option } };                \
+    ndfunc_arg_out_t aout[1] = { { rb_cArray, 0 } };                                           \
+    ndfunc_t ndf = { iter_bit_format_to_a, FULL_LOOP_NIP, 3, 1, ain, aout };                   \
+    rb_scan_args(argc, argv, "01", &fmt);                                                      \
+    return na_ndloop_cast_narray_to_rarray(&ndf, self, fmt);                                   \
+  }
+
+#endif /* NUMO_NARRAY_MH_FORMAT_TO_A_H */

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

@@ -0,0 +1,33 @@
+#ifndef NUMO_NARRAY_MH_INSPECT_H
+#define NUMO_NARRAY_MH_INSPECT_H 1
+
+#define DEF_NARRAY_INSPECT_METHOD_FUNC(tDType)                                                 \
+  static VALUE iter_##tDType##_inspect(char* ptr, size_t pos, VALUE fmt) {                     \
+    return format_##tDType(fmt, (tDType*)(ptr + pos));                                         \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_inspect(VALUE ary) {                                                   \
+    return na_ndloop_inspect(ary, iter_##tDType##_inspect, Qnil);                              \
+  }
+
+#define DEF_NARRAY_ROBJ_INSPECT_METHOD_FUNC()                                                  \
+  static VALUE iter_robject_inspect(char* ptr, size_t pos, VALUE fmt) {                        \
+    return rb_inspect(*(VALUE*)(ptr + pos));                                                   \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_inspect(VALUE ary) {                                                    \
+    return na_ndloop_inspect(ary, iter_robject_inspect, Qnil);                                 \
+  }
+
+#define DEF_NARRAY_BIT_INSPECT_METHOD_FUNC()                                                   \
+  static VALUE iter_bit_inspect(char* ptr, size_t pos, VALUE fmt) {                            \
+    BIT_DIGIT x;                                                                               \
+    LOAD_BIT(ptr, pos, x);                                                                     \
+    return format_bit(fmt, x);                                                                 \
+  }                                                                                            \
+                                                                                               \
+  static VALUE bit_inspect(VALUE ary) {                                                        \
+    return na_ndloop_inspect(ary, iter_bit_inspect, Qnil);                                     \
+  }
+
+#endif /* NUMO_NARRAY_MH_INSPECT_H */

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

@@ -0,0 +1,42 @@
+#ifndef NUMO_NARRAY_MH_ISFINITE_H
+#define NUMO_NARRAY_MH_ISFINITE_H 1
+
+#define DEF_NARRAY_FLT_ISFINITE_METHOD_FUNC(tDType, tNAryClass)                                \
+  static void iter_##tDType##_isfinite(na_loop_t* const lp) {                                  \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    BIT_DIGIT* a2;                                                                             \
+    size_t p2;                                                                                 \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    BIT_DIGIT b;                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);                                                           \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        b = (m_isfinite(x)) ? 1 : 0;                                                           \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        b = (m_isfinite(x)) ? 1 : 0;                                                           \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_isfinite(VALUE self) {                                                 \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 0 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_isfinite, FULL_LOOP, 1, 1, ain, aout };                   \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#endif /* NUMO_NARRAY_MH_ISFINITE_H */

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

@@ -0,0 +1,42 @@
+#ifndef NUMO_NARRAY_MH_ISINF_H
+#define NUMO_NARRAY_MH_ISINF_H 1
+
+#define DEF_NARRAY_FLT_ISINF_METHOD_FUNC(tDType, tNAryClass)                                   \
+  static void iter_##tDType##_isinf(na_loop_t* const lp) {                                     \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    BIT_DIGIT* a2;                                                                             \
+    size_t p2;                                                                                 \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    BIT_DIGIT b;                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);                                                           \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        b = (m_isinf(x)) ? 1 : 0;                                                              \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        b = (m_isinf(x)) ? 1 : 0;                                                              \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_isinf(VALUE self) {                                                    \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 0 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_isinf, FULL_LOOP, 1, 1, ain, aout };                      \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#endif /* NUMO_NARRAY_MH_ISINF_H */

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

@@ -0,0 +1,42 @@
+#ifndef NUMO_NARRAY_MH_ISNAN_H
+#define NUMO_NARRAY_MH_ISNAN_H 1
+
+#define DEF_NARRAY_FLT_ISNAN_METHOD_FUNC(tDType, tNAryClass)                                   \
+  static void iter_##tDType##_isnan(na_loop_t* const lp) {                                     \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    BIT_DIGIT* a2;                                                                             \
+    size_t p2;                                                                                 \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    BIT_DIGIT b;                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);                                                           \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        b = (m_isnan(x)) ? 1 : 0;                                                              \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        b = (m_isnan(x)) ? 1 : 0;                                                              \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_isnan(VALUE self) {                                                    \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 0 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_isnan, FULL_LOOP, 1, 1, ain, aout };                      \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#endif /* NUMO_NARRAY_MH_ISNAN_H */

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

@@ -0,0 +1,42 @@
+#ifndef NUMO_NARRAY_MH_ISNEGINF_H
+#define NUMO_NARRAY_MH_ISNEGINF_H 1
+
+#define DEF_NARRAY_FLT_ISNEGINF_METHOD_FUNC(tDType, tNAryClass)                                \
+  static void iter_##tDType##_isneginf(na_loop_t* const lp) {                                  \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    BIT_DIGIT* a2;                                                                             \
+    size_t p2;                                                                                 \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    BIT_DIGIT b;                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);                                                           \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        b = (m_isneginf(x)) ? 1 : 0;                                                           \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        b = (m_isneginf(x)) ? 1 : 0;                                                           \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_isneginf(VALUE self) {                                                 \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 0 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_isneginf, FULL_LOOP, 1, 1, ain, aout };                   \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#endif /* NUMO_NARRAY_MH_ISNEGINF_H */

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

@@ -0,0 +1,42 @@
+#ifndef NUMO_NARRAY_MH_ISPOSINF_H
+#define NUMO_NARRAY_MH_ISPOSINF_H 1
+
+#define DEF_NARRAY_FLT_ISPOSINF_METHOD_FUNC(tDType, tNAryClass)                                \
+  static void iter_##tDType##_isposinf(na_loop_t* const lp) {                                  \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    BIT_DIGIT* a2;                                                                             \
+    size_t p2;                                                                                 \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    BIT_DIGIT b;                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_BIT(lp, 1, a2, p2, s2);                                                           \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+        b = (m_isposinf(x)) ? 1 : 0;                                                           \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        GET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+        b = (m_isposinf(x)) ? 1 : 0;                                                           \
+        STORE_BIT(a2, p2, b);                                                                  \
+        p2 += s2;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_isposinf(VALUE self) {                                                 \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 0 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { numo_cBit, 0 } };                                           \
+    ndfunc_t ndf = { iter_##tDType##_isposinf, FULL_LOOP, 1, 1, ain, aout };                   \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#endif /* NUMO_NARRAY_MH_ISPOSINF_H */

data/ext/numo/narray/src/mh/math/acos.h

@@ -3,7 +3,7 @@
 
 #include "unary_func.h"
 
-#define DEF_NARRAY_FLT_ACOS_METHOD_FUNC(tDType, tNAryType)                                     \
-  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(acos, tDType, tNAryType)
+#define DEF_NARRAY_FLT_ACOS_METHOD_FUNC(tDType, tNAryClass)                                    \
+  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(acos, tDType, tNAryClass)
 
 #endif /* NUMO_NARRAY_MH_MATH_ACOS_H */

data/ext/numo/narray/src/mh/math/acosh.h

@@ -3,7 +3,7 @@
 
 #include "unary_func.h"
 
-#define DEF_NARRAY_FLT_ACOSH_METHOD_FUNC(tDType, tNAryType)                                    \
-  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(acosh, tDType, tNAryType)
+#define DEF_NARRAY_FLT_ACOSH_METHOD_FUNC(tDType, tNAryClass)                                   \
+  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(acosh, tDType, tNAryClass)
 
 #endif /* NUMO_NARRAY_MH_MATH_ACOSH_H */

data/ext/numo/narray/src/mh/math/asin.h

@@ -3,7 +3,7 @@
 
 #include "unary_func.h"
 
-#define DEF_NARRAY_FLT_ASIN_METHOD_FUNC(tDType, tNAryType)                                     \
-  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(asin, tDType, tNAryType)
+#define DEF_NARRAY_FLT_ASIN_METHOD_FUNC(tDType, tNAryClass)                                    \
+  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(asin, tDType, tNAryClass)
 
 #endif /* NUMO_NARRAY_MH_MATH_ASIN_H */

data/ext/numo/narray/src/mh/math/asinh.h

@@ -3,7 +3,7 @@
 
 #include "unary_func.h"
 
-#define DEF_NARRAY_FLT_ASINH_METHOD_FUNC(tDType, tNAryType)                                    \
-  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(asinh, tDType, tNAryType)
+#define DEF_NARRAY_FLT_ASINH_METHOD_FUNC(tDType, tNAryClass)                                   \
+  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(asinh, tDType, tNAryClass)
 
 #endif /* NUMO_NARRAY_MH_MATH_ASINH_H */

data/ext/numo/narray/src/mh/math/atan.h

@@ -3,7 +3,7 @@
 
 #include "unary_func.h"
 
-#define DEF_NARRAY_FLT_ATAN_METHOD_FUNC(tDType, tNAryType)                                     \
-  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(atan, tDType, tNAryType)
+#define DEF_NARRAY_FLT_ATAN_METHOD_FUNC(tDType, tNAryClass)                                    \
+  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(atan, tDType, tNAryClass)
 
 #endif /* NUMO_NARRAY_MH_MATH_ATAN_H */