numo-narray 0.9.0.1-x86-mingw32

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

@@ -0,0 +1,205 @@
+#include "float_def.h"
+
+EXTERN double round(double);
+EXTERN double log2(double);
+EXTERN double exp2(double);
+EXTERN double exp10(double);
+
+#define r_abs(x)   abs(x)
+#define r_sqrt(x)  sqrt(x)
+#define r_exp(x)   exp(x)
+#define r_log(x)   log(x)
+#define r_sin(x)   sin(x)
+#define r_cos(x)   cos(x)
+#define r_sinh(x)  sinh(x)
+#define r_cosh(x)  cosh(x)
+#define r_tanh(x)  tanh(x)
+#define r_atan2(y,x)  atan2(y,x)
+#define r_hypot(x,y)  hypot(x,y)
+
+#include "complex.h"
+
+static inline dtype c_from_scomplex(scomplex x) {
+    dtype z;
+    REAL(z) = REAL(x);
+    IMAG(z) = IMAG(x);
+    return z;
+}
+
+static inline dtype c_from_dcomplex(dcomplex x) {
+    dtype z;
+    REAL(z) = REAL(x);
+    IMAG(z) = IMAG(x);
+    return z;
+}
+
+/* --------------------------- */
+
+#define m_zero c_zero()
+#define m_one  c_one()
+
+#define m_num_to_data(x) NUM2COMP(x)
+#define m_data_to_num(x) COMP2NUM(x)
+
+#define m_from_double(x) c_new(x,0)
+#define m_from_real(x)   c_new(x,0)
+#define m_from_scomplex(x) c_from_scomplex(x)
+#define m_from_dcomplex(x) c_from_dcomplex(x)
+
+#define m_extract(x) COMP2NUM(*(dtype*)x)
+
+#define m_real(x)  REAL(x)
+#define m_imag(x)  IMAG(x)
+#define m_set_real(x,y)  c_set_real(x,y)
+#define m_set_imag(x,y)  c_set_imag(x,y)
+
+#define m_add(x,y) c_add(x,y)
+#define m_sub(x,y) c_sub(x,y)
+#define m_mul(x,y) c_mul(x,y)
+#define m_div(x,y) c_div(x,y)
+#define m_mod(x,y) c_mod(x,y)
+#define m_pow(x,y) c_pow(x,y)
+#define m_pow_int(x,y) c_pow_int(x,y)
+
+#define m_minus(x)   c_minus(x)
+#define m_inverse(x) c_inverse(x)
+#define m_square(x)  c_square(x)
+#define m_im(x)      c_im(x)
+
+#define m_conj(x)  c_new(REAL(x),-IMAG(x))
+#define m_abs(x)   c_abs(x)
+#define m_arg(x)   atan2(IMAG(x),REAL(x))
+
+#define m_eq(x,y) c_eq(x,y)
+#define m_ne(x,y) c_ne(x,y)
+#define m_nearly_eq(x,y) c_nearly_eq(x,y)
+
+#define m_isnan(x)    c_isnan(x)
+#define m_isinf(x)    c_isinf(x)
+#define m_isfinite(x) c_isfinite(x)
+
+#define m_sum(x,y) {if (!c_isnan(x)) {y=c_add(x,y);}}
+#define m_sum_init INT2FIX(0)
+
+#define m_mulsum(x,y,z) {z = c_add(c_mul(x,y),z);}
+#define m_mulsum_init INT2FIX(0)
+
+#define m_rand c_new(to_res53(gen_rand64()),to_res53(gen_rand64()))
+#define m_rand_norm(a) rand_norm(a)
+
+#define m_sprintf(s,x) sprintf(s,"%g%+gi",REAL(x),IMAG(x))
+
+#define m_sqrt(x)    c_sqrt(x)
+#define m_cbrt(x)    c_cbrt(x)
+#define m_log(x)     c_log(x)
+#define m_log2(x)    c_log2(x)
+#define m_log10(x)   c_log10(x)
+#define m_exp(x)     c_exp(x)
+#define m_exp2(x)    c_exp2(x)
+#define m_exp10(x)   c_exp10(x)
+#define m_sin(x)     c_sin(x)
+#define m_cos(x)     c_cos(x)
+#define m_tan(x)     c_tan(x)
+#define m_asin(x)    c_asin(x)
+#define m_acos(x)    c_acos(x)
+#define m_atan(x)    c_atan(x)
+#define m_sinh(x)    c_sinh(x)
+#define m_cosh(x)    c_cosh(x)
+#define m_tanh(x)    c_tanh(x)
+#define m_asinh(x)   c_asinh(x)
+#define m_acosh(x)   c_acosh(x)
+#define m_atanh(x)   c_atanh(x)
+#define m_hypot(x,y) c_hypot(x,y)
+
+static inline dtype f_sum(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y;
+
+    y = c_zero();
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!c_isnan(x)) {
+            y = c_add(x,y);
+        }
+        p += stride;
+    }
+    return y;
+}
+
+static inline dtype f_prod(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y;
+
+    y = c_one();
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!c_isnan(x)) {
+            y = c_mul(x,y);
+        }
+        p += stride;
+    }
+    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;
+
+    y = c_zero();
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!c_isnan(x)) {
+            y = c_add(x,y);
+            count++;
+        }
+        p += stride;
+    }
+    return c_div_r(y,count);
+}
+
+static inline rtype f_var(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x,m;
+    rtype y=0;
+
+    m = f_mean(n,p,stride);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!c_isnan(x)) {
+            y += c_abs_square(c_sub(x,m));
+            count++;
+        }
+        p += stride;
+    }
+    return y/(count-1);
+}
+
+static inline rtype f_stddev(size_t n, char *p, ssize_t stride)
+{
+    return r_sqrt(f_var(n,p,stride));
+}
+
+static inline rtype f_rms(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x;
+    rtype y=0;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!c_isnan(x)) {
+            y += c_abs_square(x);
+            count++;
+        }
+        p += stride;
+    }
+    return r_sqrt(y/count);
+}

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

@@ -0,0 +1,11 @@
+typedef dcomplex dtype;
+typedef double rtype;
+#define cT  numo_cDComplex
+#define cRT numo_cDFloat
+#define mTM numo_mDComplexMath
+
+#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))*DBL_EPSILON*2;
+}

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

@@ -0,0 +1,12 @@
+typedef double dtype;
+typedef double rtype;
+#define cT  numo_cDFloat
+#define cRT numo_cDFloat
+#define mTM numo_mDFloatMath
+
+#include "float_macro.h"
+
+#define m_min_init numo_dfloat_new_dim0(0.0/0.0)
+#define m_max_init numo_dfloat_new_dim0(0.0/0.0)
+#define m_extract(x) rb_float_new(*(double*)x)
+#define m_nearly_eq(x,y) (fabs(x-y)<=(fabs(x)+fabs(y))*DBL_EPSILON*2)

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

@@ -0,0 +1,34 @@
+#ifndef DBL_EPSILON
+#define DBL_EPSILON 2.2204460492503131e-16
+#endif
+#ifndef FLT_EPSILON
+#define FLT_EPSILON 1.1920928955078125e-07
+#endif
+#ifndef DBL_MAX
+#define DBL_MAX 1.7976931348623157e+308
+#endif
+#ifndef DBL_MAX
+#define DBL_MAX 1.7976931348623157e+308
+#endif
+#ifndef FLT_MIN
+#define FLT_MIN 1.1754943508222875e-38
+#endif
+#ifndef FLT_MAX
+#define FLT_MAX 3.4028234663852886e+38
+#endif
+
+#ifndef M_PI_2
+#define M_PI_2         1.57079632679489661923  /* pi/2 */
+#endif
+#ifndef M_LOG2E
+#define M_LOG2E        1.4426950408889634074   /* log_2 e */
+#endif
+#ifndef M_LOG10E
+#define M_LOG10E       0.43429448190325182765  /* log_10 e */
+#endif
+#ifndef M_LN2
+#define M_LN2          0.69314718055994530942  /* log_e 2 */
+#endif
+#ifndef M_LN10
+#define M_LN10         2.30258509299404568402  /* log_e 10 */
+#endif

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

@@ -0,0 +1,277 @@
+#include "float_def.h"
+
+EXTERN double round(double);
+EXTERN double log2(double);
+EXTERN double exp2(double);
+#ifdef HAVE_EXP10
+EXTERN double exp10(double);
+#else
+EXTERN double pow(double, double);
+#endif
+
+#define m_zero 0.0
+#define m_one  1.0
+
+#define m_num_to_data(x) NUM2DBL(x)
+#define m_data_to_num(x) rb_float_new(x)
+
+#define m_from_double(x) (x)
+#define m_from_real(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_div_check(x,y) ((y)==0)
+#define m_mod(x,y) fmod(x,y)
+#define m_divmod(x,y,a,b) {a=(x)/(y); b=m_mod(x,y);}
+#define m_pow(x,y) pow(x,y)
+#define m_pow_int(x,y) pow_int(x,y)
+
+#define m_abs(x)     fabs(x)
+#define m_minus(x)   (-(x))
+#define m_inverse(x) (1/(x))
+#define m_square(x)  ((x)*(x))
+#define m_floor(x)   floor(x)
+#define m_round(x)   round(x)
+#define m_ceil(x)    ceil(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_isnan(x) isnan(x)
+#define m_isinf(x) isinf(x)
+#define m_isfinite(x) isfinite(x)
+
+#define m_mulsum(x,y,z) {z += x*y;}
+#define m_mulsum_init INT2FIX(0)
+
+#define m_rand to_res53(gen_rand64())
+#define m_rand_norm(a) rand_norm(a)
+
+#define m_sprintf(s,x) sprintf(s,"%g",x)
+
+#define cmp(a,b)                                                        \
+    (m_isnan(qsort_cast(a)) ? (m_isnan(qsort_cast(b)) ? 0 : 1) :            \
+     (m_isnan(qsort_cast(b)) ? -1 :                                       \
+      ((qsort_cast(a)==qsort_cast(b)) ? 0 :                             \
+       (qsort_cast(a) > qsort_cast(b)) ? 1 : -1)))
+
+#define cmpgt(a,b)                                            \
+    ((m_isnan(qsort_cast(a)) && !m_isnan(qsort_cast(b))) ||       \
+     (qsort_cast(a) > qsort_cast(b)))
+
+#define m_sqrt(x)    sqrt(x)
+#define m_cbrt(x)    cbrt(x)
+#define m_log(x)     log(x)
+#define m_log2(x)    log2(x)
+#define m_log10(x)   log10(x)
+#define m_exp(x)     exp(x)
+#define m_exp2(x)    exp2(x)
+#ifdef HAVE_EXP10
+#define m_exp10(x)   exp10(x)
+#else
+#define m_exp10(x)   pow(10, x)
+#endif
+#define m_sin(x)     sin(x)
+#define m_cos(x)     cos(x)
+#define m_tan(x)     tan(x)
+#define m_asin(x)    asin(x)
+#define m_acos(x)    acos(x)
+#define m_atan(x)    atan(x)
+#define m_sinh(x)    sinh(x)
+#define m_cosh(x)    cosh(x)
+#define m_tanh(x)    tanh(x)
+#define m_asinh(x)   asinh(x)
+#define m_acosh(x)   acosh(x)
+#define m_atanh(x)   atanh(x)
+#define m_atan2(x,y) atan2(x,y)
+#define m_hypot(x,y) hypot(x,y)
+
+#define m_erf(x)     erf(x)
+#define m_erfc(x)    erfc(x)
+#define m_ldexp(x,y) ldexp(x,y)
+#define m_frexp(x,exp) frexp(x,exp)
+
+static inline dtype pow_int(dtype x, int p)
+{
+    dtype r=1;
+    switch(p) {
+    case 0: return 1;
+    case 1: return x;
+    case 2: return x*x;
+    case 3: return x*x*x;
+    case 4: x=x*x; return x*x;
+    }
+    if (p<0)  return 1/pow_int(x,-p);
+    if (p>64) return pow(x,p);
+    while (p) {
+        if (p&1) r *= x;
+        x *= x;
+        p >>= 1;
+    }
+    return r;
+}
+
+
+static inline dtype f_sum(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y=0;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y += x;
+        }
+        p += stride;
+    }
+    return y;
+}
+
+static inline dtype f_prod(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y=1;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y *= x;
+        }
+        p += stride;
+    }
+    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=0;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y += x;
+            count++;
+        }
+        p += stride;
+    }
+    return y/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=0;
+    dtype a,m;
+
+    m = f_mean(n,p,stride);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            a = x - m;
+            y += a*a;
+            count++;
+        }
+        p += stride;
+    }
+    return y/(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_rms(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x,y=0;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y += x*x;
+            count++;
+        }
+        p += stride;
+    }
+    return m_sqrt(y/count);
+}
+
+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 (!m_isnan(x) && (m_isnan(y) || 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 (!m_isnan(x) && (m_isnan(y) || 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 (!m_isnan(x) && (m_isnan(y) || 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 (!m_isnan(x) && (m_isnan(y) || x>y)) {
+            y = x;
+            j = i;
+        }
+    }
+    return j;
+}

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

@@ -0,0 +1,12 @@
+typedef int16_t dtype;
+typedef int16_t rtype;
+#define cT  numo_cInt16
+#define cRT cT
+
+#define m_num_to_data(x) ((dtype)NUM2INT(x))
+#define m_data_to_num(x) INT2NUM((int)(x))
+#define m_extract(x)     INT2NUM((int)*(dtype*)(x))
+#define m_sprintf(s,x)   sprintf(s,"%d",(int)(x))
+#define m_rand           ((dtype)gen_rand32())
+
+#include "int_macro.h"

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

@@ -0,0 +1,12 @@
+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_extract(x)     INT322NUM((int32_t)*(dtype*)(x))
+#define m_sprintf(s,x)   sprintf(s,"%"PRId32,(int32_t)(x))
+#define m_rand           ((dtype)gen_rand32())
+
+#include "int_macro.h"

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

@@ -0,0 +1,12 @@
+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_extract(x)     INT642NUM((int64_t)*(dtype*)(x))
+#define m_sprintf(s,x)   sprintf(s,"%"PRId64,(int64_t)(x))
+#define m_rand           ((dtype)gen_rand64())
+
+#include "int_macro.h"

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

@@ -0,0 +1,12 @@
+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) INT2NUM((int)(x))
+#define m_extract(x)     INT2NUM((int)*(dtype*)(x))
+#define m_sprintf(s,x)   sprintf(s,"%d",(int)(x))
+#define m_rand           ((dtype)gen_rand32())
+
+#include "int_macro.h"

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

@@ -0,0 +1,34 @@
+#include "xint_macro.h"
+
+#define m_abs(x)     ((x<0)?-x:x)
+
+static inline dtype int_inverse(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;
+}