cumo 0.1.0

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

@@ -0,0 +1,20 @@
+#ifndef CUMO_UINT64_KERNEL_H
+#define CUMO_UINT64_KERNEL_H
+
+typedef u_int64_t dtype;
+typedef u_int64_t rtype;
+
+#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
+
+#include "uint_macro_kernel.h"
+
+#endif // CUMO_UINT64_KERNEL_H

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

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

@@ -0,0 +1,20 @@
+#ifndef CUMO_UINT8_KERNEL_H
+#define CUMO_UINT8_KERNEL_H
+
+typedef u_int8_t dtype;
+typedef u_int8_t rtype;
+
+#ifndef UINT8_MIN
+#define UINT8_MIN (0)
+#endif
+
+#ifndef UINT8_MAX
+#define UINT8_MAX (255)
+#endif
+
+#define DATA_MIN UINT8_MIN
+#define DATA_MAX UINT8_MAX
+
+#include "uint_macro_kernel.h"
+
+#endif // CUMO_UINT8_KERNEL_H

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

@@ -0,0 +1,58 @@
+#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/cumo/include/cumo/types/uint_macro_kernel.h

@@ -0,0 +1,38 @@
+#ifndef CUMO_UINT_MACRO_KERNEL_H
+#define CUMO_UINT_MACRO_KERNEL_H
+
+#include "xint_macro_kernel.h"
+
+#define m_abs(x)     (x)
+#define m_sign(x)    (((x)==0) ? 0:1)
+
+__host__ __device__ static inline dtype int_reciprocal(dtype x) {
+    switch (x) {
+    case 1:
+        return 1;
+    case 0:
+        return 0; // as CUDA kernel 1/0 results in 0.
+        //rb_raise(rb_eZeroDivError, "divided by 0");
+    default:
+        return 0;
+    }
+}
+
+__device__ 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;
+}
+
+#endif // CUMO_UINT_MACRO_KERNEL_H

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

@@ -0,0 +1,169 @@
+#define m_zero 0
+#define m_one  1
+
+#define m_from_double(x) (x)
+#define m_from_real(x) (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/cumo/include/cumo/types/xint_macro_kernel.h

@@ -0,0 +1,88 @@
+#ifndef CUMO_XINT_MACRO_KERNEL_H
+#define CUMO_XINT_MACRO_KERNEL_H
+
+#define m_zero 0
+#define m_one  1
+
+#define m_from_double(x) (x)
+#define m_from_real(x) (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 0
+//#define m_cumsum(x,y) {x += y;}
+//#define m_cumprod(x,y) {x *= y;}
+
+__host__ __device__ static inline double f_seq(double x, double y, double c)
+{
+    return x + y * c;
+}
+
+__host__ __device__ static inline dtype f_maximum(dtype x, dtype y)
+{
+    if (m_ge(x,y)) {
+        return x;
+    }
+    return y;
+}
+
+__host__ __device__ static inline dtype f_minimum(dtype x, dtype y)
+{
+    if (m_le(x,y)) {
+        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_square : public thrust::unary_function<dtype, dtype>
+{
+    __host__ __device__ rtype operator()(const dtype& x) const { return m_square(x); }
+};
+
+#endif // CUMO_XINT_MACRO_KERNEL_H

data/ext/cumo/narray/SFMT-params.h

@@ -0,0 +1,97 @@
+#ifndef SFMT_PARAMS_H
+#define SFMT_PARAMS_H
+
+#if !defined(MEXP)
+//#ifdef __GNUC__
+//  #warning "MEXP is not defined. I assume MEXP is 19937."
+//#endif
+  #define MEXP 19937
+#endif
+/*-----------------
+  BASIC DEFINITIONS
+  -----------------*/
+/** Mersenne Exponent. The period of the sequence 
+ *  is a multiple of 2^MEXP-1.
+ * #define MEXP 19937 */
+/** SFMT generator has an internal state array of 128-bit integers,
+ * and N is its size. */
+#define N (MEXP / 128 + 1)
+/** N32 is the size of internal state array when regarded as an array
+ * of 32-bit integers.*/
+#define N32 (N * 4)
+/** N64 is the size of internal state array when regarded as an array
+ * of 64-bit integers.*/
+#define N64 (N * 2)
+
+/*----------------------
+  the parameters of SFMT
+  following definitions are in paramsXXXX.h file.
+  ----------------------*/
+/** the pick up position of the array.
+#define POS1 122 
+*/
+
+/** the parameter of shift left as four 32-bit registers.
+#define SL1 18
+ */
+
+/** the parameter of shift left as one 128-bit register. 
+ * The 128-bit integer is shifted by (SL2 * 8) bits. 
+#define SL2 1 
+*/
+
+/** the parameter of shift right as four 32-bit registers.
+#define SR1 11
+*/
+
+/** the parameter of shift right as one 128-bit register. 
+ * The 128-bit integer is shifted by (SL2 * 8) bits. 
+#define SR2 1 
+*/
+
+/** A bitmask, used in the recursion.  These parameters are introduced
+ * to break symmetry of SIMD.
+#define MSK1 0xdfffffefU
+#define MSK2 0xddfecb7fU
+#define MSK3 0xbffaffffU
+#define MSK4 0xbffffff6U 
+*/
+
+/** These definitions are part of a 128-bit period certification vector.
+#define PARITY1	0x00000001U
+#define PARITY2	0x00000000U
+#define PARITY3	0x00000000U
+#define PARITY4	0xc98e126aU
+*/
+
+#if MEXP == 607
+  #include "SFMT-params607.h"
+#elif MEXP == 1279
+  #include "SFMT-params1279.h"
+#elif MEXP == 2281
+  #include "SFMT-params2281.h"
+#elif MEXP == 4253
+  #include "SFMT-params4253.h"
+#elif MEXP == 11213
+  #include "SFMT-params11213.h"
+#elif MEXP == 19937
+  #include "SFMT-params19937.h"
+#elif MEXP == 44497
+  #include "SFMT-params44497.h"
+#elif MEXP == 86243
+  #include "SFMT-params86243.h"
+#elif MEXP == 132049
+  #include "SFMT-params132049.h"
+#elif MEXP == 216091
+  #include "SFMT-params216091.h"
+#else
+#ifdef __GNUC__
+  #error "MEXP is not valid."
+  #undef MEXP
+#else
+  #undef MEXP
+#endif
+
+#endif
+
+#endif /* SFMT_PARAMS_H */