numo-narray 0.9.0.1-x86-mingw32

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

@@ -0,0 +1,218 @@
+#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_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_inverse(x)   rb_funcall(x,id_inverse,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_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_op_gt,1,y))
+#define m_ge(x,y)      RTEST(rb_funcall(x,id_op_ge,1,y))
+#define m_lt(x,y)      RTEST(rb_funcall(x,id_op_lt,1,y))
+#define m_le(x,y)      RTEST(rb_funcall(x,id_op_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_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_isfinite(x)  ((rb_respond_to(x,id_finite_p)) ? RTEST(rb_funcall(x,id_finite_p,0)) : 0)
+
+#define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
+#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) 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));
+}
+
+static inline dtype f_sum(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y=INT2FIX(0);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y = m_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=INT2FIX(1);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y = m_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=INT2FIX(0);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y = m_add(x,y);
+            count++;
+        }
+        p += stride;
+    }
+    return m_div(y,DBL2NUM(count));
+}
+
+static inline dtype f_var(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x,m;
+    dtype y=INT2FIX(0);
+
+    m = f_mean(n,p,stride);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y = m_add(y,m_square(m_abs(m_sub(x,m))));
+            count++;
+        }
+        p += stride;
+    }
+    return m_div(y,DBL2NUM(count-1));
+}
+
+static inline dtype f_stddev(size_t n, char *p, ssize_t stride)
+{
+    VALUE m = rb_const_get(rb_mKernel,rb_intern("Math"));
+    return rb_funcall(m,rb_intern("sqrt"),1,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;
+    dtype y=INT2FIX(0);
+    VALUE m;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (!m_isnan(x)) {
+            y = m_add(y,m_square(m_abs(x)));
+            count++;
+        }
+        p += stride;
+    }
+    y = m_div(y,DBL2NUM(count));
+    m = rb_const_get(rb_mKernel,rb_intern("Math"));
+    return rb_funcall(m,rb_intern("sqrt"),1,y);
+}
+
+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) || m_lt(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) || m_gt(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) || m_lt(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) || m_gt(x,y))) {
+            y = x;
+            j = i;
+        }
+    }
+    return j;
+}

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

@@ -0,0 +1,21 @@
+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);
+}

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

@@ -0,0 +1,11 @@
+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;
+}

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

@@ -0,0 +1,13 @@
+typedef float dtype;
+typedef float rtype;
+#define cT  numo_cSFloat
+#define cRT cT
+#define mTM numo_mSFloatMath
+
+#include "float_macro.h"
+
+#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)

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,133 @@
+#define m_zero 0
+#define m_one  1
+
+#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_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_inverse(x) int_inverse(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_isnan(x) 0
+
+#define m_mulsum(x,y,z) {z += x*y;}
+#define m_mulsum_init INT2FIX(0)
+
+#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_sum(size_t n, char *p, ssize_t stride)
+{
+    dtype x,y=0;
+    size_t i=n;
+    for (; i--;) {
+        x = *(dtype*)p;
+        y += x;
+        p += stride;
+    }
+    return y;
+}
+
+static inline dtype f_prod(size_t n, char *p, ssize_t stride)
+{
+    dtype x,y=1;
+    size_t i=n;
+    for (; i--;) {
+        x = *(dtype*)p;
+        y *= x;
+        p += stride;
+    }
+    return y;
+}
+
+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;
+}

data/ext/numo/narray/rand.c

@@ -0,0 +1,87 @@
+#include "ruby.h"
+#include "numo/narray.h"
+#include "SFMT.h"
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#include <time.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+
+int n_bits(u_int64_t a)
+{
+    int i, x, /*xu,*/ xl, n=5;
+    u_int64_t m;
+
+    if (a==0) return 0;
+    //if (a<0) a=-a;
+
+    x  = 1<<n;
+    //xu = 1<<(n+1);
+    xl = 0;
+    //printf("%3i, [%3i, %3i], %i\n", i, xu, xl, x);
+
+    for (i=n; i>=0; i--) {
+	m = ~((1<<(x-1))-1);
+	if (m & a) {
+	    xl = x;
+	    x += 1<<(i-1);
+	} else {
+	    //xu = x;
+	    x -= 1<<(i-1);
+	}
+	//printf("%3i, [%3i, %3i], %i, 0x%lx, 0x%lx\n", i, xu, xl, x, m, m&a);
+    }
+    return xl;
+}
+
+void rand_norm(double *a)
+{
+    double x1, x2, w;
+    do {
+	x1 = to_res53(gen_rand64());
+	x1 = x1*2-1;
+	x2 = to_res53(gen_rand64());
+	x2 = x2*2-1;
+	w = x1 * x1 + x2 * x2;
+    } while (w>=1);
+    w = sqrt( (-2*log(w)) / w );
+    a[0] = x1*w;
+    a[1] = x2*w;
+}
+
+static u_int64_t
+ random_seed()
+{
+    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(seed);
+
+    return Qnil;
+}
+
+void
+Init_nary_rand() {
+    rb_define_singleton_method(cNArray, "srand", nary_s_srand, -1);
+    init_gen_rand(0);
+}