cumo 0.1.0

data/ext/cumo/include/cumo/types/real_accum_kernel.h

@@ -0,0 +1,101 @@
+#ifndef CUMO_REAL_ACCUM_KERNEL_H
+#define CUMO_REAL_ACCUM_KERNEL_H
+
+#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);    \
+        }}
+
+__host__ __device__ static inline dtype f_maximum(dtype x, dtype y)
+{
+    if (m_ge(x,y)) {
+        return x;
+    }
+    if (not_nan(y)) {
+        return y;
+    }
+    return x;
+}
+
+__host__ __device__ 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;
+}
+
+__host__ __device__ static inline dtype f_minimum(dtype x, dtype y)
+{
+    if (m_le(x,y)) {
+        return x;
+    }
+    if (not_nan(y)) {
+        return y;
+    }
+    return x;
+}
+
+__host__ __device__ 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;
+}
+
+/* --------- thrust ----------------- */
+#include "cumo/cuda/cumo_thrust.hpp"
+
+struct cumo_thrust_plus : public thrust::binary_function<dtype, dtype, dtype>
+{
+    __host__ __device__ dtype operator()(dtype x, dtype y) { return m_add(x,y); }
+};
+
+struct cumo_thrust_multiplies : public thrust::binary_function<dtype, dtype, dtype>
+{
+    __host__ __device__ dtype operator()(dtype x, dtype y) { return m_mul(x,y); }
+};
+
+struct cumo_thrust_multiplies_mulsum_nan : public thrust::binary_function<dtype, dtype, dtype>
+{
+    __host__ __device__ dtype operator()(dtype x, dtype y) {
+        if (not_nan(x) && not_nan(y)) {
+            return m_mul(x, y);
+        } else {
+            return m_zero;
+        }
+    }
+};
+
+struct cumo_thrust_square : public thrust::unary_function<dtype, dtype>
+{
+    __host__ __device__ rtype operator()(const dtype& x) const { return m_square(x); }
+};
+
+#endif // CUMO_REAL_ACCUM_KERNEL_H

data/ext/cumo/include/cumo/types/robj_macro.h

@@ -0,0 +1,80 @@
+#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"

data/ext/cumo/include/cumo/types/robject.h

@@ -0,0 +1,27 @@
+typedef VALUE dtype;
+typedef VALUE rtype;
+#define cT  cumo_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/cumo/include/cumo/types/robject_kernel.h

@@ -0,0 +1,7 @@
+//TODO(sonots):
+//typedef VALUE dtype;
+//typedef VALUE rtype;
+typedef void* dtype;
+typedef void* rtype;
+
+#include "robj_macro_kernel.h"

data/ext/cumo/include/cumo/types/scomplex.h

@@ -0,0 +1,46 @@
+typedef scomplex dtype;
+typedef float rtype;
+#define cT  cumo_cSComplex
+#define cRT cumo_cSFloat
+#define mTM cumo_mSComplexMath
+
+#include "complex_macro.h"
+#include "cublas_v2.h"
+#include "cumo/cuda/cublas.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/cumo/include/cumo/types/scomplex_kernel.h

@@ -0,0 +1,13 @@
+#ifndef CUMO_SCOMPLEX_KERNEL_H
+#define CUMO_SCOMPLEX_KERNEL_H
+
+typedef scomplex dtype;
+typedef float rtype;
+
+#include "complex_macro_kernel.h"
+
+__device__ 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;
+}
+
+#endif // CUMO_SCOMPLEX_KERNEL_H

data/ext/cumo/include/cumo/types/sfloat.h

@@ -0,0 +1,48 @@
+typedef float dtype;
+typedef float rtype;
+#define cT  cumo_cSFloat
+#define cRT cumo_cSFloat
+#define mTM cumo_mSFloatMath
+
+#include "float_macro.h"
+#include "cublas_v2.h"
+#include "cumo/cuda/cublas.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 cumo_sfloat_new_dim0(0.0/0.0)
+#define m_max_init cumo_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)
+
+#define DATA_MIN FLT_MIN
+#define DATA_MAX FLT_MAX

data/ext/cumo/include/cumo/types/sfloat_kernel.h

@@ -0,0 +1,14 @@
+#ifndef CUMO_SFLOAT_KERNEL_H
+#define CUMO_SFLOAT_KERNEL_H
+
+typedef float dtype;
+typedef float rtype;
+
+#include "float_macro_kernel.h"
+
+#define m_nearly_eq(x,y) (fabs(x-y)<=(fabs(x)+fabs(y))*FLT_EPSILON*2)
+
+#define DATA_MIN FLT_MIN
+#define DATA_MAX FLT_MAX
+
+#endif // CUMO_SFLOAT_KERNEL_H

data/ext/cumo/include/cumo/types/uint16.h

@@ -0,0 +1,25 @@
+typedef u_int16_t dtype;
+typedef u_int16_t rtype;
+#define cT  cumo_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))
+
+#ifndef UINT16_MIN
+#define UINT16_MIN (0)
+#endif
+
+#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/cumo/include/cumo/types/uint16_kernel.h

@@ -0,0 +1,20 @@
+#ifndef CUMO_UINT16_KERNEL_H
+#define CUMO_UINT16_KERNEL_H
+
+typedef u_int16_t dtype;
+typedef u_int16_t rtype;
+
+#ifndef UINT16_MIN
+#define UINT16_MIN (0)
+#endif
+
+#ifndef UINT16_MAX
+#define UINT16_MAX (65535)
+#endif
+
+#define DATA_MIN UINT16_MIN
+#define DATA_MAX UINT16_MAX
+
+#include "uint_macro_kernel.h"
+
+#endif // CUMO_UINT16_KERNEL_H

data/ext/cumo/include/cumo/types/uint32.h

@@ -0,0 +1,25 @@
+typedef u_int32_t dtype;
+typedef u_int32_t rtype;
+#define cT  cumo_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))
+
+#ifndef UINT32_MIN
+#define UINT32_MIN (0)
+#endif
+
+#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/cumo/include/cumo/types/uint32_kernel.h

@@ -0,0 +1,20 @@
+#ifndef CUMO_UINT32_KERNEL_H
+#define CUMO_UINT32_KERNEL_H
+
+typedef u_int32_t dtype;
+typedef u_int32_t rtype;
+
+#ifndef UINT32_MIN
+#define UINT32_MIN (0)
+#endif
+
+#ifndef UINT32_MAX
+#define UINT32_MAX (4294967295u)
+#endif
+
+#define DATA_MIN UINT32_MIN
+#define DATA_MAX UINT32_MAX
+
+#include "uint_macro_kernel.h"
+
+#endif // CUMO_UINT32_KERNEL_H

data/ext/cumo/include/cumo/types/uint64.h

@@ -0,0 +1,25 @@
+typedef u_int64_t dtype;
+typedef u_int64_t rtype;
+#define cT  cumo_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))
+
+#ifndef UINT64_MIN
+#define UINT64_MIN (0)
+#endif
+
+#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"