numo-narray 0.9.0.5 → 0.9.0.6

data/ext/numo/narray/narray.c

@@ -32,6 +32,7 @@ static ID id_eq;
 static ID id_count_false;
 static ID id_axis;
 static ID id_nan;
+static ID id_keepdims;
 
 VALUE cPointer;
 
@@ -1042,7 +1043,7 @@ nary_reverse(int argc, VALUE *argv, VALUE self)
     VALUE view;
     VALUE reduce;
 
-    reduce = na_reduce_dimension(argc, argv, 1, &self, 0);
+    reduce = na_reduce_dimension(argc, argv, 1, &self, 0, 0);
 
     GetNArray(self,na);
     nd = na->ndim;
@@ -1448,7 +1449,8 @@ na_test_reduce(VALUE reduce, int dim)
 
 
 VALUE
-na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv, int *propagate_nan)
+na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
+                    ndfunc_t *ndf, na_iter_func_t iter_nan)
 {
     int ndim, ndim0;
     int row_major;
@@ -1462,12 +1464,12 @@ na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv, int *propaga
     size_t m;
     VALUE reduce;
     VALUE kw_hash = Qnil;
-    ID kw_table[2] = {id_axis,id_nan};
-    VALUE opts[2] = {Qundef,Qundef};
+    ID kw_table[3] = {id_axis,id_nan,id_keepdims};
+    VALUE opts[3] = {Qundef,Qundef,Qundef};
     VALUE axes;
 
     narg = rb_scan_args(argc, argv, "*:", &axes, &kw_hash);
-    rb_get_kwargs(kw_hash, kw_table, 0, 2, opts);
+    rb_get_kwargs(kw_hash, kw_table, 0, 3, opts);
 
     // option: axis
     if (opts[0] != Qundef && RTEST(opts[0])) {
@@ -1480,9 +1482,17 @@ na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv, int *propaga
             axes = rb_ary_new3(1,opts[0]);
         }
     }
-    // option: ignore_none
-    if (propagate_nan) {
-        *propagate_nan = (opts[1] != Qundef && RTEST(opts[1])) ? 1 : 0;
+    if (ndf) {
+        // option: nan
+        if (iter_nan && opts[1] != Qundef) {
+            if (RTEST(opts[1]))
+                ndf->func = iter_nan; // replace to nan-aware iterator function
+        }
+        // option: keepdims
+        if (opts[2] != Qundef) {
+            if (RTEST(opts[2]))
+                ndf->flag |= NDF_KEEP_DIM;
+        }
     }
 
     if (naryc<1) {
@@ -1890,6 +1900,7 @@ Init_narray()
     id_count_false = rb_intern("count_false");
     id_axis        = rb_intern("axis");
     id_nan         = rb_intern("nan");
+    id_keepdims    = rb_intern("keepdims");
 
     sym_reduce   = ID2SYM(rb_intern("reduce"));
     sym_option   = ID2SYM(rb_intern("option"));

data/ext/numo/narray/numo/intern.h

@@ -72,7 +72,8 @@ void na_release_lock(VALUE); // currently do nothing
 
 // used in reduce methods
 #define na_reduce_dimension nary_reduce_dimension
-VALUE nary_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv, int *ignore_nan);
+VALUE nary_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv,
+                            ndfunc_t *ndf, na_iter_func_t nan_iter);
 
 // ndloop
 VALUE na_ndloop(ndfunc_t *nf, int argc, ...);

data/ext/numo/narray/numo/narray.h

@@ -13,8 +13,8 @@ extern "C" {
 #endif
 #endif
 
-#define NARRAY_VERSION "0.9.0.5"
-#define NARRAY_VERSION_CODE 905
+#define NARRAY_VERSION "0.9.0.6"
+#define NARRAY_VERSION_CODE 906
 
 #include <math.h>
 #include "numo/compat.h"

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

@@ -89,17 +89,6 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_isneginf(x) c_isneginf(x)
 #define m_isfinite(x) c_isfinite(x)
 
-#define m_sum(x,y) {if (!c_isnan(x)) {y=c_add(x,y);}}
-#define m_sum_init INT2FIX(0)
-
-#define m_mulsum_init INT2FIX(0)
-#define m_mulsum(x,y,z) {z = c_add(c_mul(x,y),z);}
-#define m_mulsum_nan(x,y,z) {if(!m_isnan(x) && !m_isnan(y)){z = c_add(c_mul(x,y),z);}}
-#define m_cumsum(x,y) {(x)=c_add(x,y);}
-#define m_cumsum_nan(x,y) {if (c_isnan(x)) {(x)=(y);} else if (!c_isnan(y)) {(x)=c_add(x,y);}}
-#define m_cumprod(x,y) {(x)=c_mul(x,y);}
-#define m_cumprod_nan(x,y) {if (c_isnan(x)) {(x)=(y);} else if (!c_isnan(y)) {(x)=c_mul(x,y);}}
-
 #define m_sprintf(s,x) sprintf(s,"%g%+gi",REAL(x),IMAG(x))
 
 #define m_sqrt(x)    c_sqrt(x)
@@ -125,6 +114,31 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_hypot(x,y) c_hypot(x,y)
 #define m_sinc(x)    c_div(c_sin(x),x)
 
+#define m_sum_init INT2FIX(0)
+#define m_mulsum_init INT2FIX(0)
+
+#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;

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

@@ -56,12 +56,6 @@ EXTERN double pow(double, double);
 #define m_isfinite(x) isfinite(x)
 
 #define m_mulsum_init INT2FIX(0)
-#define m_mulsum(x,y,z) {(z)+=(x)*(y);}
-#define m_mulsum_nan(x,y,z) {if (isnan(z)) {(z)=(x)*(y);} else if (!isnan(x) && !isnan(y)) {(z)+=(x)*(y);}}
-#define m_cumsum(x,y) {(x)+=(y);}
-#define m_cumsum_nan(x,y) {if (isnan(x)) {(x)=(y);} else if (!isnan(y)) {(x)+=(y);}}
-#define m_cumprod(x,y) {(x)*=(y);}
-#define m_cumprod_nan(x,y) {if (isnan(x)) {(x)=(y);} else if (!isnan(y)) {(x)*=(y);}}
 
 #define m_sprintf(s,x) sprintf(s,"%g",x)
 
@@ -138,37 +132,12 @@ static inline dtype pow_int(dtype x, int p)
     return r;
 }
 
-
-static inline dtype f_sum_nan(size_t n, char *p, ssize_t stride)
-{
-    size_t i=n;
-    dtype x,y=0;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        y += x;
-        p += stride;
-    }
-    return y;
-}
-
-static inline dtype f_sum(size_t n, char *p, ssize_t stride)
+static inline dtype f_seq(dtype x, dtype y, double c)
 {
-    size_t i=n;
-    dtype x,y=0;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (!m_isnan(x)) {
-            y += x;
-        }
-        p += stride;
-    }
-    return y;
+    return x + y * c;
 }
 
-static inline dtype f_kahan_sum_nan(size_t n, char *p, ssize_t stride)
+static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
 {
     size_t i=n;
     dtype x;
@@ -177,7 +146,7 @@ static inline dtype f_kahan_sum_nan(size_t n, char *p, ssize_t stride)
 
     for (; i--;) {
         x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
+        p += stride;
         if (fabs(x) > fabs(y)) {
             dtype z=x; x=y; y=z;
         }
@@ -186,12 +155,11 @@ static inline dtype f_kahan_sum_nan(size_t n, char *p, ssize_t stride)
         y += r;
         t = y-t;
         r -= t;
-        p += stride;
     }
     return y;
 }
 
-static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
+static inline dtype f_kahan_sum_nan(size_t n, char *p, ssize_t stride)
 {
     size_t i=n;
     dtype x;
@@ -200,6 +168,7 @@ static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
 
     for (; i--;) {
         x = *(dtype*)p;
+        p += stride;
         if (!m_isnan(x)) {
             if (fabs(x) > fabs(y)) {
                 dtype z=x; x=y; y=z;
@@ -210,375 +179,8 @@ static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
             t = y-t;
             r -= t;
         }
-        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=1;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        y *= x;
-        p += stride;
-    }
-    return y;
-}
-
-static inline dtype f_prod(size_t n, char *p, ssize_t stride)
-{
-    size_t i=n;
-    dtype x,y=1;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (!m_isnan(x)) {
-            y *= x;
-        }
-        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=0;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        y += x;
-        count++;
-        p += stride;
-    }
-    return y/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=0;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (!m_isnan(x)) {
-            y += x;
-            count++;
-        }
-        p += stride;
-    }
-    return y/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,y=0;
-    dtype a,m;
-
-    m = f_mean_nan(n,p,stride);
-    if (m_isnan(m)) {return m;}
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        a = x - m;
-        y += a*a;
-        count++;
-        p += stride;
-    }
-    return y/(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,y=0;
-    dtype a,m;
-
-    m = f_mean(n,p,stride);
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (!m_isnan(x)) {
-            a = x - m;
-            y += a*a;
-            count++;
-        }
-        p += stride;
-    }
-    return y/(count-1);
-}
-
-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_stddev(size_t n, char *p, ssize_t stride)
-{
-    return m_sqrt(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,y=0;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        y += x*x;
-        count++;
-        p += stride;
-    }
-    return m_sqrt(y/count);
-}
-
-static inline dtype f_rms(size_t n, char *p, ssize_t stride)
-{
-    size_t i=n;
-    size_t count=0;
-    dtype x,y=0;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (!m_isnan(x)) {
-            y += x*x;
-            count++;
-        }
-        p += stride;
-    }
-    return m_sqrt(y/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;
-    if (m_isnan(y)) {return y;}
-    p += stride;
-    i--;
-    for (; i--;) {
-        x = *(dtype*)p;
-        if (m_isnan(x)) {return x;}
-        if (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) || 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 (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) || 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 j;}
-    for (i=1; i<n; i++) {
-        x = *(dtype*)(p+i*stride);
-        if (m_isnan(x)) {return i;}
-        if (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) || 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 j;}
-    for (i=1; i<n; i++) {
-        x = *(dtype*)(p+i*stride);
-        if (m_isnan(x)) {return i;}
-        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 (!m_isnan(x) && (m_isnan(y) || 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(x)) {
-        *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);
-}
-
-static inline dtype f_seq(dtype x, dtype y, double c)
-{
-    return x + y * c;
-}
+#include "real_accum.h"