numo-narray 0.9.0.5 → 0.9.0.6

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

@@ -0,0 +1,440 @@
+
+#define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
+#define m_mulsum_nan(x,y,z) {            \
+        if(!m_isnan(x) && !m_isnan(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 (m_isnan(x)) {         \
+            (x) = (y);            \
+        } else if (!m_isnan(y)) { \
+            (x) = m_add(x,y);     \
+        }}
+
+#define m_cumprod(x,y) {(x)=m_mul(x,y);}
+#define m_cumprod_nan(x,y) {      \
+        if (m_isnan(x)) {         \
+            (x) = (y);            \
+        } else if (!m_isnan(y)) { \
+            (x) = m_mul(x,y);     \
+        }}
+
+static inline dtype f_sum(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y=m_zero;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        y = m_add(x,y);
+    }
+    return y;
+}
+
+static inline dtype f_sum_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y=m_zero;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(x)) {
+            y = m_add(x,y);
+        }
+    }
+    return y;
+}
+
+
+static inline dtype f_prod(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y=m_one;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        y = m_mul(x,y);
+    }
+    return y;
+}
+
+static inline dtype f_prod_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y=m_one;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(x)) {
+            y = m_mul(x,y);
+        }
+    }
+    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=m_zero;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        y = m_add(x,y);
+        count++;
+    }
+    return m_div(y,m_from_real(count));
+}
+
+static inline dtype f_mean_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x,y=m_zero;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(x)) {
+            y = m_add(x,y);
+            count++;
+        }
+    }
+    return m_div(y,m_from_real(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=m_zero;
+    dtype a,m;
+
+    m = f_mean(n,p,stride);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        a = m_abs(m_sub(x,m));
+        y = m_add(y,m_square(a));
+        count++;
+    }
+    return m_div(y,m_from_real(count-1));
+}
+
+static inline dtype f_var_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x,y=m_zero;
+    dtype a,m;
+
+    m = f_mean_nan(n,p,stride);
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(x)) {
+            a = m_abs(m_sub(x,m));
+            y = m_add(y,m_square(a));
+            count++;
+        }
+    }
+    return m_div(y,m_from_real(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_stddev_nan(size_t n, char *p, ssize_t stride)
+{
+    return m_sqrt(f_var_nan(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=m_zero;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        y = m_add(y,m_square(m_abs(x)));
+        count++;
+    }
+    return m_sqrt(m_div(y,m_from_real(count)));
+}
+
+static inline dtype f_rms_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x,y=m_zero;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(x)) {
+            y = m_add(y,m_square(m_abs(x)));
+            count++;
+        }
+    }
+    return m_sqrt(m_div(y,m_from_real(count)));
+}
+
+// ---------------------------------------------------------
+
+static inline dtype f_min_nan(size_t n, char *p, ssize_t stride)
+{
+    dtype x,y;
+    size_t i=n;
+
+    y = *(dtype*)p;
+    p += stride;
+    if (m_isnan(y)) {return y;}
+    for (i--; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_isnan(x)) {return x;}
+        if (m_lt(x,y)) {
+            y = x;
+        }
+    }
+    return y;
+}
+
+static inline dtype f_min(size_t n, char *p, ssize_t stride)
+{
+    dtype x,y=m_zero;
+    size_t i=n;
+
+    for (; i--; ) {
+        y = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(y)) {
+            for (; i--;) {
+                x = *(dtype*)p;
+                p += stride;
+                if (m_lt(x,y)) {
+                    y = x;
+                }
+            }
+            break;
+        }
+    }
+    return y;
+}
+
+static inline dtype f_max_nan(size_t n, char *p, ssize_t stride)
+{
+    dtype x,y;
+    size_t i=n;
+
+    y = *(dtype*)p;
+    p += stride;
+    if (m_isnan(y)) {return y;}
+    for (i--; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_isnan(x)) {return x;}
+        if (m_gt(x,y)) {
+            y = x;
+        }
+    }
+    return y;
+}
+
+static inline dtype f_max(size_t n, char *p, ssize_t stride)
+{
+    dtype x,y=m_zero;
+    size_t i=n;
+
+    for (; i--; ) {
+        y = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(y)) {
+            for (; i--;) {
+                x = *(dtype*)p;
+                p += stride;
+                if (m_gt(x,y)) {
+                    y = x;
+                }
+            }
+            break;
+        }
+    }
+    return y;
+}
+
+static inline size_t f_min_index_nan(size_t n, char *p, ssize_t stride)
+{
+    dtype x, y;
+    size_t i, j=0;
+
+    y = *(dtype*)p;
+    p += stride;
+    if (m_isnan(y)) {return j;}
+    for (i=1; i<n; i++) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_isnan(x)) {return i;}
+        if (m_lt(x,y)) {
+            y = x;
+            j = i;
+        }
+    }
+    return j;
+}
+
+static inline size_t f_min_index(size_t n, char *p, ssize_t stride)
+{
+    dtype x, y;
+    size_t i, j=0;
+
+    for (i=0; i<n; i++) {
+        y = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(y)) {
+            j = i;
+            for (; i<n; i++) {
+                x = *(dtype*)p;
+                p += stride;
+                if (m_lt(x,y)) {
+                    y = x;
+                    j = i;
+                }
+            }
+            break;
+        }
+    }
+    return j;
+}
+
+static inline size_t f_max_index_nan(size_t n, char *p, ssize_t stride)
+{
+    dtype x, y;
+    size_t i, j=0;
+
+    y = *(dtype*)p;
+    p += stride;
+    if (m_isnan(y)) {return j;}
+    for (i=1; i<n; i++) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_isnan(x)) {return i;}
+        if (m_gt(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;
+
+    for (i=0; i<n; i++) {
+        y = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(y)) {
+            j = i;
+            for (; i<n; i++) {
+                x = *(dtype*)p;
+                p += stride;
+                if (m_gt(x,y)) {
+                    y = x;
+                    j = i;
+                }
+            }
+            break;
+        }
+    }
+    return j;
+}
+
+static inline void
+f_minmax_nan(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;
+    if (m_isnan(min)) {
+        *amin = *amax = min;
+        return;
+    }
+    for (i--; i--;) {
+        x = *(dtype*)p;
+        p += stride;
+        if (m_isnan(x)) {
+            *amin = *amax = x;
+            return;
+        }
+        if (m_lt(x,min)) {
+            min = x;
+        }
+        if (m_gt(x,max)) {
+            max = x;
+        }
+    }
+    *amin = min;
+    *amax = max;
+    return;
+}
+
+static inline dtype f_ptp_nan(size_t n, char *p, ssize_t stride)
+{
+    dtype min,max;
+    f_minmax_nan(n,p,stride,&min,&max);
+    return m_sub(max,min);
+}
+
+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 = m_zero;
+    for (; i--; ) {
+        min = *(dtype*)p;
+        p += stride;
+        if (!m_isnan(min)) {
+            max = min;
+            for (; i--;) {
+                x = *(dtype*)p;
+                p += stride;
+                if (m_lt(x,min)) {
+                    min = x;
+                }
+                if (m_gt(x,max)) {
+                    max = x;
+                }
+            }
+            break;
+        }
+    }
+    *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);
+}

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

@@ -54,12 +54,6 @@
 #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_mulsum_nan(x,y,z) {z = m_add(m_mul(x,y),z);}
-#define m_mulsum(x,y,z) {if(!m_isnan(x) && !m_isnan(y)){z = m_add(m_mul(x,y),z);}}
-#define m_cumsum_nan(x,y) {(x)=m_add(x,y);}
-#define m_cumsum(x,y) {if (m_isnan(x)) {(x)=(y);} else if (!m_isnan(y)) {(x)=m_add(x,y);}}
-#define m_cumprod_nan(x,y) {(x)=m_mul(x,y);}
-#define m_cumprod(x,y) {if (m_isnan(x)) {(x)=(y);} else if (!m_isnan(y)) {(x)=m_mul(x,y);}}
 
 #define m_sprintf(s,x) robj_sprintf(s,x)
 
@@ -68,408 +62,14 @@ static inline int robj_sprintf(char *s, VALUE x) {
     return sprintf(s,"%s",StringValuePtr(v));
 }
 
-static inline dtype f_sum_nan(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)) {return x;}
-        y = m_add(x,y);
-        p += stride;
-    }
-    return y;
-}
-
-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_nan(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)) {return x;}
-        y = m_mul(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_nan(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)) {return x;}
-        y = m_add(x,y);
-        count++;
-        p += stride;
-    }
-    return m_div(y,DBL2NUM(count));
-}
-
-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_nan(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_nan(n,p,stride);
-    if (m_isnan(m)) {return m;}
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return 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_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_nan(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_nan(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_nan(n,p,stride));
-}
-
-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_nan(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)) {return 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_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_nan(size_t n, char *p, ssize_t stride)
-{
-    dtype x,y;
-    size_t i=n;
-
-    y = *(dtype*)p;
-    if (m_isnan(y)) {return y;}
-    p += stride;
-    i--;
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        if (m_lt(x,y)) {
-            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 (!m_isnan(x) && (m_isnan(y) || m_lt(x,y))) {
-            y = x;
-        }
-        p += stride;
-    }
-    return y;
-}
-
-static inline dtype f_max_nan(size_t n, char *p, ssize_t stride)
-{
-    dtype x,y;
-    size_t i=n;
-
-    y = *(dtype*)p;
-    if (m_isnan(y)) {return y;}
-    p += stride;
-    i--;
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        if (m_gt(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_nan(size_t n, char *p, ssize_t stride)
-{
-    dtype x, y;
-    size_t i, j=0;
-
-    y = *(dtype*)p;
-    if (m_isnan(y)) {return y;}
-    for (i=1; i<n; i++) {
-        x = *(dtype*)(p+i*stride);
-        if (m_isnan(x)) {return x;}
-        if (m_lt(x,y)) {
-            y = x;
-            j = i;
-        }
-    }
-    return j;
-}
-
-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_nan(size_t n, char *p, ssize_t stride)
-{
-    dtype x, y;
-    size_t i, j=0;
-
-    y = *(dtype*)p;
-    if (m_isnan(y)) {return y;}
-    for (i=1; i<n; i++) {
-        x = *(dtype*)(p+i*stride);
-        if (m_isnan(x)) {return x;}
-        if (m_gt(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;
-}
-
-static inline void
-f_minmax_nan(size_t n, char *p, ssize_t stride, dtype *amin, dtype *amax)
-{
-    dtype x,min,max;
-    size_t i=n;
-
-    min = max = *(dtype*)p;
-    if (m_isnan(min)) {
-        *amin = *amax = min;
-        return;
-    }
-    p += stride;
-    i--;
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {
-            *amin = *amax = x;
-            return;
-        }
-        if (m_lt(x,min)) {
-            min = x;
-        }
-        if (m_gt(x,max)) {
-            max = x;
-        }
-        p += stride;
-    }
-    *amin = min;
-    *amax = max;
-    return;
-}
-
-static inline dtype f_ptp_nan(size_t n, char *p, ssize_t stride)
-{
-    dtype min,max;
-    f_minmax_nan(n,p,stride,&min,&max);
-    return m_sub(max,min);
-}
-
-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;
-    i--;
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (!m_isnan(x)) {
-            if (m_isnan(min) || m_lt(x,min)) {
-                min = x;
-            }
-            if (m_isnan(max) || m_gt(x,max)) {
-                max = 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);
-}
+#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"