numo-narray-alt 0.9.3

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

@@ -0,0 +1,25 @@
+typedef VALUE dtype;
+typedef VALUE rtype;
+#define cT numo_cRObject
+#define cRT cT
+// #define mTM mRObjectMath
+
+#include "float_def.h"
+#include "robj_macro.h"
+
+#define m_min_init (0.0 / 0.0)
+#define m_max_init (0.0 / 0.0)
+#define m_extract(x) (*(VALUE*)x)
+#define m_nearly_eq(x, y) robj_nearly_eq(x, y)
+
+inline static int robj_nearly_eq(VALUE vx, VALUE vy) {
+  double x, y;
+  x = NUM2DBL(vx);
+  y = NUM2DBL(vy);
+  return (fabs(x - y) <= (fabs(x) + fabs(y)) * DBL_EPSILON * 2);
+}
+
+/* generates a random number on [0,1)-real-interval */
+inline static dtype m_rand(dtype max) {
+  return DBL2NUM(genrand_res53_mix() * max);
+}

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

@@ -0,0 +1,42 @@
+typedef scomplex dtype;
+typedef float rtype;
+#define cT numo_cSComplex
+#define cRT numo_cSFloat
+#define mTM numo_mSComplexMath
+
+#include "complex_macro.h"
+
+static inline bool c_nearly_eq(dtype x, dtype y) {
+  return c_abs(c_sub(x, y)) <= (c_abs(x) + c_abs(y)) * FLT_EPSILON * 2;
+}
+
+#ifdef SFMT_H
+/* generates a random number on [0,1)-real-interval */
+inline static dtype m_rand(dtype max) {
+  dtype z;
+  REAL(z) = to_real2(gen_rand32()) * REAL(max);
+  IMAG(z) = to_real2(gen_rand32()) * IMAG(max);
+  return z;
+}
+
+/* generates random numbers from the normal distribution
+   using Box-Muller Transformation.
+ */
+inline static void m_rand_norm(dtype mu, rtype sigma, dtype* a0) {
+  rtype x1, x2, w;
+  do {
+    x1 = to_real2(gen_rand32());
+    x1 = x1 * 2 - 1;
+    x2 = to_real2(gen_rand32());
+    x2 = x2 * 2 - 1;
+    w = x1 * x1 + x2 * x2;
+  } while (w >= 1);
+  w = sqrt((-2 * log(w)) / w);
+  REAL(*a0) = x1 * w * sigma + REAL(mu);
+  IMAG(*a0) = x2 * w * sigma + IMAG(mu);
+}
+#endif
+
+#define M_EPSILON rb_float_new(1.1920928955078125e-07)
+#define M_MIN rb_float_new(1.1754943508222875e-38)
+#define M_MAX rb_float_new(3.4028234663852886e+38)

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

@@ -0,0 +1,45 @@
+typedef float dtype;
+typedef float rtype;
+#define cT numo_cSFloat
+#define cRT numo_cSFloat
+#define mTM numo_mSFloatMath
+
+#include "float_macro.h"
+
+#ifdef SFMT_H
+/* generates a random number on [0,1)-real-interval */
+inline static dtype m_rand(dtype max) {
+  return to_real2(gen_rand32()) * max;
+}
+
+/* generates random numbers from the normal distribution
+   using Box-Muller Transformation.
+ */
+inline static void m_rand_norm(dtype mu, dtype sigma, dtype* a0, dtype* a1) {
+  dtype x1, x2, w;
+  do {
+    x1 = to_real2(gen_rand32());
+    x1 = x1 * 2 - 1;
+    x2 = to_real2(gen_rand32());
+    x2 = x2 * 2 - 1;
+    w = x1 * x1 + x2 * x2;
+  } while (w >= 1);
+  w = sqrt((-2 * log(w)) / w);
+  if (a0) {
+    *a0 = x1 * w * sigma + mu;
+  }
+  if (a1) {
+    *a1 = x2 * w * sigma + mu;
+  }
+}
+#endif
+
+#define m_min_init numo_sfloat_new_dim0(0.0 / 0.0)
+#define m_max_init numo_sfloat_new_dim0(0.0 / 0.0)
+
+#define m_extract(x) rb_float_new(*(float*)x)
+#define m_nearly_eq(x, y) (fabs(x - y) <= (fabs(x) + fabs(y)) * FLT_EPSILON * 2)
+
+#define M_EPSILON rb_float_new(1.1920928955078125e-07)
+#define M_MIN rb_float_new(1.1754943508222875e-38)
+#define M_MAX rb_float_new(3.4028234663852886e+38)

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

@@ -0,0 +1,24 @@
+typedef u_int16_t dtype;
+typedef u_int16_t rtype;
+#define cT numo_cUInt16
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2UINT(x))
+#if SIZEOF_INT > 2
+#define m_data_to_num(x) INT2FIX(x)
+#else
+#define m_data_to_num(x) UINT2NUM(x)
+#endif
+#define m_sprintf(s, x) sprintf(s, "%u", (unsigned int)(x))
+
+#ifndef UINT16_MAX
+#define UINT16_MAX (65535)
+#endif
+
+#define DATA_MIN UINT16_MIN
+#define DATA_MAX UINT16_MAX
+
+#define M_MIN INT2FIX(0)
+#define M_MAX m_data_to_num(UINT16_MAX)
+
+#include "uint_macro.h"

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

@@ -0,0 +1,20 @@
+typedef u_int32_t dtype;
+typedef u_int32_t rtype;
+#define cT numo_cUInt32
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2UINT32(x))
+#define m_data_to_num(x) UINT322NUM((u_int32_t)(x))
+#define m_sprintf(s, x) sprintf(s, "%" PRIu32, (u_int32_t)(x))
+
+#ifndef UINT32_MAX
+#define UINT32_MAX (4294967295u)
+#endif
+
+#define DATA_MIN UINT32_MIN
+#define DATA_MAX UINT32_MAX
+
+#define M_MIN INT2FIX(0)
+#define M_MAX m_data_to_num(UINT32_MAX)
+
+#include "uint_macro.h"

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

@@ -0,0 +1,20 @@
+typedef u_int64_t dtype;
+typedef u_int64_t rtype;
+#define cT numo_cUInt64
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2UINT64(x))
+#define m_data_to_num(x) UINT642NUM((u_int64_t)(x))
+#define m_sprintf(s, x) sprintf(s, "%" PRIu64, (u_int64_t)(x))
+
+#ifndef UINT64_MAX
+#define UINT64_MAX (18446744073709551615ul)
+#endif
+
+#define DATA_MIN UINT64_MIN
+#define DATA_MAX UINT64_MAX
+
+#define M_MIN INT2FIX(0)
+#define M_MAX m_data_to_num(UINT64_MAX)
+
+#include "uint_macro.h"

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

@@ -0,0 +1,20 @@
+typedef u_int8_t dtype;
+typedef u_int8_t rtype;
+#define cT numo_cUInt8
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2UINT(x))
+#define m_data_to_num(x) INT2FIX(x)
+#define m_sprintf(s, x) sprintf(s, "%u", (unsigned int)(x))
+
+#ifndef UINT8_MAX
+#define UINT8_MAX (255)
+#endif
+
+#define DATA_MIN UINT8_MIN
+#define DATA_MAX UINT8_MAX
+
+#define M_MIN INT2FIX(0)
+#define M_MAX m_data_to_num(UINT8_MAX)
+
+#include "uint_macro.h"

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

@@ -0,0 +1,57 @@
+#include "xint_macro.h"
+
+#define m_abs(x) (x)
+#define m_sign(x) (((x) == 0) ? 0 : 1)
+
+static inline dtype int_reciprocal(dtype x) {
+  switch (x) {
+  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;
+  }
+  while (p) {
+    if (p & 1) r *= x;
+    x *= x;
+    p >>= 1;
+  }
+  return r;
+}
+
+static inline u_int64_t f_sum(size_t n, char* p, ssize_t stride) {
+  u_int64_t x, y = 0;
+  size_t i = n;
+  for (; i--;) {
+    x = *(dtype*)p;
+    y += x;
+    p += stride;
+  }
+  return y;
+}
+
+static inline u_int64_t f_prod(size_t n, char* p, ssize_t stride) {
+  u_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/xint_macro.h

@@ -0,0 +1,166 @@
+#define m_zero 0
+#define m_one 1
+
+#define m_extract(x) m_data_to_num(*(dtype*)(x))
+
+/* Handle negative values consistently across platforms for unsigned integer types */
+#define m_from_double(x) ((x) < 0 ? (dtype)((long long)(x)) : (dtype)(x))
+#define m_from_real(x) ((x) < 0 ? (dtype)((long long)(x)) : (dtype)(x))
+#define m_from_sint(x) (x)
+#define m_from_int32(x) (x)
+#define m_from_int64(x) (x)
+#define m_from_uint32(x) (x)
+#define m_from_uint64(x) (x)
+
+#define m_add(x, y) ((x) + (y))
+#define m_sub(x, y) ((x) - (y))
+#define m_mul(x, y) ((x) * (y))
+#define m_div(x, y) ((x) / (y))
+#define m_mod(x, y) ((x) % (y))
+#define m_divmod(x, y, a, b)                                                                                                   \
+  {                                                                                                                            \
+    a = (x) / (y);                                                                                                             \
+    b = m_mod(x, y);                                                                                                           \
+  }
+#define m_pow(x, y) pow_int(x, y)
+#define m_pow_int(x, y) pow_int(x, y)
+
+#define m_bit_and(x, y) ((x) & (y))
+#define m_bit_or(x, y) ((x) | (y))
+#define m_bit_xor(x, y) ((x) ^ (y))
+#define m_bit_not(x) (~(x))
+
+#define m_minus(x) (-(x))
+#define m_reciprocal(x) int_reciprocal(x)
+#define m_square(x) ((x) * (x))
+
+#define m_eq(x, y) ((x) == (y))
+#define m_ne(x, y) ((x) != (y))
+#define m_gt(x, y) ((x) > (y))
+#define m_ge(x, y) ((x) >= (y))
+#define m_lt(x, y) ((x) < (y))
+#define m_le(x, y) ((x) <= (y))
+#define m_left_shift(x, y) ((x) << (y))
+#define m_right_shift(x, y) ((x) >> (y))
+
+#define m_isnan(x) 0
+
+#define m_mulsum(x, y, z)                                                                                                      \
+  { z += x * y; }
+#define m_mulsum_init INT2FIX(0)
+#define m_cumsum(x, y)                                                                                                         \
+  { x += y; }
+#define m_cumprod(x, y)                                                                                                        \
+  { x *= y; }
+
+#define cmp(a, b) ((qsort_cast(a) == qsort_cast(b)) ? 0 : (qsort_cast(a) > qsort_cast(b)) ? 1 : -1)
+#define cmpgt(a, b) (qsort_cast(a) > qsort_cast(b))
+
+static inline dtype f_min(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i = n;
+
+  y = *(dtype*)p;
+  p += stride;
+  i--;
+  for (; i--;) {
+    x = *(dtype*)p;
+    if (x < y) {
+      y = x;
+    }
+    p += stride;
+  }
+  return y;
+}
+
+static inline dtype f_max(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i = n;
+
+  y = *(dtype*)p;
+  p += stride;
+  i--;
+  for (; i--;) {
+    x = *(dtype*)p;
+    if (x > y) {
+      y = x;
+    }
+    p += stride;
+  }
+  return y;
+}
+
+static inline size_t f_min_index(size_t n, char* p, ssize_t stride) {
+  dtype x, y;
+  size_t i, j = 0;
+
+  y = *(dtype*)p;
+  for (i = 1; i < n; i++) {
+    x = *(dtype*)(p + i * stride);
+    if (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;
+
+  y = *(dtype*)p;
+  for (i = 1; i < n; i++) {
+    x = *(dtype*)(p + i * stride);
+    if (x > y) {
+      y = x;
+      j = i;
+    }
+  }
+  return j;
+}
+
+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 = *(dtype*)p;
+  p += stride;
+  for (i--; i--;) {
+    x = *(dtype*)p;
+    if (m_gt(x, max)) {
+      max = x;
+    }
+    if (m_lt(x, min)) {
+      min = x;
+    }
+    p += stride;
+  }
+  *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 double f_seq(double x, double y, double c) {
+  return x + y * c;
+}
+
+static inline dtype f_maximum(dtype x, dtype y) {
+  if (m_ge(x, y)) {
+    return x;
+  }
+  return y;
+}
+
+static inline dtype f_minimum(dtype x, dtype y) {
+  if (m_le(x, y)) {
+    return x;
+  }
+  return y;
+}

data/ext/numo/narray/rand.c

@@ -0,0 +1,40 @@
+#include <ruby.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <time.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+#include "SFMT.h"
+#include "numo/narray.h"
+
+static u_int64_t random_seed(void) {
+  static int n = 0;
+  struct timeval tv;
+
+  gettimeofday(&tv, 0);
+  return tv.tv_sec ^ tv.tv_usec ^ getpid() ^ n++;
+}
+
+static VALUE nary_s_srand(int argc, VALUE* argv, VALUE obj) {
+  VALUE vseed;
+  u_int64_t seed;
+
+  // rb_secure(4);
+  if (rb_scan_args(argc, argv, "01", &vseed) == 0) {
+    seed = random_seed();
+  } else {
+    seed = NUM2UINT64(vseed);
+  }
+  init_gen_rand((uint32_t)seed);
+
+  return Qnil;
+}
+
+void Init_nary_rand(void) {
+  rb_define_singleton_method(cNArray, "srand", nary_s_srand, -1);
+  init_gen_rand(0);
+}