numo-narray-alt 0.9.10 → 0.9.12

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/logseq.h

@@ -0,0 +1,69 @@
+#ifndef NUMO_NARRAY_MH_LOGSEQ_H
+#define NUMO_NARRAY_MH_LOGSEQ_H 1
+
+#define DEF_NARRAY_FLT_LOGSEQ_METHOD_FUNC(tDType)                                              \
+  typedef struct {                                                                             \
+    tDType beg;                                                                                \
+    tDType step;                                                                               \
+    tDType base;                                                                               \
+    double count;                                                                              \
+  } logseq_opt_t;                                                                              \
+                                                                                               \
+  static void iter_##tDType##_logseq(na_loop_t* const lp) {                                    \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    tDType beg;                                                                                \
+    tDType step;                                                                               \
+    tDType base;                                                                               \
+    double c;                                                                                  \
+    logseq_opt_t* g;                                                                           \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    g = (logseq_opt_t*)(lp->opt_ptr);                                                          \
+    beg = g->beg;                                                                              \
+    step = g->step;                                                                            \
+    base = g->base;                                                                            \
+    c = g->count;                                                                              \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = f_seq(beg, step, c++);                                                             \
+        *(tDType*)(p1 + *idx1) = m_pow(base, x);                                               \
+        idx1++;                                                                                \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = f_seq(beg, step, c++);                                                             \
+        *(tDType*)(p1) = m_pow(base, x);                                                       \
+        p1 += s1;                                                                              \
+      }                                                                                        \
+    }                                                                                          \
+    g->count = c;                                                                              \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_logseq(int argc, VALUE* argv, VALUE self) {                            \
+    logseq_opt_t* g;                                                                           \
+    VALUE vbeg;                                                                                \
+    VALUE vstep;                                                                               \
+    VALUE vbase = Qnil;                                                                        \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_logseq, FULL_LOOP, 1, 0, ain, 0 };                        \
+                                                                                               \
+    g = ALLOCA_N(logseq_opt_t, 1);                                                             \
+    rb_scan_args(argc, argv, "21", &vbeg, &vstep, &vbase);                                     \
+    g->beg = m_num_to_data(vbeg);                                                              \
+    g->step = m_num_to_data(vstep);                                                            \
+    g->count = 0;                                                                              \
+    if (vbase == Qnil) {                                                                       \
+      g->base = m_from_real(10);                                                               \
+    } else {                                                                                   \
+      g->base = m_num_to_data(vbase);                                                          \
+    }                                                                                          \
+    na_ndloop3(&ndf, g, 1, self);                                                              \
+    return self;                                                                               \
+  }
+
+#endif /* NUMO_NARRAY_MH_LOGSEQ_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 */

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

@@ -1,7 +1,7 @@
 #ifndef NUMO_NARRAY_MH_MATH_ATAN2_H
 #define NUMO_NARRAY_MH_MATH_ATAN2_H 1
 
-#define DEF_NARRAY_FLT_ATAN2_METHOD_FUNC(tDType, tNAryType)                                    \
+#define DEF_NARRAY_FLT_ATAN2_METHOD_FUNC(tDType, tNAryClass)                                   \
   static void iter_##tDType##_math_s_atan2(na_loop_t* const lp) {                              \
     size_t n;                                                                                  \
     char *p1, *p2, *p3;                                                                        \
@@ -20,8 +20,8 @@
   }                                                                                            \
                                                                                                \
   static VALUE tDType##_math_s_atan2(VALUE mod, VALUE a1, VALUE a2) {                          \
-    ndfunc_arg_in_t ain[2] = { { tNAryType, 0 }, { tNAryType, 0 } };                           \
-    ndfunc_arg_out_t aout[1] = { { tNAryType, 0 } };                                           \
+    ndfunc_arg_in_t ain[2] = { { tNAryClass, 0 }, { tNAryClass, 0 } };                         \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
     ndfunc_t ndf = { iter_##tDType##_math_s_atan2, STRIDE_LOOP, 2, 1, ain, aout };             \
     return na_ndloop(&ndf, 2, a1, a2);                                                         \
   }

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

@@ -3,7 +3,7 @@
 
 #include "unary_func.h"
 
-#define DEF_NARRAY_FLT_ATANH_METHOD_FUNC(tDType, tNAryType)                                    \
-  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(atanh, tDType, tNAryType)
+#define DEF_NARRAY_FLT_ATANH_METHOD_FUNC(tDType, tNAryClass)                                   \
+  DEF_NARRAY_FLT_UNARY_MATH_METHOD_FUNC(atanh, tDType, tNAryClass)
 
 #endif /* NUMO_NARRAY_MH_MATH_ATANH_H */