numo-narray 0.9.0.4 → 0.9.0.5

data/ext/numo/narray/ndloop.c

@@ -1,7 +1,7 @@
 /*
   ndloop.c
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2016 by Masahiro TANAKA
+    (C) Copyright 1999-2017 by Masahiro TANAKA
 */
 
 #include <ruby.h>
@@ -70,10 +70,13 @@ typedef struct NA_MD_LOOP {
 #define NDL_WRITE 2
 #define NDL_READ_WRITE (NDL_READ|NDL_WRITE)
 
+static ID id_cast;
+static ID id_extract;
+
 static inline VALUE
 nary_type_s_cast(VALUE type, VALUE obj)
 {
-    return rb_funcall(type,rb_intern("cast"),1,obj);
+    return rb_funcall(type,id_cast,1,obj);
 }
 
 static void
@@ -470,24 +473,6 @@ ndloop_release(VALUE vlp)
 }
 
 
-/*
-static void
-ndloop_free(na_md_loop_t* lp)
-{
-    int j;
-    VALUE v;
-
-    for (j=0; j<lp->narg; j++) {
-        v = LARG(lp,j).value;
-        if (IsNArray(v)) {
-            na_release_lock(v);
-        }
-    }
-    xfree(lp);
-}
-*/
-
-
 /*
   set lp->n[i] (shape of n-d iteration) here
 */
@@ -529,7 +514,7 @@ ndloop_set_stepidx(na_md_loop_t *lp, int j, VALUE vna, int *dim_map, int rwflag)
     narray_t *na;
 
     LARG(lp,j).value = vna;
-    LARG(lp,j).elmsz = na_get_elmsz(vna);
+    LARG(lp,j).elmsz = nary_element_stride(vna);
     if (rwflag == NDL_READ) {
         LARG(lp,j).ptr = na_get_pointer_for_read(vna);
     } else
@@ -796,7 +781,7 @@ ndloop_set_output_narray(ndfunc_t *nf, na_md_loop_t *lp, int k,
     }
     if (!RTEST(v)) {
         // new object
-        v = rb_narray_new(type, na_ndim, na_shape);
+        v = nary_new(type, na_ndim, na_shape);
         flag = NDL_WRITE;
     }
 
@@ -1226,7 +1211,7 @@ ndloop_extract(VALUE results, ndfunc_t *nf)
     narray_t *na;
 
     if (id_extract==0) {
-        id_extract = rb_intern("extract");
+        id_extract = id_extract;
     }
 
     // extract result objects
@@ -1662,7 +1647,7 @@ loop_store_subnarray(ndfunc_t *nf, na_md_loop_t *lp, int i0, size_t *c, VALUE a)
 
     a_type = CLASS_OF(LARG(lp,0).value);
     if (CLASS_OF(a) != a_type) {
-        a = rb_funcall(a_type, rb_intern("cast"), 1, a);
+        a = rb_funcall(a_type, id_cast, 1, a);
     }
     GetNArray(a,na);
     if (na->ndim != nd-i0+1) {
@@ -1971,3 +1956,11 @@ na_ndloop(nf, argc, va_alist)
 
     return rb_ensure(ndloop_run, (VALUE)&lp, ndloop_release, (VALUE)&lp);
 }
+
+
+void
+Init_nary_ndloop()
+{
+    id_cast    = rb_intern("cast");
+    id_extract = rb_intern("extract");
+}

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

@@ -1,65 +1,80 @@
 /*
   intern.h
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2016 by Masahiro TANAKA
+    (C) Copyright 1999-2017 by Masahiro TANAKA
 */
 #ifndef INTERN_H
 #define INTERN_H
 
-VALUE rb_narray_new(VALUE elem, int ndim, size_t *shape);
-VALUE rb_narray_view_new(VALUE elem, int ndim, size_t *shape);
-VALUE rb_narray_debug_info(VALUE);
+#define rb_narray_new nary_new
+VALUE nary_new(VALUE elem, int ndim, size_t *shape);
+#define rb_narray_view_new nary_view_new
+VALUE nary_view_new(VALUE elem, int ndim, size_t *shape);
+#define rb_narray_debug_info nary_debug_info
+VALUE nary_debug_info(VALUE);
 
-VALUE na_original_data(VALUE self);
-VALUE na_make_view(VALUE self);
-VALUE na_make_view_struct(VALUE self, VALUE dtype, VALUE offset);
-void na_array_to_internal_shape(VALUE self, VALUE ary, size_t *shape);
-VALUE na_expand_dims(VALUE self, VALUE vdim);
+#define na_make_view nary_make_view
+VALUE nary_make_view(VALUE self);
 
-VALUE na_reduce_dimension(int argc, VALUE *argv, int naryc, VALUE *naryv);
+#define na_s_allocate nary_s_allocate
+VALUE nary_s_allocate(VALUE klass);
+#define na_s_allocate_view nary_s_allocate_view
+VALUE nary_s_allocate_view(VALUE klass);
+#define na_s_new_like nary_s_new_like
+VALUE nary_s_new_like(VALUE type, VALUE obj);
 
-VALUE na_check_ladder(VALUE self, int start_dim);
-VALUE na_check_contiguous(VALUE self);
+void na_alloc_shape(narray_t *na, int ndim);
+void na_array_to_internal_shape(VALUE self, VALUE ary, size_t *shape);
+void na_index_arg_to_internal_order(int argc, VALUE *argv, VALUE self);
 void na_setup_shape(narray_t *na, int ndim, size_t *shape);
 
-VALUE na_transpose_map(VALUE self, int *map);
-VALUE na_flatten_dim(VALUE self, int sd);
-VALUE na_flatten_by_reduce(int argc, VALUE *argv, VALUE self);
+#define na_get_elmsz nary_element_stride
+//#define na_element_stride nary_element_stride
+unsigned int nary_element_stride(VALUE nary);
+#define na_dtype_elmsz nary_dtype_element_stride
+size_t nary_dtype_element_stride(VALUE klass);
 
-VALUE na_sort_main(int argc, VALUE *argv, volatile VALUE self, na_iter_func_t iter_func);
-VALUE na_median_main(int argc, VALUE *argv, volatile VALUE self, na_iter_func_t iter_func);
+#define na_get_pointer nary_get_pointer
+char *nary_get_pointer(VALUE);
+#define na_get_pointer_for_write nary_get_pointer_for_write
+char *nary_get_pointer_for_write(VALUE);
+#define na_get_pointer_for_read nary_get_pointer_for_read
+char *nary_get_pointer_for_read(VALUE);
+#define na_get_pointer_for_read_write nary_get_pointer_for_read_write
+char *nary_get_pointer_for_read_write(VALUE);
+#define na_get_offset nary_get_offset
+size_t nary_get_offset(VALUE self);
 
-VALUE na_sort_index_main(int argc, VALUE *argv, VALUE self, void (*func_qsort)());
+#define na_copy_flags nary_copy_flags
+void nary_copy_flags(VALUE src, VALUE dst);
 
-char *na_get_pointer(VALUE);
-char *na_get_pointer_for_write(VALUE);
-char *na_get_pointer_for_read(VALUE);
-char *na_get_pointer_for_read_write(VALUE);
+#define na_check_ladder nary_check_ladder
+VALUE nary_check_ladder(VALUE self, int start_dim);
+#define na_check_contiguous nary_check_contiguous
+VALUE nary_check_contiguous(VALUE self);
 
-size_t na_get_offset(VALUE self);
+#define na_flatten_dim nary_flatten_dim
+VALUE nary_flatten_dim(VALUE self, int sd);
 
-VALUE na_s_allocate(VALUE klass);
-VALUE na_s_allocate_view(VALUE klass);
+#define na_flatten nary_flatten
+VALUE nary_flatten(VALUE);
 
-void na_alloc_shape(narray_t *na, int ndim);
-void na_alloc_index(narray_t *na);
+#define na_copy nary_dup
+VALUE nary_dup(VALUE);
 
-void na_copy_flags(VALUE src, VALUE dst);
+#define na_store nary_store
+VALUE nary_store(VALUE self, VALUE src);
 
-VALUE na_flatten(VALUE);
-VALUE na_copy(VALUE);
-VALUE na_upcast(VALUE type1, VALUE type2);
+#define na_upcast numo_na_upcast
+VALUE numo_na_upcast(VALUE type1, VALUE type2);
 
-stridx_t *na_get_stride(VALUE v);
+void na_release_lock(VALUE); // currently do nothing
 
-void na_release_lock(VALUE);
-
-void na_index_arg_to_internal_order(int argc, VALUE *argv, VALUE self);
-
-//ndfunc_t *ndfunc_alloc(na_iter_func_t func, int has_loop, int narg, int nres, ...);
-//ndfunc_t *ndfunc_alloc2(na_iter_func_t func, unsigned int flag, int narg, int nres, VALUE *etypes);
-//void ndfunc_free(ndfunc_t* nf);
+// 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);
 
+// ndloop
 VALUE na_ndloop(ndfunc_t *nf, int argc, ...);
 VALUE na_ndloop2(ndfunc_t *nf, VALUE args);
 VALUE na_ndloop3(ndfunc_t *nf, void *ptr, int argc, ...);
@@ -68,41 +83,22 @@ VALUE na_ndloop4(ndfunc_t *nf, void *ptr, VALUE args);
 VALUE na_ndloop_cast_narray_to_rarray(ndfunc_t *nf, VALUE nary, VALUE fmt);
 VALUE na_ndloop_store_rarray(ndfunc_t *nf, VALUE nary, VALUE rary);
 VALUE na_ndloop_store_rarray2(ndfunc_t *nf, VALUE nary, VALUE rary, VALUE opt);
-
 VALUE na_ndloop_inspect(VALUE nary, na_text_func_t func, VALUE opt);
-
 VALUE na_ndloop_with_index(ndfunc_t *nf, int argc, ...);
 
+#define na_info_str nary_info_str
+VALUE nary_info_str(VALUE);
 
-VALUE na_info_str(VALUE);
-
-size_t na_get_elmsz(VALUE nary);
-size_t na_dtype_elmsz(VALUE klass);
-
-bool na_test_reduce(VALUE reduce, int dim);
-
-//size_t *na_mdarray_investigate(VALUE ary, int *ndim, VALUE *type);
-VALUE na_ary_composition(VALUE ary);
-
-//void na_copy_bytes(na_loop_t *const itr);
-
-VALUE na_debug_set(VALUE mod, VALUE flag);
+#define na_test_reduce nary_test_reduce
+bool nary_test_reduce(VALUE reduce, int dim);
 
 void nary_step_array_index(VALUE self, size_t ary_size, size_t *plen, ssize_t *pbeg, ssize_t *pstep);
-
-VALUE na_store(VALUE self, VALUE src);
-
 void nary_step_sequence(VALUE self, size_t *plen, double *pbeg, double *pstep);
 
-VALUE nary_init_accum_aref0(VALUE self, VALUE reduce);
-
-VALUE nary_mathcast(int argc, VALUE *argv);
-
-
-int
-na_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx);
-VALUE
-na_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int nd);
-
+// used in aref, aset
+#define na_get_result_dimension nary_get_result_dimension
+int nary_get_result_dimension(VALUE self, int argc, VALUE *argv, ssize_t stride, size_t *pos_idx);
+#define na_aref_main nary_aref_main
+VALUE nary_aref_main(int nidx, VALUE *idx, VALUE self, int keep_dim, int nd);
 
 #endif /* ifndef INTERN_H */

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

@@ -1,13 +1,20 @@
 /*
   narray.h
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2016 by Masahiro TANAKA
+    (C) Copyright 1999-2017 by Masahiro TANAKA
 */
 #ifndef NARRAY_H
 #define NARRAY_H
 
-#define NARRAY_VERSION "0.9.0.4"
-#define NARRAY_VERSION_CODE 904
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#define NARRAY_VERSION "0.9.0.5"
+#define NARRAY_VERSION_CODE 905
 
 #include <math.h>
 #include "numo/compat.h"
@@ -126,13 +133,14 @@ extern VALUE nary_eCastError;
 extern VALUE nary_eShapeError;
 extern VALUE nary_eOperationError;
 extern VALUE nary_eDimensionError;
+extern const rb_data_type_t na_data_type;
 
 //EXTERN const int na_sizeof[NA_NTYPES+1];
 #endif
 
 #define cNArray numo_cNArray
 #define mNumo rb_mNumo
-#define na_upcast(x,y) numo_na_upcast(x,y)
+//#define na_upcast(x,y) numo_na_upcast(x,y)
 
 /* global variables within this module */
 extern VALUE numo_cBit;
@@ -167,6 +175,7 @@ typedef struct RNArray {
     unsigned char ndim;     // # of dimensions
     unsigned char type;
     unsigned char flag[2];  // flags
+    unsigned short elmsz;    // element size
     size_t   size;          // # of total elements
     size_t  *shape;         // # of elements for each dimension
     VALUE    reduce;
@@ -210,11 +219,12 @@ typedef struct RNArrayFileMap {
 } narray_filemap_t;
 
 
+// this will be revised in future.
 typedef struct {
-    int     ndim;
-    size_t *shape;
-    VALUE   dtype;
-} na_compose_t;
+    unsigned int element_bits;
+    unsigned int element_bytes;
+    unsigned int element_stride;
+} narray_type_info_t;
 
 
 static inline narray_t *
@@ -222,7 +232,7 @@ na_get_narray_t(VALUE obj)
 {
     narray_t *na;
 
-    Check_Type(obj, T_DATA);
+    Check_TypedStruct(obj,&na_data_type);
     na = (narray_t*)DATA_PTR(obj);
     return na;
 }
@@ -232,7 +242,7 @@ _na_get_narray_t(VALUE obj, unsigned char na_type)
 {
     narray_t *na;
 
-    Check_Type(obj, T_DATA);
+    Check_TypedStruct(obj,&na_data_type);
     na = (narray_t*)DATA_PTR(obj);
     if (na->type != na_type) {
         rb_bug("unknown type 0x%x (0x%x given)", na_type, na->type);
@@ -244,9 +254,9 @@ _na_get_narray_t(VALUE obj, unsigned char na_type)
 #define na_get_narray_view_t(obj) (narray_view_t*)_na_get_narray_t(obj,NARRAY_VIEW_T)
 #define na_get_narray_filemap_t(obj) (narray_filemap_t*)_na_get_narray_t(obj,NARRAY_FILEMAP_T)
 
-#define GetNArray(obj,var)  Data_Get_Struct(obj, narray_t, var)
-#define GetNArrayView(obj,var)  Data_Get_Struct(obj, narray_view_t, var)
-#define GetNArrayData(obj,var)  Data_Get_Struct(obj, narray_data_t, var)
+#define GetNArray(obj,var)      TypedData_Get_Struct(obj, narray_t, &na_data_type, var)
+#define GetNArrayView(obj,var)  TypedData_Get_Struct(obj, narray_view_t, &na_data_type, var)
+#define GetNArrayData(obj,var)  TypedData_Get_Struct(obj, narray_data_t, &na_data_type, var)
 
 #define SDX_IS_STRIDE(x) ((x).stride&0x1)
 #define SDX_IS_INDEX(x)  (!SDX_IS_STRIDE(x))
@@ -387,6 +397,7 @@ _na_get_narray_t(VALUE obj, unsigned char na_type)
 #define NUM2IMAG(v)  NUM2DBL( rb_funcall((v),na_id_imag,0) )
 
 #define NA_MAX_DIMENSION (int)(sizeof(VALUE)*8-2)
+#define NA_MAX_ELMSZ     65535
 
 typedef unsigned int BIT_DIGIT;
 //#define BYTE_BIT_DIGIT sizeof(BIT_DIGIT)
@@ -398,7 +409,21 @@ typedef unsigned int BIT_DIGIT;
 #define ELEMENT_BYTE_SIZE "ELEMENT_BYTE_SIZE"
 #define CONTIGUOUS_STRIDE "CONTIGUOUS_STRIDE"
 
+
+#ifdef RUBY_INTEGER_UNIFICATION
+#define IS_INTEGER_CLASS(c) ((c)==rb_cInteger)
+#else
+#define IS_INTEGER_CLASS(c) ((c)==rb_cFixnum||(c)==rb_cBignum)
+#endif
+
 #include "numo/ndloop.h"
 #include "numo/intern.h"
 
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
 #endif /* ifndef NARRAY_H */

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

@@ -1,7 +1,7 @@
 /*
   ndloop.h
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2016 by Masahiro TANAKA
+    (C) Copyright 1999-2017 by Masahiro TANAKA
 */
 #ifndef NDLOOP_H
 #define NDLOOP_H

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

@@ -1,7 +1,7 @@
 /*
   template.h
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2016 by Masahiro TANAKA
+    (C) Copyright 1999-2017 by Masahiro TANAKA
 */
 #ifndef TEMPLATE_H
 #define TEMPLATE_H

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

@@ -1,7 +1,7 @@
 /*
   complex.h
   Numerical Array Extension for Ruby
-    (C) Copyright 1999-2016 by Masahiro TANAKA
+    (C) Copyright 1999-2017 by Masahiro TANAKA
 */
 
 
@@ -39,9 +39,13 @@ static inline dtype NUM2COMP(VALUE v) {
 #define c_is_zero(x) (REAL(x)==0 && IMAG(x)==0)
 #define c_eq(x,y) (REAL(x)==REAL(y) && IMAG(x)==IMAG(y))
 #define c_ne(x,y) (REAL(x)!=REAL(y) || IMAG(x)!=IMAG(y))
-#define c_isnan(x) (isnan(REAL(x))||isnan(IMAG(x)))
-#define c_isinf(x) (isinf(REAL(x))||isinf(IMAG(x)))
-#define c_isfinite(x) (isfinite(REAL(x))&&isfinite(IMAG(x)))
+#define c_isnan(x) (isnan(REAL(x)) || isnan(IMAG(x)))
+#define c_isinf(x) (isinf(REAL(x)) || isinf(IMAG(x)))
+#define c_isposinf(x) ((isinf(REAL(x)) && signbit(REAL(x))==0) || \
+                       (isinf(IMAG(x)) && signbit(IMAG(x))==0))
+#define c_isneginf(x) ((isinf(REAL(x)) && signbit(REAL(x))) || \
+                       (isinf(IMAG(x)) && signbit(IMAG(x))))
+#define c_isfinite(x) (isfinite(REAL(x)) && isfinite(IMAG(x)))
 
 static inline dtype c_zero() {
     dtype z;

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

@@ -85,13 +85,20 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 
 #define m_isnan(x)    c_isnan(x)
 #define m_isinf(x)    c_isinf(x)
+#define m_isposinf(x) c_isposinf(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(x,y,z) {z = c_add(c_mul(x,y),z);}
 #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))
 
@@ -116,12 +123,27 @@ static inline dtype c_from_dcomplex(dcomplex x) {
 #define m_acosh(x)   c_acosh(x)
 #define m_atanh(x)   c_atanh(x)
 #define m_hypot(x,y) c_hypot(x,y)
+#define m_sinc(x)    c_div(c_sin(x),x)
 
 static inline dtype f_sum(size_t n, char *p, ssize_t stride)
 {
     size_t i=n;
     dtype x,y;
 
+    y = c_zero();
+    for (; i--;) {
+        x = *(dtype*)p;
+        y = c_add(x,y);
+        p += stride;
+    }
+    return y;
+}
+
+static inline dtype f_sum_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    dtype x,y;
+
     y = c_zero();
     for (; i--;) {
         x = *(dtype*)p;
@@ -139,6 +161,32 @@ static inline dtype f_kahan_sum(size_t n, char *p, ssize_t stride)
     dtype x;
     volatile dtype y,t,r;
 
+    y = c_zero();
+    r = c_zero();
+    for (; i--;) {
+        x = *(dtype*)p;
+        if (fabs(REAL(x)) > fabs(REAL(y))) {
+            double z=REAL(x); REAL(x)=REAL(y); REAL(y)=z;
+        }
+        if (fabs(IMAG(x)) > fabs(IMAG(y))) {
+            double z=IMAG(x); IMAG(x)=IMAG(y); IMAG(y)=z;
+        }
+        r = c_add(x, r);
+        t = y;
+        y = c_add(r, y);
+        t = c_sub(y, t);
+        r = c_sub(r, t);
+        p += 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,t,r;
+
     y = c_zero();
     r = c_zero();
     for (; i--;) {
@@ -166,6 +214,20 @@ static inline dtype f_prod(size_t n, char *p, ssize_t stride)
     size_t i=n;
     dtype x,y;
 
+    y = c_one();
+    for (; i--;) {
+        x = *(dtype*)p;
+        y = c_mul(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;
+
     y = c_one();
     for (; i--;) {
         x = *(dtype*)p;
@@ -183,6 +245,22 @@ static inline dtype f_mean(size_t n, char *p, ssize_t stride)
     size_t count=0;
     dtype x,y;
 
+    y = c_zero();
+    for (; i--;) {
+        x = *(dtype*)p;
+        y = c_add(x,y);
+        count++;
+        p += stride;
+    }
+    return c_div_r(y,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;
+
     y = c_zero();
     for (; i--;) {
         x = *(dtype*)p;
@@ -204,6 +282,24 @@ static inline rtype f_var(size_t n, char *p, ssize_t stride)
 
     m = f_mean(n,p,stride);
 
+    for (; i--;) {
+        x = *(dtype*)p;
+        y += c_abs_square(c_sub(x,m));
+        count++;
+        p += stride;
+    }
+    return y/(count-1);
+}
+
+static inline rtype f_var_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x,m;
+    rtype y=0;
+
+    m = f_mean_nan(n,p,stride);
+
     for (; i--;) {
         x = *(dtype*)p;
         if (!c_isnan(x)) {
@@ -220,6 +316,11 @@ static inline rtype f_stddev(size_t n, char *p, ssize_t stride)
     return r_sqrt(f_var(n,p,stride));
 }
 
+static inline rtype f_stddev_nan(size_t n, char *p, ssize_t stride)
+{
+    return r_sqrt(f_var_nan(n,p,stride));
+}
+
 static inline rtype f_rms(size_t n, char *p, ssize_t stride)
 {
     size_t i=n;
@@ -227,6 +328,22 @@ static inline rtype f_rms(size_t n, char *p, ssize_t stride)
     dtype x;
     rtype y=0;
 
+    for (; i--;) {
+        x = *(dtype*)p;
+        y += c_abs_square(x);
+        count++;
+        p += stride;
+    }
+    return r_sqrt(y/count);
+}
+
+static inline rtype f_rms_nan(size_t n, char *p, ssize_t stride)
+{
+    size_t i=n;
+    size_t count=0;
+    dtype x;
+    rtype y=0;
+
     for (; i--;) {
         x = *(dtype*)p;
         if (!c_isnan(x)) {