numo-narray-alt 0.9.10 → 0.9.12

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

@@ -0,0 +1,315 @@
+#ifndef NUMO_NARRAY_MH_RAND_H
+#define NUMO_NARRAY_MH_RAND_H 1
+
+#define DEF_NARRAY_CMP_RAND_METHOD_FUNC(tDType)                                                \
+  typedef struct {                                                                             \
+    tDType low;                                                                                \
+    tDType max;                                                                                \
+  } rand_opt_t;                                                                                \
+                                                                                               \
+  static void iter_##tDType##_rand(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    rand_opt_t* g;                                                                             \
+    tDType low;                                                                                \
+    tDType max;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    g = (rand_opt_t*)(lp->opt_ptr);                                                            \
+    low = g->low;                                                                              \
+    max = g->max;                                                                              \
+                                                                                               \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max), low);                                                           \
+        SET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max), low);                                                           \
+        SET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_rand(int argc, VALUE* argv, VALUE self) {                              \
+    rand_opt_t g;                                                                              \
+    VALUE v1 = Qnil;                                                                           \
+    VALUE v2 = Qnil;                                                                           \
+    tDType high;                                                                               \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_rand, FULL_LOOP, 1, 0, ain, 0 };                          \
+                                                                                               \
+    rb_scan_args(argc, argv, "02", &v1, &v2);                                                  \
+    if (v2 == Qnil) {                                                                          \
+      g.low = m_zero;                                                                          \
+      if (v1 == Qnil) {                                                                        \
+        g.max = high = c_new(1, 1);                                                            \
+      } else {                                                                                 \
+        g.max = high = m_num_to_data(v1);                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      g.low = m_num_to_data(v1);                                                               \
+      high = m_num_to_data(v2);                                                                \
+      g.max = m_sub(high, g.low);                                                              \
+    }                                                                                          \
+                                                                                               \
+    na_ndloop3(&ndf, &g, 1, self);                                                             \
+    return self;                                                                               \
+  }
+
+#define DEF_NARRAY_FLT_RAND_METHOD_FUNC(tDType)                                                \
+  typedef struct {                                                                             \
+    tDType low;                                                                                \
+    tDType max;                                                                                \
+  } rand_opt_t;                                                                                \
+                                                                                               \
+  static void iter_##tDType##_rand(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    rand_opt_t* g;                                                                             \
+    tDType low;                                                                                \
+    tDType max;                                                                                \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    g = (rand_opt_t*)(lp->opt_ptr);                                                            \
+    low = g->low;                                                                              \
+    max = g->max;                                                                              \
+                                                                                               \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max), low);                                                           \
+        SET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max), low);                                                           \
+        SET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_rand(int argc, VALUE* args, VALUE self) {                              \
+    rand_opt_t g;                                                                              \
+    VALUE v1 = Qnil;                                                                           \
+    VALUE v2 = Qnil;                                                                           \
+    tDType high;                                                                               \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_rand, FULL_LOOP, 1, 0, ain, 0 };                          \
+                                                                                               \
+    rb_scan_args(argc, args, "02", &v1, &v2);                                                  \
+    if (v2 == Qnil) {                                                                          \
+      g.low = m_zero;                                                                          \
+      if (v1 == Qnil) {                                                                        \
+        g.max = high = m_one;                                                                  \
+      } else {                                                                                 \
+        g.max = high = m_num_to_data(v1);                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      g.low = m_num_to_data(v1);                                                               \
+      high = m_num_to_data(v2);                                                                \
+      g.max = m_sub(high, g.low);                                                              \
+    }                                                                                          \
+                                                                                               \
+    na_ndloop3(&ndf, &g, 1, self);                                                             \
+    return self;                                                                               \
+  }
+
+#define DEF_NARRAY_INT_RAND_METHOD_FUNC(tDType)                                                \
+  static int msb_pos(uint32_t a) {                                                             \
+    const int hwid = 4 * sizeof(tDType);                                                       \
+    int width = hwid;                                                                          \
+    int pos = 0;                                                                               \
+    uint32_t mask = (((tDType)1 << hwid) - 1) << hwid;                                         \
+                                                                                               \
+    if (a == 0) {                                                                              \
+      return -1;                                                                               \
+    }                                                                                          \
+                                                                                               \
+    while (width) {                                                                            \
+      if (a & mask) {                                                                          \
+        pos += width;                                                                          \
+      } else {                                                                                 \
+        mask >>= width;                                                                        \
+      }                                                                                        \
+      width >>= 1;                                                                             \
+      mask &= mask << width;                                                                   \
+    }                                                                                          \
+    return pos;                                                                                \
+  }                                                                                            \
+                                                                                               \
+  inline static tDType m_rand(uint32_t max, int shift) {                                       \
+    uint32_t x;                                                                                \
+    do {                                                                                       \
+      x = gen_rand32();                                                                        \
+      x >>= shift;                                                                             \
+    } while (x >= max);                                                                        \
+    return x;                                                                                  \
+  }                                                                                            \
+                                                                                               \
+  typedef struct {                                                                             \
+    tDType low;                                                                                \
+    uint32_t max;                                                                              \
+  } rand_opt_t;                                                                                \
+                                                                                               \
+  static void iter_##tDType##_rand(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    rand_opt_t* g;                                                                             \
+    tDType low;                                                                                \
+    uint32_t max;                                                                              \
+    int shift;                                                                                 \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    g = (rand_opt_t*)(lp->opt_ptr);                                                            \
+    low = g->low;                                                                              \
+    max = g->max;                                                                              \
+    shift = 31 - msb_pos(max);                                                                 \
+                                                                                               \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max, shift), low);                                                    \
+        SET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max, shift), low);                                                    \
+        SET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_rand(int argc, VALUE* argv, VALUE self) {                              \
+    rand_opt_t g;                                                                              \
+    VALUE v1 = Qnil;                                                                           \
+    VALUE v2 = Qnil;                                                                           \
+    tDType high;                                                                               \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_rand, FULL_LOOP, 1, 0, ain, 0 };                          \
+                                                                                               \
+    rb_scan_args(argc, argv, "11", &v1, &v2);                                                  \
+    if (v2 == Qnil) {                                                                          \
+      g.low = m_zero;                                                                          \
+      g.max = high = m_num_to_data(v1);                                                        \
+    } else {                                                                                   \
+      g.low = m_num_to_data(v1);                                                               \
+      high = m_num_to_data(v2);                                                                \
+      g.max = m_sub(high, g.low);                                                              \
+    }                                                                                          \
+                                                                                               \
+    if (high <= g.low) {                                                                       \
+      rb_raise(rb_eArgError, "high must be larger than low");                                  \
+    }                                                                                          \
+                                                                                               \
+    na_ndloop3(&ndf, &g, 1, self);                                                             \
+    return self;                                                                               \
+  }
+
+#define DEF_NARRAY_INT64_RAND_METHOD_FUNC(tDType)                                              \
+  static int msb_pos(uint64_t a) {                                                             \
+    const int hwid = 4 * sizeof(tDType);                                                       \
+    int width = hwid;                                                                          \
+    int pos = 0;                                                                               \
+    uint64_t mask = (((tDType)1 << hwid) - 1) << hwid;                                         \
+                                                                                               \
+    if (a == 0) {                                                                              \
+      return -1;                                                                               \
+    }                                                                                          \
+                                                                                               \
+    while (width) {                                                                            \
+      if (a & mask) {                                                                          \
+        pos += width;                                                                          \
+      } else {                                                                                 \
+        mask >>= width;                                                                        \
+      }                                                                                        \
+      width >>= 1;                                                                             \
+      mask &= mask << width;                                                                   \
+    }                                                                                          \
+    return pos;                                                                                \
+  }                                                                                            \
+                                                                                               \
+  inline static tDType m_rand(uint64_t max, int shift) {                                       \
+    uint64_t x;                                                                                \
+    do {                                                                                       \
+      x = gen_rand32();                                                                        \
+      x = (x << 32) | gen_rand32();                                                            \
+      x >>= shift;                                                                             \
+    } while (x >= max);                                                                        \
+    return x;                                                                                  \
+  }                                                                                            \
+                                                                                               \
+  typedef struct {                                                                             \
+    tDType low;                                                                                \
+    uint64_t max;                                                                              \
+  } rand_opt_t;                                                                                \
+                                                                                               \
+  static void iter_##tDType##_rand(na_loop_t* const lp) {                                      \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    ssize_t s1;                                                                                \
+    size_t* idx1;                                                                              \
+    tDType x;                                                                                  \
+    rand_opt_t* g;                                                                             \
+    tDType low;                                                                                \
+    uint64_t max;                                                                              \
+    int shift;                                                                                 \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    g = (rand_opt_t*)(lp->opt_ptr);                                                            \
+    low = g->low;                                                                              \
+    max = g->max;                                                                              \
+    shift = 63 - msb_pos(max);                                                                 \
+                                                                                               \
+    if (idx1) {                                                                                \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max, shift), low);                                                    \
+        SET_DATA_INDEX(p1, idx1, tDType, x);                                                   \
+      }                                                                                        \
+    } else {                                                                                   \
+      for (size_t i = 0; i < n; i++) {                                                         \
+        x = m_add(m_rand(max, shift), low);                                                    \
+        SET_DATA_STRIDE(p1, s1, tDType, x);                                                    \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_rand(int argc, VALUE* argv, VALUE self) {                              \
+    rand_opt_t g;                                                                              \
+    VALUE v1 = Qnil;                                                                           \
+    VALUE v2 = Qnil;                                                                           \
+    tDType high;                                                                               \
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };                                             \
+    ndfunc_t ndf = { iter_##tDType##_rand, FULL_LOOP, 1, 0, ain, 0 };                          \
+                                                                                               \
+    rb_scan_args(argc, argv, "11", &v1, &v2);                                                  \
+    if (v2 == Qnil) {                                                                          \
+      g.low = m_zero;                                                                          \
+      g.max = high = m_num_to_data(v1);                                                        \
+    } else {                                                                                   \
+      g.low = m_num_to_data(v1);                                                               \
+      high = m_num_to_data(v2);                                                                \
+      g.max = m_sub(high, g.low);                                                              \
+    }                                                                                          \
+                                                                                               \
+    if (high <= g.low) {                                                                       \
+      rb_raise(rb_eArgError, "high must be larger than low");                                  \
+    }                                                                                          \
+                                                                                               \
+    na_ndloop3(&ndf, &g, 1, self);                                                             \
+    return self;                                                                               \
+  }
+
+#endif /* NUMO_NARRAY_MH_RAND_H */

data/ext/numo/narray/src/mh/round/ceil.h

@@ -0,0 +1,11 @@
+#ifndef NUMO_NARRAY_MH_ROUND_CEIL_H
+#define NUMO_NARRAY_MH_ROUND_CEIL_H 1
+
+#include "unary_func.h"
+
+#define DEF_NARRAY_FLT_CEIL_METHOD_FUNC(tDType, tNAryClass)                                    \
+  DEF_NARRAY_FLT_UNARY_ROUND_METHOD_FUNC(ceil, tDType, tNAryClass)
+
+#define DEF_NARRAY_ROBJ_CEIL_METHOD_FUNC() DEF_NARRAY_ROBJ_UNARY_ROUND_METHOD_FUNC(ceil)
+
+#endif /* NUMO_NARRAY_MH_ROUND_CEIL_H */

data/ext/numo/narray/src/mh/round/floor.h

@@ -0,0 +1,11 @@
+#ifndef NUMO_NARRAY_MH_ROUND_FLOOR_H
+#define NUMO_NARRAY_MH_ROUND_FLOOR_H 1
+
+#include "unary_func.h"
+
+#define DEF_NARRAY_FLT_FLOOR_METHOD_FUNC(tDType, tNAryClass)                                   \
+  DEF_NARRAY_FLT_UNARY_ROUND_METHOD_FUNC(floor, tDType, tNAryClass)
+
+#define DEF_NARRAY_ROBJ_FLOOR_METHOD_FUNC() DEF_NARRAY_ROBJ_UNARY_ROUND_METHOD_FUNC(floor)
+
+#endif /* NUMO_NARRAY_MH_ROUND_FLOOR_H */

data/ext/numo/narray/src/mh/round/rint.h

@@ -0,0 +1,9 @@
+#ifndef NUMO_NARRAY_MH_ROUND_RINT_H
+#define NUMO_NARRAY_MH_ROUND_RINT_H 1
+
+#include "unary_func.h"
+
+#define DEF_NARRAY_FLT_RINT_METHOD_FUNC(tDType, tNAryClass)                                    \
+  DEF_NARRAY_FLT_UNARY_ROUND_METHOD_FUNC(rint, tDType, tNAryClass)
+
+#endif /* NUMO_NARRAY_MH_ROUND_RINT_H */

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

@@ -0,0 +1,11 @@
+#ifndef NUMO_NARRAY_MH_ROUND_ROUND_H
+#define NUMO_NARRAY_MH_ROUND_ROUND_H 1
+
+#include "unary_func.h"
+
+#define DEF_NARRAY_FLT_ROUND_METHOD_FUNC(tDType, tNAryClass)                                   \
+  DEF_NARRAY_FLT_UNARY_ROUND_METHOD_FUNC(round, tDType, tNAryClass)
+
+#define DEF_NARRAY_ROBJ_ROUND_METHOD_FUNC() DEF_NARRAY_ROBJ_UNARY_ROUND_METHOD_FUNC(round)
+
+#endif /* NUMO_NARRAY_MH_ROUND_ROUND_H */

data/ext/numo/narray/src/mh/round/trunc.h

@@ -0,0 +1,11 @@
+#ifndef NUMO_NARRAY_MH_ROUND_TRUNC_H
+#define NUMO_NARRAY_MH_ROUND_TRUNC_H 1
+
+#include "unary_func.h"
+
+#define DEF_NARRAY_FLT_TRUNC_METHOD_FUNC(tDType, tNAryClass)                                   \
+  DEF_NARRAY_FLT_UNARY_ROUND_METHOD_FUNC(trunc, tDType, tNAryClass)
+
+#define DEF_NARRAY_ROBJ_TRUNC_METHOD_FUNC() DEF_NARRAY_ROBJ_UNARY_ROUND_METHOD_FUNC(trunc)
+
+#endif /* NUMO_NARRAY_MH_ROUND_TRUNC_H */

data/ext/numo/narray/src/mh/round/unary_func.h

@@ -0,0 +1,127 @@
+#ifndef NUMO_NARRAY_MH_ROUND_UNARY_FUNC_H
+#define NUMO_NARRAY_MH_ROUND_UNARY_FUNC_H 1
+
+#define DEF_NARRAY_FLT_UNARY_ROUND_METHOD_FUNC(fRoundFunc, tDType, tNAryClass)                 \
+  static void iter_##tDType##_##fRoundFunc(na_loop_t* const lp) {                              \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    size_t* idx2;                                                                              \
+    tDType x;                                                                                  \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);                                                         \
+                                                                                               \
+    if (idx1) {                                                                                \
+      if (idx2) {                                                                              \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA_INDEX(p1, idx1, tDType, x);                                                 \
+          x = m_##fRoundFunc(x);                                                               \
+          SET_DATA_INDEX(p2, idx2, tDType, x);                                                 \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA_INDEX(p1, idx1, tDType, x);                                                 \
+          x = m_##fRoundFunc(x);                                                               \
+          SET_DATA_STRIDE(p2, s2, tDType, x);                                                  \
+        }                                                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (idx2) {                                                                              \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA_STRIDE(p1, s1, tDType, x);                                                  \
+          x = m_##fRoundFunc(x);                                                               \
+          SET_DATA_INDEX(p2, idx2, tDType, x);                                                 \
+        }                                                                                      \
+      } else {                                                                                 \
+        if (is_aligned(p1, sizeof(tDType)) && is_aligned(p2, sizeof(tDType))) {                \
+          if (s1 == sizeof(tDType) && s2 == sizeof(tDType)) {                                  \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              ((tDType*)p2)[i] = m_##fRoundFunc(((tDType*)p1)[i]);                             \
+            }                                                                                  \
+            return;                                                                            \
+          }                                                                                    \
+          if (is_aligned_step(s1, sizeof(tDType)) && is_aligned_step(s2, sizeof(tDType))) {    \
+            for (size_t i = 0; i < n; i++) {                                                   \
+              *(tDType*)p2 = m_##fRoundFunc(*(tDType*)p1);                                     \
+              p1 += s1;                                                                        \
+              p2 += s2;                                                                        \
+            }                                                                                  \
+            return;                                                                            \
+          }                                                                                    \
+        }                                                                                      \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA_STRIDE(p1, s1, tDType, x);                                                  \
+          x = m_##fRoundFunc(x);                                                               \
+          SET_DATA_STRIDE(p2, s2, tDType, x);                                                  \
+        }                                                                                      \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE tDType##_##fRoundFunc(VALUE self) {                                             \
+    ndfunc_arg_in_t ain[1] = { { tNAryClass, 0 } };                                            \
+    ndfunc_arg_out_t aout[1] = { { tNAryClass, 0 } };                                          \
+    ndfunc_t ndf = { iter_##tDType##_##fRoundFunc, FULL_LOOP, 1, 1, ain, aout };               \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#define DEF_NARRAY_ROBJ_UNARY_ROUND_METHOD_FUNC(fRoundFunc)                                    \
+  static void iter_robject_##fRoundFunc(na_loop_t* const lp) {                                 \
+    size_t n;                                                                                  \
+    char* p1;                                                                                  \
+    char* p2;                                                                                  \
+    ssize_t s1;                                                                                \
+    ssize_t s2;                                                                                \
+    size_t* idx1;                                                                              \
+    size_t* idx2;                                                                              \
+    robject x;                                                                                 \
+                                                                                               \
+    INIT_COUNTER(lp, n);                                                                       \
+    INIT_PTR_IDX(lp, 0, p1, s1, idx1);                                                         \
+    INIT_PTR_IDX(lp, 1, p2, s2, idx2);                                                         \
+                                                                                               \
+    if (idx1) {                                                                                \
+      if (idx2) {                                                                              \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA_INDEX(p1, idx1, robject, x);                                                \
+          x = m_##fRoundFunc(x);                                                               \
+          SET_DATA_INDEX(p2, idx2, robject, x);                                                \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA_INDEX(p1, idx1, robject, x);                                                \
+          x = m_##fRoundFunc(x);                                                               \
+          SET_DATA_STRIDE(p2, s2, robject, x);                                                 \
+        }                                                                                      \
+      }                                                                                        \
+    } else {                                                                                   \
+      if (idx2) {                                                                              \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          GET_DATA_STRIDE(p1, s1, robject, x);                                                 \
+          x = m_##fRoundFunc(x);                                                               \
+          SET_DATA_INDEX(p2, idx2, robject, x);                                                \
+        }                                                                                      \
+      } else {                                                                                 \
+        for (size_t i = 0; i < n; i++) {                                                       \
+          *(robject*)p2 = m_##fRoundFunc(*(robject*)p1);                                       \
+          p1 += s1;                                                                            \
+          p2 += s2;                                                                            \
+        }                                                                                      \
+        return;                                                                                \
+      }                                                                                        \
+    }                                                                                          \
+  }                                                                                            \
+                                                                                               \
+  static VALUE robject_##fRoundFunc(VALUE self) {                                              \
+    ndfunc_arg_in_t ain[1] = { { numo_cRObject, 0 } };                                         \
+    ndfunc_arg_out_t aout[1] = { { numo_cRObject, 0 } };                                       \
+    ndfunc_t ndf = { iter_robject_##fRoundFunc, FULL_LOOP, 1, 1, ain, aout };                  \
+    return na_ndloop(&ndf, 1, self);                                                           \
+  }
+
+#endif /* NUMO_NARRAY_MH_ROUND_UNARY_FUNC_H */