ruby-dnn 0.1.6 → 0.1.7

data/lib/dnn/ext/mnist/numo/types/float_def.h

@@ -1,34 +0,0 @@
-#ifndef DBL_EPSILON
-#define DBL_EPSILON 2.2204460492503131e-16
-#endif
-#ifndef FLT_EPSILON
-#define FLT_EPSILON 1.1920928955078125e-07
-#endif
-#ifndef DBL_MAX
-#define DBL_MAX 1.7976931348623157e+308
-#endif
-#ifndef DBL_MAX
-#define DBL_MAX 1.7976931348623157e+308
-#endif
-#ifndef FLT_MIN
-#define FLT_MIN 1.1754943508222875e-38
-#endif
-#ifndef FLT_MAX
-#define FLT_MAX 3.4028234663852886e+38
-#endif
-
-#ifndef M_PI_2
-#define M_PI_2         1.57079632679489661923  /* pi/2 */
-#endif
-#ifndef M_LOG2E
-#define M_LOG2E        1.4426950408889634074   /* log_2 e */
-#endif
-#ifndef M_LOG10E
-#define M_LOG10E       0.43429448190325182765  /* log_10 e */
-#endif
-#ifndef M_LN2
-#define M_LN2          0.69314718055994530942  /* log_e 2 */
-#endif
-#ifndef M_LN10
-#define M_LN10         2.30258509299404568402  /* log_e 10 */
-#endif

data/lib/dnn/ext/mnist/numo/types/float_macro.h

@@ -1,186 +0,0 @@
-#include "float_def.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_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 INT2FIX(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)
-
-static inline dtype pow_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<0)  return 1/pow_int(x,-p);
-    if (p>64) return pow(x,p);
-    while (p) {
-        if (p&1) r *= x;
-        x *= x;
-        p >>= 1;
-    }
-    return r;
-}
-
-static inline dtype f_seq(dtype x, dtype y, double c)
-{
-    return x + y * c;
-}
-
-static inline dtype f_kahan_sum(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;
-        p += stride;
-        if (fabs(x) > fabs(y)) {
-            dtype z=x; x=y; y=z;
-        }
-        r += x;
-        t = y;
-        y += r;
-        t = y-t;
-        r -= t;
-    }
-    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;
-        p += stride;
-        if (!m_isnan(x)) {
-            if (fabs(x) > fabs(y)) {
-                dtype z=x; x=y; y=z;
-            }
-            r += x;
-            t = y;
-            y += r;
-            t = y-t;
-            r -= t;
-        }
-    }
-    return y;
-}
-
-#include "real_accum.h"

data/lib/dnn/ext/mnist/numo/types/int16.h

@@ -1,24 +0,0 @@
-typedef int16_t dtype;
-typedef int16_t rtype;
-#define cT  numo_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/lib/dnn/ext/mnist/numo/types/int32.h

@@ -1,24 +0,0 @@
-typedef int32_t dtype;
-typedef int32_t rtype;
-#define cT  numo_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/lib/dnn/ext/mnist/numo/types/int64.h

@@ -1,24 +0,0 @@
-typedef int64_t dtype;
-typedef int64_t rtype;
-#define cT  numo_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/lib/dnn/ext/mnist/numo/types/int8.h

@@ -1,24 +0,0 @@
-typedef int8_t dtype;
-typedef int8_t rtype;
-#define cT  numo_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/lib/dnn/ext/mnist/numo/types/int_macro.h

@@ -1,41 +0,0 @@
-#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;
-}

data/lib/dnn/ext/mnist/numo/types/real_accum.h

@@ -1,486 +0,0 @@
-#define not_nan(x) ((x)==(x))
-
-#define m_mulsum(x,y,z) {z = m_add(m_mul(x,y),z);}
-#define m_mulsum_nan(x,y,z) {          \
-        if(not_nan(x) && not_nan(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 (!not_nan(x)) {       \
-            (x) = (y);           \
-        } else if (not_nan(y)) { \
-            (x) = m_add(x,y);    \
-        }}
-
-#define m_cumprod(x,y) {(x)=m_mul(x,y);}
-#define m_cumprod_nan(x,y) {     \
-        if (!not_nan(x)) {       \
-            (x) = (y);           \
-        } else if (not_nan(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;
-        y = m_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=m_zero;
-
-    for (; i--;) {
-        x = *(dtype*)p;
-        p += stride;
-        if (not_nan(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 (not_nan(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 (not_nan(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 (not_nan(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 (not_nan(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 (!not_nan(y)) {return y;}
-    for (i--; i--;) {
-        x = *(dtype*)p;
-        p += stride;
-        if (!not_nan(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 (not_nan(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 (!not_nan(y)) {return y;}
-    for (i--; i--;) {
-        x = *(dtype*)p;
-        p += stride;
-        if (!not_nan(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 (not_nan(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 (!not_nan(y)) {return j;}
-    for (i=1; i<n; i++) {
-        x = *(dtype*)p;
-        p += stride;
-        if (!not_nan(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 (not_nan(y)) {
-            j = i; 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 (!not_nan(y)) {return j;}
-    for (i=1; i<n; i++) {
-        x = *(dtype*)p;
-        p += stride;
-        if (!not_nan(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 (not_nan(y)) {
-            j = i; 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 (!not_nan(min)) {
-        *amin = *amax = min;
-        return;
-    }
-    for (i--; i--;) {
-        x = *(dtype*)p;
-        p += stride;
-        if (!not_nan(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 (not_nan(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);
-}
-
-
-static inline dtype f_maximum(dtype x, dtype y)
-{
-    if (m_ge(x,y)) {
-        return x;
-    }
-    if (not_nan(y)) {
-        return y;
-    }
-    return x;
-}
-
-static inline dtype f_maximum_nan(dtype x, dtype y)
-{
-    if (m_ge(x,y)) {
-        return x;
-    }
-    if (!not_nan(x)) {
-        return x;
-    }
-    return y;
-}
-
-static inline dtype f_minimum(dtype x, dtype y)
-{
-    if (m_le(x,y)) {
-        return x;
-    }
-    if (not_nan(y)) {
-        return y;
-    }
-    return x;
-}
-
-static inline dtype f_minimum_nan(dtype x, dtype y)
-{
-    if (m_le(x,y)) {
-        return x;
-    }
-    if (!not_nan(x)) {
-        return x;
-    }
-    return y;
-}