numo-narray-alt 0.9.3

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

@@ -0,0 +1,27 @@
+typedef int16_t dtype;
+typedef int16_t rtype;
+#define cT numo_cInt16
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2INT(x))
+#if SIZEOF_INT > 2
+#define m_data_to_num(x) INT2FIX(x)
+#else
+#define m_data_to_num(x) INT2NUM(x)
+#endif
+#define m_sprintf(s, x) sprintf(s, "%d", (int)(x))
+
+#ifndef INT16_MIN
+#define INT16_MIN (-32767 - 1)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX (32767)
+#endif
+
+#define DATA_MIN INT16_MIN
+#define DATA_MAX INT16_MAX
+
+#define M_MIN m_data_to_num(INT16_MIN)
+#define M_MAX m_data_to_num(INT16_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,23 @@
+typedef int32_t dtype;
+typedef int32_t rtype;
+#define cT numo_cInt32
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2INT32(x))
+#define m_data_to_num(x) INT322NUM((int32_t)(x))
+#define m_sprintf(s, x) sprintf(s, "%" PRId32, (int32_t)(x))
+
+#ifndef INT32_MIN
+#define INT32_MIN (-2147483647 - 1)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX (2147483647)
+#endif
+
+#define DATA_MIN INT32_MIN
+#define DATA_MAX INT32_MAX
+
+#define M_MIN m_data_to_num(INT32_MIN)
+#define M_MAX m_data_to_num(INT32_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,23 @@
+typedef int64_t dtype;
+typedef int64_t rtype;
+#define cT numo_cInt64
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2INT64(x))
+#define m_data_to_num(x) INT642NUM((int64_t)(x))
+#define m_sprintf(s, x) sprintf(s, "%" PRId64, (int64_t)(x))
+
+#ifndef INT64_MIN
+#define INT64_MIN (-9223372036854775807l - 1)
+#endif
+#ifndef INT64_MAX
+#define INT64_MAX (9223372036854775807l)
+#endif
+
+#define DATA_MIN INT64_MIN
+#define DATA_MAX INT64_MAX
+
+#define M_MIN m_data_to_num(INT64_MIN)
+#define M_MAX m_data_to_num(INT64_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,23 @@
+typedef int8_t dtype;
+typedef int8_t rtype;
+#define cT numo_cInt8
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2INT(x))
+#define m_data_to_num(x) INT2FIX(x)
+#define m_sprintf(s, x) sprintf(s, "%d", (int)(x))
+
+#ifndef INT8_MIN
+#define INT8_MIN (-127 - 1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX (127)
+#endif
+
+#define DATA_MIN INT8_MIN
+#define DATA_MAX INT8_MAX
+
+#define M_MIN INT2FIX(INT8_MIN)
+#define M_MAX INT2FIX(INT8_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,66 @@
+#include "xint_macro.h"
+
+#define m_sign(x) (((x) == 0) ? 0 : (((x) > 0) ? 1 : -1))
+
+static inline dtype m_abs(dtype x) {
+  if (x == DATA_MIN) {
+    rb_raise(nary_eValueError, "cannot convert the minimum integer");
+  }
+  return (x < 0) ? -x : x;
+}
+
+static inline dtype int_reciprocal(dtype x) {
+  switch (x) {
+  case 1:
+    return 1;
+  case -1:
+    return -1;
+  case 0:
+    rb_raise(rb_eZeroDivError, "divided by 0");
+  default:
+    return 0;
+  }
+}
+
+static dtype pow_int(dtype x, int p) {
+  dtype r = m_one;
+  switch (p) {
+  case 0:
+    return 1;
+  case 1:
+    return x;
+  case 2:
+    return x * x;
+  case 3:
+    return x * x * x;
+  }
+  if (p < 0) return 0;
+  while (p) {
+    if (p & 1) r *= x;
+    x *= x;
+    p >>= 1;
+  }
+  return r;
+}
+
+static inline int64_t f_sum(size_t n, char* p, ssize_t stride) {
+  int64_t x, y = 0;
+  size_t i = n;
+  for (; i--;) {
+    x = *(dtype*)p;
+    y += x;
+    p += stride;
+  }
+  return y;
+}
+
+static inline int64_t f_prod(size_t n, char* p, ssize_t stride) {
+  int64_t x, y = 1;
+  size_t i = n;
+  for (; i--;) {
+    x = *(dtype*)p;
+    y *= x;
+    p += stride;
+  }
+  return y;
+}

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

@@ -0,0 +1,481 @@
+#define not_nan(x) ((x) == (x))
+
+#define m_mulsum(x, y, z)                                                                                                      \
+  { z = m_add(m_mul(x, y), z); }
+#define m_mulsum_nan(x, y, z)                                                                                                  \
+  {                                                                                                                            \
+    if (not_nan(x) && not_nan(y)) {                                                                                            \
+      z = m_add(m_mul(x, y), z);                                                                                               \
+    }                                                                                                                          \
+  }
+
+#define m_cumsum(x, y)                                                                                                         \
+  { (x) = m_add(x, y); }
+#define m_cumsum_nan(x, y)                                                                                                     \
+  {                                                                                                                            \
+    if (!not_nan(x)) {                                                                                                         \
+      (x) = (y);                                                                                                               \
+    } else if (not_nan(y)) {                                                                                                   \
+      (x) = m_add(x, y);                                                                                                       \
+    }                                                                                                                          \
+  }
+
+#define m_cumprod(x, y)                                                                                                        \
+  { (x) = m_mul(x, y); }
+#define m_cumprod_nan(x, y)                                                                                                    \
+  {                                                                                                                            \
+    if (!not_nan(x)) {                                                                                                         \
+      (x) = (y);                                                                                                               \
+    } else if (not_nan(y)) {                                                                                                   \
+      (x) = m_mul(x, y);                                                                                                       \
+    }                                                                                                                          \
+  }
+
+static inline dtype f_sum(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  dtype x, y = m_zero;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    y = m_add(x, y);
+    p += stride;
+  }
+  return y;
+}
+
+static inline dtype f_sum_nan(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  dtype x, y = m_zero;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (not_nan(x)) {
+      y = m_add(x, y);
+    }
+  }
+  return y;
+}
+
+static inline dtype f_prod(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  dtype x, y = m_one;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    y = m_mul(x, y);
+  }
+  return y;
+}
+
+static inline dtype f_prod_nan(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  dtype x, y = m_one;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (not_nan(x)) {
+      y = m_mul(x, y);
+    }
+  }
+  return y;
+}
+
+static inline dtype f_mean(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  size_t count = 0;
+  dtype x, y = m_zero;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    y = m_add(x, y);
+    count++;
+  }
+  return m_div(y, m_from_real(count));
+}
+
+static inline dtype f_mean_nan(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  size_t count = 0;
+  dtype x, y = m_zero;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (not_nan(x)) {
+      y = m_add(x, y);
+      count++;
+    }
+  }
+  return m_div(y, m_from_real(count));
+}
+
+static inline dtype f_var(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  size_t count = 0;
+  dtype x, y = m_zero;
+  dtype a, m;
+
+  m = f_mean(n, p, stride);
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    a = m_abs(m_sub(x, m));
+    y = m_add(y, m_square(a));
+    count++;
+  }
+  return m_div(y, m_from_real(count - 1));
+}
+
+static inline dtype f_var_nan(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  size_t count = 0;
+  dtype x, y = m_zero;
+  dtype a, m;
+
+  m = f_mean_nan(n, p, stride);
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (not_nan(x)) {
+      a = m_abs(m_sub(x, m));
+      y = m_add(y, m_square(a));
+      count++;
+    }
+  }
+  return m_div(y, m_from_real(count - 1));
+}
+
+static inline dtype f_stddev(size_t n, char* p, ssize_t stride) {
+  return m_sqrt(f_var(n, p, stride));
+}
+
+static inline dtype f_stddev_nan(size_t n, char* p, ssize_t stride) {
+  return m_sqrt(f_var_nan(n, p, stride));
+}
+
+static inline dtype f_rms(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  size_t count = 0;
+  dtype x, y = m_zero;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    y = m_add(y, m_square(m_abs(x)));
+    count++;
+  }
+  return m_sqrt(m_div(y, m_from_real(count)));
+}
+
+static inline dtype f_rms_nan(size_t n, char* p, ssize_t stride) {
+  size_t i = n;
+  size_t count = 0;
+  dtype x, y = m_zero;
+
+  for (; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (not_nan(x)) {
+      y = m_add(y, m_square(m_abs(x)));
+      count++;
+    }
+  }
+  return m_sqrt(m_div(y, m_from_real(count)));
+}
+
+// ---------------------------------------------------------
+
+static inline dtype f_min_nan(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i = n;
+
+  y = *(dtype*)p;
+  p += stride;
+  if (!not_nan(y)) {
+    return y;
+  }
+  for (i--; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (!not_nan(x)) {
+      return x;
+    }
+    if (m_lt(x, y)) {
+      y = x;
+    }
+  }
+  return y;
+}
+
+static inline dtype f_min(size_t n, char* p, ssize_t stride) {
+  dtype x, y = m_zero;
+  size_t i = n;
+
+  for (; i--;) {
+    y = *(dtype*)p;
+    p += stride;
+    if (not_nan(y)) {
+      for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_lt(x, y)) {
+          y = x;
+        }
+      }
+      break;
+    }
+  }
+  return y;
+}
+
+static inline dtype f_max_nan(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i = n;
+
+  y = *(dtype*)p;
+  p += stride;
+  if (!not_nan(y)) {
+    return y;
+  }
+  for (i--; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (!not_nan(x)) {
+      return x;
+    }
+    if (m_gt(x, y)) {
+      y = x;
+    }
+  }
+  return y;
+}
+
+static inline dtype f_max(size_t n, char* p, ssize_t stride) {
+  dtype x, y = m_zero;
+  size_t i = n;
+
+  for (; i--;) {
+    y = *(dtype*)p;
+    p += stride;
+    if (not_nan(y)) {
+      for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_gt(x, y)) {
+          y = x;
+        }
+      }
+      break;
+    }
+  }
+  return y;
+}
+
+static inline size_t f_min_index_nan(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i, j = 0;
+
+  y = *(dtype*)p;
+  p += stride;
+  if (!not_nan(y)) {
+    return j;
+  }
+  for (i = 1; i < n; i++) {
+    x = *(dtype*)p;
+    p += stride;
+    if (!not_nan(x)) {
+      return i;
+    }
+    if (m_lt(x, y)) {
+      y = x;
+      j = i;
+    }
+  }
+  return j;
+}
+
+static inline size_t f_min_index(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i, j = 0;
+
+  for (i = 0; i < n; i++) {
+    y = *(dtype*)p;
+    p += stride;
+    if (not_nan(y)) {
+      j = i;
+      i++;
+      for (; i < n; i++) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_lt(x, y)) {
+          y = x;
+          j = i;
+        }
+      }
+      break;
+    }
+  }
+  return j;
+}
+
+static inline size_t f_max_index_nan(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i, j = 0;
+
+  y = *(dtype*)p;
+  p += stride;
+  if (!not_nan(y)) {
+    return j;
+  }
+  for (i = 1; i < n; i++) {
+    x = *(dtype*)p;
+    p += stride;
+    if (!not_nan(x)) {
+      return i;
+    }
+    if (m_gt(x, y)) {
+      y = x;
+      j = i;
+    }
+  }
+  return j;
+}
+
+static inline size_t f_max_index(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i, j = 0;
+
+  for (i = 0; i < n; i++) {
+    y = *(dtype*)p;
+    p += stride;
+    if (not_nan(y)) {
+      j = i;
+      i++;
+      for (; i < n; i++) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_gt(x, y)) {
+          y = x;
+          j = i;
+        }
+      }
+      break;
+    }
+  }
+  return j;
+}
+
+static inline void f_minmax_nan(size_t n, char* p, ssize_t stride, dtype* amin, dtype* amax) {
+  dtype x, min, max;
+  size_t i = n;
+
+  min = max = *(dtype*)p;
+  p += stride;
+  if (!not_nan(min)) {
+    *amin = *amax = min;
+    return;
+  }
+  for (i--; i--;) {
+    x = *(dtype*)p;
+    p += stride;
+    if (!not_nan(x)) {
+      *amin = *amax = x;
+      return;
+    }
+    if (m_lt(x, min)) {
+      min = x;
+    }
+    if (m_gt(x, max)) {
+      max = x;
+    }
+  }
+  *amin = min;
+  *amax = max;
+  return;
+}
+
+static inline dtype f_ptp_nan(size_t n, char* p, ssize_t stride) {
+  dtype min, max;
+  f_minmax_nan(n, p, stride, &min, &max);
+  return m_sub(max, min);
+}
+
+static inline void f_minmax(size_t n, char* p, ssize_t stride, dtype* amin, dtype* amax) {
+  dtype x, min, max;
+  size_t i = n;
+
+  min = max = m_zero;
+  for (; i--;) {
+    min = *(dtype*)p;
+    p += stride;
+    if (not_nan(min)) {
+      max = min;
+      for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_lt(x, min)) {
+          min = x;
+        }
+        if (m_gt(x, max)) {
+          max = x;
+        }
+      }
+      break;
+    }
+  }
+  *amin = min;
+  *amax = max;
+  return;
+}
+
+static inline dtype f_ptp(size_t n, char* p, ssize_t stride) {
+  dtype min, max;
+  f_minmax(n, p, stride, &min, &max);
+  return m_sub(max, min);
+}
+
+static inline dtype f_maximum(dtype x, dtype y) {
+  if (m_ge(x, y)) {
+    return x;
+  }
+  if (not_nan(y)) {
+    return y;
+  }
+  return x;
+}
+
+static inline dtype f_maximum_nan(dtype x, dtype y) {
+  if (m_ge(x, y)) {
+    return x;
+  }
+  if (!not_nan(x)) {
+    return x;
+  }
+  return y;
+}
+
+static inline dtype f_minimum(dtype x, dtype y) {
+  if (m_le(x, y)) {
+    return x;
+  }
+  if (not_nan(y)) {
+    return y;
+  }
+  return x;
+}
+
+static inline dtype f_minimum_nan(dtype x, dtype y) {
+  if (m_le(x, y)) {
+    return x;
+  }
+  if (!not_nan(x)) {
+    return x;
+  }
+  return y;
+}

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

@@ -0,0 +1,78 @@
+#define m_zero INT2FIX(0)
+#define m_one INT2FIX(1)
+
+#define m_num_to_data(x) (x)
+#define m_data_to_num(x) (x)
+
+#define m_from_double(x) rb_float_new(x)
+#define m_from_real(x) rb_float_new(x)
+#define m_from_sint(x) INT2FIX(x)
+#define m_from_int32(x) INT322NUM(x)
+#define m_from_int64(x) INT642NUM(x)
+#define m_from_uint32(x) UINT322NUM(x)
+#define m_from_uint64(x) UINT642NUM(x)
+
+#define m_add(x, y) rb_funcall(x, '+', 1, y)
+#define m_sub(x, y) rb_funcall(x, '-', 1, y)
+#define m_mul(x, y) rb_funcall(x, '*', 1, y)
+#define m_div(x, y) rb_funcall(x, '/', 1, y)
+#define m_mod(x, y) rb_funcall(x, '%', 1, y)
+#define m_divmod(x, y, a, b)                                                                                                   \
+  {                                                                                                                            \
+    x = rb_funcall(x, id_divmod, 1, y);                                                                                        \
+    a = RARRAY_PTR(x)[0];                                                                                                      \
+    b = RARRAY_PTR(x)[0];                                                                                                      \
+  }
+#define m_pow(x, y) rb_funcall(x, id_pow, 1, y)
+#define m_pow_int(x, y) rb_funcall(x, id_pow, 1, y)
+
+#define m_abs(x) rb_funcall(x, id_abs, 0)
+#define m_minus(x) rb_funcall(x, id_minus, 0)
+#define m_reciprocal(x) rb_funcall(x, id_reciprocal, 0)
+#define m_square(x) rb_funcall(x, '*', 1, x)
+#define m_floor(x) rb_funcall(x, id_floor, 0)
+#define m_round(x) rb_funcall(x, id_round, 0)
+#define m_ceil(x) rb_funcall(x, id_ceil, 0)
+#define m_trunc(x) rb_funcall(x, id_truncate, 0)
+#define m_sign(x) rb_funcall(x, id_ufo, 1, INT2FIX(0))
+
+#define m_eq(x, y) RTEST(rb_funcall(x, id_eq, 1, y))
+#define m_ne(x, y) RTEST(rb_funcall(x, id_ne, 1, y))
+#define m_gt(x, y) RTEST(rb_funcall(x, id_gt, 1, y))
+#define m_ge(x, y) RTEST(rb_funcall(x, id_ge, 1, y))
+#define m_lt(x, y) RTEST(rb_funcall(x, id_lt, 1, y))
+#define m_le(x, y) RTEST(rb_funcall(x, id_le, 1, y))
+
+#define m_bit_and(x, y) rb_funcall(x, id_bit_and, 1, y)
+#define m_bit_or(x, y) rb_funcall(x, id_bit_or, 1, y)
+#define m_bit_xor(x, y) rb_funcall(x, id_bit_xor, 1, y)
+#define m_bit_not(x) rb_funcall(x, id_bit_not, 0)
+
+#define m_left_shift(x, y) rb_funcall(x, id_left_shift, 1, y)
+#define m_right_shift(x, y) rb_funcall(x, id_right_shift, 1, y)
+
+#define m_isnan(x) ((rb_respond_to(x, id_nan_p)) ? RTEST(rb_funcall(x, id_nan_p, 0)) : 0)
+#define m_isinf(x) ((rb_respond_to(x, id_infinite_p)) ? RTEST(rb_funcall(x, id_infinite_p, 0)) : 0)
+#define m_isposinf(x)                                                                                                          \
+  ((rb_respond_to(x, id_infinite_p)) ? ((RTEST(rb_funcall(x, id_infinite_p, 0))) ? m_gt(x, INT2FIX(0)) : 0) : 0)
+#define m_isneginf(x)                                                                                                          \
+  ((rb_respond_to(x, id_infinite_p)) ? ((RTEST(rb_funcall(x, id_infinite_p, 0))) ? m_lt(x, INT2FIX(0)) : 0) : 0)
+#define m_isfinite(x) ((rb_respond_to(x, id_finite_p)) ? RTEST(rb_funcall(x, id_finite_p, 0)) : 0)
+
+#define m_mulsum_init INT2FIX(0)
+
+#define m_sprintf(s, x) robj_sprintf(s, x)
+
+static inline int robj_sprintf(char* s, VALUE x) {
+  VALUE v = rb_funcall(x, rb_intern("to_s"), 0);
+  return sprintf(s, "%s", StringValuePtr(v));
+}
+
+#define m_sqrt(x) rb_funcall(rb_const_get(rb_mKernel, rb_intern("Math")), rb_intern("sqrt"), 1, x);
+
+static inline dtype f_seq(dtype x, dtype y, size_t c) {
+  y = m_mul(y, SIZET2NUM(c));
+  return m_add(x, y);
+}
+
+#include "real_accum.h"