numo-narray 0.9.0.4 → 0.9.0.5

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

@@ -39,6 +39,8 @@ EXTERN double pow(double, double);
 #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))
@@ -49,21 +51,35 @@ EXTERN double pow(double, double);
 
 #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(x,y,z) {z += x*y;}
 #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)
 
-#define cmp(a,b)                                                        \
-    (m_isnan(qsort_cast(a)) ? (m_isnan(qsort_cast(b)) ? 0 : 1) :            \
-     (m_isnan(qsort_cast(b)) ? -1 :                                       \
+#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(a,b)                                            \
-    ((m_isnan(qsort_cast(a)) && !m_isnan(qsort_cast(b))) ||       \
+#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)
@@ -78,6 +94,9 @@ EXTERN double pow(double, double);
 #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)
@@ -92,6 +111,7 @@ EXTERN double pow(double, double);
 #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)
@@ -119,6 +139,20 @@ static inline dtype pow_int(dtype x, int p)
 }
 
 
+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)
 {
     size_t i=n;
@@ -134,6 +168,29 @@ static inline dtype f_sum(size_t n, char *p, ssize_t stride)
     return y;
 }
 
+static inline dtype f_kahan_sum_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x;
+    volatile dtype y=0;
+    volatile dtype t,r=0;
+
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (m_isnan(x)) {return x;}
+        if (fabs(x) > fabs(y)) {
+            dtype z=x; x=y; y=z;
+        }
+        r += x;
+        t = y;
+        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)
 {
     size_t i=n;
@@ -158,6 +215,20 @@ static inline dtype f_kahan_sum(size_t n, char *p, ssize_t 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;
@@ -173,6 +244,22 @@ static inline dtype f_prod(size_t n, char *p, ssize_t 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;
@@ -190,6 +277,27 @@ static inline dtype f_mean(size_t n, char *p, ssize_t 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;
@@ -211,11 +319,32 @@ static inline dtype f_var(size_t n, char *p, ssize_t 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;
@@ -233,6 +362,26 @@ static inline dtype f_rms(size_t n, char *p, ssize_t 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;
@@ -251,6 +400,26 @@ static inline dtype f_min(size_t n, char *p, ssize_t 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;
@@ -269,6 +438,24 @@ static inline dtype f_max(size_t n, char *p, ssize_t 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;
@@ -285,6 +472,24 @@ static inline size_t f_min_index(size_t n, char *p, ssize_t stride)
     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;
@@ -301,6 +506,78 @@ static inline size_t f_max_index(size_t n, char *p, ssize_t stride)
     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;

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

@@ -26,26 +26,40 @@
 #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_op_ufo,1,INT2FIX(0))
+#define m_sign(x)      rb_funcall(x,id_ufo,1,INT2FIX(0))
 
-#define m_eq(x,y)      RTEST(rb_funcall(x,id_op_eq,1,y))
-#define m_ne(x,y)      RTEST(rb_funcall(x,id_op_ne,1,y))
-#define m_gt(x,y)      RTEST(rb_funcall(x,id_op_gt,1,y))
-#define m_ge(x,y)      RTEST(rb_funcall(x,id_op_ge,1,y))
-#define m_lt(x,y)      RTEST(rb_funcall(x,id_op_lt,1,y))
-#define m_le(x,y)      RTEST(rb_funcall(x,id_op_le,1,y))
+#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(x,y,z) {z = m_add(m_mul(x,y),z);}
 #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)
 
@@ -54,6 +68,20 @@ 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;
@@ -69,6 +97,20 @@ static inline dtype f_sum(size_t n, char *p, ssize_t 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;
@@ -84,6 +126,22 @@ static inline dtype f_prod(size_t n, char *p, ssize_t 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;
@@ -101,6 +159,26 @@ static inline dtype f_mean(size_t n, char *p, ssize_t 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;
@@ -108,7 +186,7 @@ static inline dtype f_var(size_t n, char *p, ssize_t stride)
     dtype x,m;
     dtype y=INT2FIX(0);
 
-    m = f_mean(n,p,stride);
+    m = f_mean_nan(n,p,stride);
 
     for (; i--;) {
         x = *(dtype*)p;
@@ -121,12 +199,38 @@ static inline dtype f_var(size_t n, char *p, ssize_t 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;
@@ -148,6 +252,26 @@ static inline dtype f_rms(size_t n, char *p, ssize_t stride)
     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;
@@ -166,6 +290,26 @@ static inline dtype f_min(size_t n, char *p, ssize_t 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;
@@ -184,6 +328,24 @@ static inline dtype f_max(size_t n, char *p, ssize_t 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;
@@ -200,6 +362,24 @@ static inline size_t f_min_index(size_t n, char *p, ssize_t stride)
     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;
@@ -216,6 +396,78 @@ static inline size_t f_max_index(size_t n, char *p, ssize_t stride)
     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);
+}
+
 static inline dtype f_seq(dtype x, dtype y, size_t c)
 {
     y = m_mul(y,SIZET2NUM(c));