cumo 0.1.0

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

@@ -0,0 +1,158 @@
+#ifndef CUMO_FLOAT_MACRO_KERNEL_H
+#define CUMO_FLOAT_MACRO_KERNEL_H
+
+#include "float_def_kernel.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_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_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_reciprocal(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_trunc(x)   trunc(x)
+#define m_rint(x)    rint(x)
+#define m_sign(x)    (((x)==0) ? 0.0:(((x)>0) ? 1.0:(((x)<0) ? -1.0:(x))))
+#define m_copysign(x,y) copysign(x,y)
+#define m_signbit(x) signbit(x)
+#define m_modf(x,y,z) {double d; y=modf(x,&d); z=d;}
+
+#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_isposinf(x) (isinf(x) && signbit(x)==0)
+#define m_isneginf(x) (isinf(x) && signbit(x))
+#define m_isfinite(x) isfinite(x)
+
+#define m_mulsum_init 0
+
+#define m_sprintf(s,x) sprintf(s,"%g",x)
+
+/*
+#define cmp_prnan(a,b)                         \
+    ((qsort_cast(a)==qsort_cast(b)) ? 0 :      \
+     (qsort_cast(a) > qsort_cast(b)) ? 1 : -1)
+
+#define cmp_ignan(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_prnan(a,b)                        \
+    (qsort_cast(a) > qsort_cast(b))
+
+#define cmpgt_ignan(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_expm1(x)   expm1(x)
+#define m_log1p(x)   log1p(x)
+
+#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_sinc(x)    (sin(x)/(x))
+
+#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)
+
+/* only internal use (called by pow_int) */
+__host__ __device__ static inline dtype pow_positive_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>64) return pow(x,p);
+    while (p) {
+        if (p&1) r *= x;
+        x *= x;
+        p >>= 1;
+    }
+    return r;
+}
+
+__host__ __device__ static inline dtype pow_int(dtype x, int p)
+{
+    if (p<0) return 1/pow_positive_int(x, -p);
+    return pow_positive_int(x, p);
+}
+
+__host__ __device__ static inline dtype f_seq(dtype x, dtype y, double c)
+{
+    return x + y * c;
+}
+
+#include "real_accum_kernel.h"
+
+#endif // CUMO_FLOAT_MACRO_KERNEL_H

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

@@ -0,0 +1,24 @@
+typedef int16_t dtype;
+typedef int16_t rtype;
+#define cT  cumo_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))
+
+#ifndef INT16_MIN
+#define INT16_MIN (-32767-1)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX (32767)
+#endif
+
+#define DATA_MIN INT16_MIN
+#define DATA_MAX INT16_MAX
+
+#define M_MIN  m_data_to_num(INT16_MIN)
+#define M_MAX  m_data_to_num(INT16_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,23 @@
+#ifndef CUMO_INT16_KERNEL_H
+#define CUMO_INT16_KERNEL_H
+
+typedef int16_t dtype;
+typedef int16_t rtype;
+#define cT  cumo_cInt16
+#define cRT cT
+
+#define m_sprintf(s,x)   sprintf(s,"%d",(int)(x))
+
+#ifndef INT16_MIN
+#define INT16_MIN (-32767-1)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX (32767)
+#endif
+
+#define DATA_MIN INT16_MIN
+#define DATA_MAX INT16_MAX
+
+#include "int_macro_kernel.h"
+
+#endif // CUMO_INT16_KERNEL_H

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

@@ -0,0 +1,24 @@
+typedef int32_t dtype;
+typedef int32_t rtype;
+#define cT  cumo_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))
+
+#ifndef INT32_MIN
+#define INT32_MIN (-2147483647-1)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX (2147483647)
+#endif
+
+#define DATA_MIN INT32_MIN
+#define DATA_MAX INT32_MAX
+
+#define M_MIN  m_data_to_num(INT32_MIN)
+#define M_MAX  m_data_to_num(INT32_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,19 @@
+#ifndef CUMO_INT32_KERNEL_H
+#define CUMO_INT32_KERNEL_H
+
+typedef int32_t dtype;
+typedef int32_t rtype;
+
+#ifndef INT32_MIN
+#define INT32_MIN (-2147483647-1)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX (2147483647)
+#endif
+
+#define DATA_MIN INT32_MIN
+#define DATA_MAX INT32_MAX
+
+#include "int_macro_kernel.h"
+
+#endif // CUMO_INT32_KERNEL_H

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

@@ -0,0 +1,24 @@
+typedef int64_t dtype;
+typedef int64_t rtype;
+#define cT  cumo_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))
+
+#ifndef INT64_MIN
+#define INT64_MIN (-9223372036854775807l-1)
+#endif
+#ifndef INT64_MAX
+#define INT64_MAX (9223372036854775807l)
+#endif
+
+#define DATA_MIN INT64_MIN
+#define DATA_MAX INT64_MAX
+
+#define M_MIN  m_data_to_num(INT64_MIN)
+#define M_MAX  m_data_to_num(INT64_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,19 @@
+#ifndef CUMO_INT64_KERNEL_H
+#define CUMO_INT64_KERNEL_H
+
+typedef int64_t dtype;
+typedef int64_t rtype;
+
+#ifndef INT64_MIN
+#define INT64_MIN (-9223372036854775807l-1)
+#endif
+#ifndef INT64_MAX
+#define INT64_MAX (9223372036854775807l)
+#endif
+
+#define DATA_MIN INT64_MIN
+#define DATA_MAX INT64_MAX
+
+#include "int_macro_kernel.h"
+
+#endif // CUMO_INT64_KERNEL_H

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

@@ -0,0 +1,24 @@
+typedef int8_t dtype;
+typedef int8_t rtype;
+#define cT  cumo_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))
+
+#ifndef INT8_MIN
+#define INT8_MIN (-127-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX (127)
+#endif
+
+#define DATA_MIN INT8_MIN
+#define DATA_MAX INT8_MAX
+
+#define M_MIN  INT2FIX(INT8_MIN)
+#define M_MAX  INT2FIX(INT8_MAX)
+
+#include "int_macro.h"

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

@@ -0,0 +1,19 @@
+#ifndef CUMO_INT8_KERNEL_H
+#define CUMO_INT8_KERNEL_H
+
+typedef int8_t dtype;
+typedef int8_t rtype;
+
+#ifndef INT8_MIN
+#define INT8_MIN (-127-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX (127)
+#endif
+
+#define DATA_MIN INT8_MIN
+#define DATA_MAX INT8_MAX
+
+#include "int_macro_kernel.h"
+
+#endif // CUMO_INT8_KERNEL_H

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

@@ -0,0 +1,67 @@
+#include "xint_macro.h"
+
+#define m_sign(x)    (((x)==0) ? 0 : (((x)>0) ? 1 : -1))
+
+static inline dtype m_abs(dtype x) {
+    if (x==DATA_MIN) {
+        rb_raise(nary_eValueError, "cannot convert the minimum integer");
+    }
+    return (x<0)?-x:x;
+}
+
+static inline dtype int_reciprocal(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;
+}
+*/
+
+static inline int64_t f_sum(size_t n, char *p, ssize_t stride)
+{
+    int64_t x,y=0;
+    size_t i=n;
+    for (; i--;) {
+        x = *(dtype*)p;
+        y += x;
+        p += stride;
+    }
+    return y;
+}
+
+static inline int64_t f_prod(size_t n, char *p, ssize_t stride)
+{
+    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/int_macro_kernel.h

@@ -0,0 +1,48 @@
+#ifndef CUMO_INT_MACRO_KERNEL_H
+#define CUMO_INT_MACRO_KERNEL_H
+
+#include "xint_macro_kernel.h"
+
+#define m_sign(x)    (((x)==0) ? 0 : (((x)>0) ? 1 : -1))
+
+__host__ __device__ static inline dtype m_abs(dtype x) {
+    // TODO(sonots): How to handle in CUDA kernel?
+    // if (x==DATA_MIN) {
+    //     rb_raise(nary_eValueError, "cannot convert the minimum integer");
+    // }
+    return (x<0)?-x:x;
+}
+
+__host__ __device__ static inline dtype int_reciprocal(dtype x) {
+    switch (x) {
+    case 1:
+        return 1;
+    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;
+    }
+    if (p<0) return 0;
+    while (p) {
+        if (p&1) r *= x;
+        x *= x;
+        p >>= 1;
+    }
+    return r;
+}
+
+#endif // CUMO_INT_MACRO_KERNEL_H