[svn-r16318] Added an option to avoid dealing with NaNs

-N, --nan               Avoid NaNs detection
Note: there is no shell script run for datasets with NaN because the output is non portable (different results and NaN strings for different systems)



Tested: windows, linux

17 files changed, 249 insertions, 153 deletions

diff --git a/tools/h5diff/h5diff_main.c b/tools/h5diff/h5diff_main.c
index 6ab3946..3b6c699 100644
--- a/tools/h5diff/h5diff_main.c
+++ b/tools/h5diff/h5diff_main.c
@@ -35,7 +35,7 @@ const char  *progname = "h5diff";
  * Command-line options: The user can specify short or long-named
  * parameters.
  */
-static const char *s_opts = "hVrvqn:d:p:";
+static const char *s_opts = "hVrvqn:d:p:N";
 static struct long_options l_opts[] = {
     { "help", no_arg, 'h' },
     { "version", no_arg, 'V' },
@@ -45,6 +45,7 @@ static struct long_options l_opts[] = {
     { "count", require_arg, 'n' },
     { "delta", require_arg, 'd' },
     { "relative", require_arg, 'p' },
+    { "nan", no_arg, 'N' },
     { NULL, 0, '\0' }
 };
 
@@ -147,6 +148,9 @@ void parse_command_line(int argc,
 
     /* assume equal contents initially */
     options->contents = 1;
+
+     /* NaNs are handled by default */
+    options->do_nans = 1;
     
     /* parse command line options */
     while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) 
@@ -208,6 +212,13 @@ void parse_command_line(int argc,
             options->count = atol( opt_arg );
             
             break;
+
+            
+        case 'N':
+            options->do_nans = 0;
+            break;
+
+
         }
     }
     
@@ -406,6 +417,8 @@ void usage(void)
  printf("   -n C, --count=C         Print differences up to C number\n");
  printf("   -d D, --delta=D         Print difference when greater than limit D\n");
  printf("   -p R, --relative=R      Print difference when greater than relative limit R\n");
+ printf("   -N, --nan               Avoid NaNs detection\n");
+
  
 
  printf("\n");
diff --git a/tools/h5diff/testfiles/h5diff_10.txt b/tools/h5diff/testfiles/h5diff_10.txt
index b803903..58a6985 100644
--- a/tools/h5diff/testfiles/h5diff_10.txt
+++ b/tools/h5diff/testfiles/h5diff_10.txt
@@ -12,6 +12,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_600.txt b/tools/h5diff/testfiles/h5diff_600.txt
index 12fad07..98d7b68 100644
--- a/tools/h5diff/testfiles/h5diff_600.txt
+++ b/tools/h5diff/testfiles/h5diff_600.txt
@@ -12,6 +12,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_603.txt b/tools/h5diff/testfiles/h5diff_603.txt
index d47d8f9..e34c68e 100644
--- a/tools/h5diff/testfiles/h5diff_603.txt
+++ b/tools/h5diff/testfiles/h5diff_603.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_604.txt b/tools/h5diff/testfiles/h5diff_604.txt
index 0192e55..fe050cc 100644
--- a/tools/h5diff/testfiles/h5diff_604.txt
+++ b/tools/h5diff/testfiles/h5diff_604.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_605.txt b/tools/h5diff/testfiles/h5diff_605.txt
index 8f6ef4b..89b1fe8 100644
--- a/tools/h5diff/testfiles/h5diff_605.txt
+++ b/tools/h5diff/testfiles/h5diff_605.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_606.txt b/tools/h5diff/testfiles/h5diff_606.txt
index 58f7bde..7b16431 100644
--- a/tools/h5diff/testfiles/h5diff_606.txt
+++ b/tools/h5diff/testfiles/h5diff_606.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_612.txt b/tools/h5diff/testfiles/h5diff_612.txt
index ee3b373..051c4a8 100644
--- a/tools/h5diff/testfiles/h5diff_612.txt
+++ b/tools/h5diff/testfiles/h5diff_612.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_613.txt b/tools/h5diff/testfiles/h5diff_613.txt
index cc9cb56..d5ac351 100644
--- a/tools/h5diff/testfiles/h5diff_613.txt
+++ b/tools/h5diff/testfiles/h5diff_613.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_614.txt b/tools/h5diff/testfiles/h5diff_614.txt
index 4c80b41..4d134cc 100644
--- a/tools/h5diff/testfiles/h5diff_614.txt
+++ b/tools/h5diff/testfiles/h5diff_614.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_615.txt b/tools/h5diff/testfiles/h5diff_615.txt
index d699dc0..941578f 100644
--- a/tools/h5diff/testfiles/h5diff_615.txt
+++ b/tools/h5diff/testfiles/h5diff_615.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_621.txt b/tools/h5diff/testfiles/h5diff_621.txt
index a008a72..d882bc1 100644
--- a/tools/h5diff/testfiles/h5diff_621.txt
+++ b/tools/h5diff/testfiles/h5diff_621.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_622.txt b/tools/h5diff/testfiles/h5diff_622.txt
index 561a8ad..0e52ee0 100644
--- a/tools/h5diff/testfiles/h5diff_622.txt
+++ b/tools/h5diff/testfiles/h5diff_622.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_623.txt b/tools/h5diff/testfiles/h5diff_623.txt
index 9873f35..33eec29 100644
--- a/tools/h5diff/testfiles/h5diff_623.txt
+++ b/tools/h5diff/testfiles/h5diff_623.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/h5diff/testfiles/h5diff_624.txt b/tools/h5diff/testfiles/h5diff_624.txt
index ed0d302..740a6c6 100644
--- a/tools/h5diff/testfiles/h5diff_624.txt
+++ b/tools/h5diff/testfiles/h5diff_624.txt
@@ -13,6 +13,7 @@ usage: h5diff [OPTIONS] file1 file2 [obj1[obj2]]
    -n C, --count=C         Print differences up to C number
    -d D, --delta=D         Print difference when greater than limit D
    -p R, --relative=R      Print difference when greater than relative limit R
+   -N, --nan               Avoid NaNs detection
 
   C - is a positive integer
   D - is a positive number. Compare criteria is |a - b| > D
diff --git a/tools/lib/h5diff.h b/tools/lib/h5diff.h
index 3bd4473..bdad702 100644
--- a/tools/lib/h5diff.h
+++ b/tools/lib/h5diff.h
@@ -38,6 +38,7 @@ typedef struct {
     int    cmn_objs;  /* do we have comparable objects */
     int    not_cmp;   /* are the objects comparable */
     int    contents;  /* equal contents */
+    int    do_nans;   /* consider Nans while diffing floats */
 } diff_opt_t;
 
 
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index dcfebdb..ecaac24 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -142,10 +142,10 @@ static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id,hid_t region1_id, hid_t
 static hbool_t all_zero(const void *_mem, size_t size);
 static hsize_t character_compare(unsigned char *mem1,unsigned char *mem2,hsize_t i,unsigned u,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
 static hsize_t character_compare_opt(unsigned char *mem1,unsigned char *mem2,hsize_t i,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
-static hbool_t equal_float(float value, float expected);
-static hbool_t equal_double(double value, double expected);
+static hbool_t equal_float(float value, float expected, diff_opt_t *options);
+static hbool_t equal_double(double value, double expected, diff_opt_t *options);
 #if H5_SIZEOF_LONG_DOUBLE !=0
-static hbool_t equal_ldouble(long double value, long double expected);
+static hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *options);
 #endif
 static int print_data(diff_opt_t *options);
 static void print_pos(int *ph,int pp,hsize_t curr_pos,hsize_t *acc,hsize_t *pos,int rank,hsize_t *dims,const char *obj1,const char *obj2 );
@@ -1780,8 +1780,8 @@ hsize_t diff_datum(void       *_mem1,
         {
             float temp1_float;
             float temp2_float;
-            int   isnan1;
-            int   isnan2;
+            int   isnan1=0;
+            int   isnan2=0;
 
             assert(type_size==sizeof(float));
 
@@ -1802,8 +1802,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                    isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {             
@@ -1832,8 +1835,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                    isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {   
@@ -1882,8 +1888,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                    isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {   
@@ -1925,7 +1934,7 @@ hsize_t diff_datum(void       *_mem1,
             * no -d and -p
             *-------------------------------------------------------------------------
             */
-            else if (equal_float(temp1_float,temp2_float)==FALSE)
+            else if (equal_float(temp1_float,temp2_float,options)==FALSE)
             {
                 
                 if ( print_data(options) )
@@ -1947,8 +1956,8 @@ hsize_t diff_datum(void       *_mem1,
         {
             double temp1_double;
             double temp2_double;
-            int    isnan1;
-            int    isnan2;
+            int    isnan1=0;
+            int    isnan2=0;
 
 
             assert(type_size==sizeof(double));
@@ -1968,10 +1977,12 @@ hsize_t diff_datum(void       *_mem1,
                /*-------------------------------------------------------------------------
                 * detect NaNs
                 *-------------------------------------------------------------------------
-                */
-                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
-                
+                */ 
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                    isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                }
                 if ( !isnan1 && !isnan2)
                 {           
                     
@@ -2000,8 +2011,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                    isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {           
@@ -2050,8 +2064,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                    isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {           
@@ -2094,7 +2111,7 @@ hsize_t diff_datum(void       *_mem1,
             * no -d and -p 
             *-------------------------------------------------------------------------
             */
-            else if (equal_double(temp1_double,temp2_double)==FALSE)
+            else if (equal_double(temp1_double,temp2_double,options)==FALSE)
             {
                 if ( print_data(options) )
                 {
@@ -2119,8 +2136,8 @@ hsize_t diff_datum(void       *_mem1,
         {
             long double temp1_double;
             long double temp2_double;
-            int    isnan1;
-            int    isnan2;
+            int    isnan1=0;
+            int    isnan2=0;
 
 
             assert(type_size==sizeof(long  double));
@@ -2141,8 +2158,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                    isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {           
@@ -2172,8 +2192,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                    isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {           
@@ -2222,8 +2245,11 @@ hsize_t diff_datum(void       *_mem1,
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+                if ( options->do_nans )
+                {
+                    isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                    isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+                }
                 
                 if ( !isnan1 && !isnan2)
                 {           
@@ -2266,7 +2292,7 @@ hsize_t diff_datum(void       *_mem1,
             * no -d and -p 
             *-------------------------------------------------------------------------
             */
-            else if (equal_ldouble(temp1_double,temp2_double)==FALSE)
+            else if (equal_ldouble(temp1_double,temp2_double,options)==FALSE)
             {
                 if ( print_data(options) )
                 {
@@ -2762,8 +2788,8 @@ hsize_t diff_float(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
-    int         isnan1;
-    int         isnan2;
+    int         isnan1=0;
+    int         isnan2=0;
     
 
  /*-------------------------------------------------------------------------
@@ -2782,8 +2808,11 @@ hsize_t diff_float(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-            isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            }
 
             if ( !isnan1 && !isnan2)
             {             
@@ -2820,8 +2849,11 @@ hsize_t diff_float(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-            isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            }
             
             if ( !isnan1 && !isnan2)
             {        
@@ -2879,8 +2911,11 @@ hsize_t diff_float(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
-            isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+            }
             
             if ( !isnan1 && !isnan2)
             {        
@@ -2936,7 +2971,7 @@ hsize_t diff_float(unsigned char *mem1,
             memcpy(&temp2_float, mem2, sizeof(float));
 
             
-            if (equal_float(temp1_float,temp2_float)==FALSE)
+            if (equal_float(temp1_float,temp2_float,options)==FALSE)
             {
                 if ( print_data(options) )
                 {
@@ -2991,8 +3026,8 @@ hsize_t diff_double(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
-    int         isnan1;
-    int         isnan2;
+    int         isnan1=0;
+    int         isnan2=0;
     
 
  /*-------------------------------------------------------------------------
@@ -3011,8 +3046,11 @@ hsize_t diff_double(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            }
 
             if ( !isnan1 && !isnan2)
             {             
@@ -3049,8 +3087,11 @@ hsize_t diff_double(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            }
             
             if ( !isnan1 && !isnan2)
             {        
@@ -3108,8 +3149,11 @@ hsize_t diff_double(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            }
             
             if ( !isnan1 && !isnan2)
             {        
@@ -3164,7 +3208,7 @@ hsize_t diff_double(unsigned char *mem1,
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
             
-            if (equal_double(temp1_double,temp2_double)==FALSE)
+            if (equal_double(temp1_double,temp2_double,options)==FALSE)
             {
                 if ( print_data(options) )
                 {
@@ -3221,8 +3265,8 @@ hsize_t diff_ldouble(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
-    int         isnan1;
-    int         isnan2;
+    int         isnan1=0;
+    int         isnan2=0;
     
 
  /*-------------------------------------------------------------------------
@@ -3241,8 +3285,11 @@ hsize_t diff_ldouble(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            }
 
             if ( !isnan1 && !isnan2)
             {             
@@ -3279,8 +3326,11 @@ hsize_t diff_ldouble(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            }
             
             if ( !isnan1 && !isnan2)
             {        
@@ -3338,8 +3388,11 @@ hsize_t diff_ldouble(unsigned char *mem1,
             * detect NaNs
             *-------------------------------------------------------------------------
             */
-            isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            if ( options->do_nans )
+            {
+                isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
+            }
             
             if ( !isnan1 && !isnan2)
             {        
@@ -3394,7 +3447,7 @@ hsize_t diff_ldouble(unsigned char *mem1,
             memcpy(&temp1_double, mem1, sizeof(long double));
             memcpy(&temp2_double, mem2, sizeof(long double));
             
-            if (equal_double(temp1_double,temp2_double)==FALSE)
+            if (equal_double(temp1_double,temp2_double,options)==FALSE)
             {
                 if ( print_data(options) )
                 {
@@ -5167,50 +5220,54 @@ hsize_t diff_ullong(unsigned char *mem1,
  *-------------------------------------------------------------------------
  */
 static 
-hbool_t equal_double(double value, double expected)                               
+hbool_t equal_double(double value, double expected, diff_opt_t *options)                               
 {
     int both_zero;
     int is_zero;
 
-
-/*-------------------------------------------------------------------------
- * detect NaNs
- *-------------------------------------------------------------------------
- */
-    int isnan1 = my_isnan(FLT_DOUBLE,&value);
-    int isnan2 = my_isnan(FLT_DOUBLE,&expected);
-
-   /*-------------------------------------------------------------------------
-    * we consider NaN == NaN to be true 
-    *-------------------------------------------------------------------------
-    */
-    if ( isnan1 && isnan2 )
+    if ( options->do_nans )
     {
-        return TRUE;
-    }
-
-   /*-------------------------------------------------------------------------
-    * one is a NaN, do not compare but assume difference
-    *-------------------------------------------------------------------------
-    */
-    if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
-    {
-        return FALSE;
+        
+        
+        /*-------------------------------------------------------------------------
+        * detect NaNs
+        *-------------------------------------------------------------------------
+        */
+        int isnan1 = my_isnan(FLT_DOUBLE,&value);
+        int isnan2 = my_isnan(FLT_DOUBLE,&expected);
+        
+        /*-------------------------------------------------------------------------
+        * we consider NaN == NaN to be true 
+        *-------------------------------------------------------------------------
+        */
+        if ( isnan1 && isnan2 )
+        {
+            return TRUE;
+        }
+        
+        /*-------------------------------------------------------------------------
+        * one is a NaN, do not compare but assume difference
+        *-------------------------------------------------------------------------
+        */
+        if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
+        {
+            return FALSE;
+        }
+        
+        /*-------------------------------------------------------------------------
+        * both are not NaNs, compare
+        *-------------------------------------------------------------------------
+        */
+        
     }
 
-   /*-------------------------------------------------------------------------
-    * both are not NaNs, compare
-    *-------------------------------------------------------------------------
-    */
-
-
     BOTH_ZERO(value,expected)
     if (both_zero)
         return TRUE;
 
     IS_ZERO(expected)
     if (is_zero)
-        return(equal_double(expected,value));
+        return(equal_double(expected,value,options));
 
     if ( ABS( (value-expected) / expected) < H5DIFF_DBL_EPSILON)
         return TRUE;
@@ -5231,42 +5288,47 @@ hbool_t equal_double(double value, double expected)
 #if H5_SIZEOF_LONG_DOUBLE !=0
 
 static 
-hbool_t equal_ldouble(long double value, long double expected)                               
+hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *options)                               
 {
     int both_zero;
     int is_zero;
 
-
-/*-------------------------------------------------------------------------
- * detect NaNs
- *-------------------------------------------------------------------------
- */
-    int isnan1 = my_isnan(FLT_LDOUBLE,&value);
-    int isnan2 = my_isnan(FLT_LDOUBLE,&expected);
-
-   /*-------------------------------------------------------------------------
-    * we consider NaN == NaN to be true 
-    *-------------------------------------------------------------------------
-    */
-    if ( isnan1 && isnan2 )
-    {
-        return TRUE;
-    }
-
-   /*-------------------------------------------------------------------------
-    * one is a NaN, do not compare but assume difference
-    *-------------------------------------------------------------------------
-    */
-    if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
+    if ( options->do_nans )
     {
-        return FALSE;
+        
+        
+        /*-------------------------------------------------------------------------
+        * detect NaNs
+        *-------------------------------------------------------------------------
+        */
+        int isnan1 = my_isnan(FLT_LDOUBLE,&value);
+        int isnan2 = my_isnan(FLT_LDOUBLE,&expected);
+        
+        /*-------------------------------------------------------------------------
+        * we consider NaN == NaN to be true 
+        *-------------------------------------------------------------------------
+        */
+        if ( isnan1 && isnan2 )
+        {
+            return TRUE;
+        }
+        
+        /*-------------------------------------------------------------------------
+        * one is a NaN, do not compare but assume difference
+        *-------------------------------------------------------------------------
+        */
+        if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
+        {
+            return FALSE;
+        }
+        
+        /*-------------------------------------------------------------------------
+        * both are not NaNs, compare
+        *-------------------------------------------------------------------------
+        */
+        
     }
 
-   /*-------------------------------------------------------------------------
-    * both are not NaNs, compare
-    *-------------------------------------------------------------------------
-    */
-
 
     BOTH_ZERO(value,expected)
     if (both_zero)
@@ -5274,7 +5336,7 @@ hbool_t equal_ldouble(long double value, long double expected)
 
     IS_ZERO(expected)
     if (is_zero)
-        return(equal_ldouble(expected,value));
+        return(equal_ldouble(expected,value,options));
 
     if ( ABS( (value-expected) / expected) < H5DIFF_DBL_EPSILON)
         return TRUE;
@@ -5303,42 +5365,48 @@ hbool_t equal_ldouble(long double value, long double expected)
  *-------------------------------------------------------------------------
  */
 static 
-hbool_t equal_float(float value, float expected)                               
+hbool_t equal_float(float value, float expected, diff_opt_t *options)                               
 {
     int both_zero;
     int is_zero;
-
-
-/*-------------------------------------------------------------------------
- * detect NaNs
- *-------------------------------------------------------------------------
- */
-    int isnan1 = my_isnan(FLT_FLOAT,&value);
-    int isnan2 = my_isnan(FLT_FLOAT,&expected);
-
-   /*-------------------------------------------------------------------------
-    * we consider NaN == NaN to be true 
-    *-------------------------------------------------------------------------
-    */
-    if ( isnan1 && isnan2 )
-    {
-        return TRUE;
-    }
-
-   /*-------------------------------------------------------------------------
-    * one is a NaN, do not compare but assume difference
-    *-------------------------------------------------------------------------
-    */
-    if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
+      
+    
+    if ( options->do_nans )
     {
-        return FALSE;
+        
+        
+        /*-------------------------------------------------------------------------
+        * detect NaNs
+        *-------------------------------------------------------------------------
+        */
+        int isnan1 = my_isnan(FLT_FLOAT,&value);
+        int isnan2 = my_isnan(FLT_FLOAT,&expected);
+        
+        /*-------------------------------------------------------------------------
+        * we consider NaN == NaN to be true 
+        *-------------------------------------------------------------------------
+        */
+        if ( isnan1 && isnan2 )
+        {
+            return TRUE;
+        }
+        
+        /*-------------------------------------------------------------------------
+        * one is a NaN, do not compare but assume difference
+        *-------------------------------------------------------------------------
+        */
+        if ( (isnan1 && !isnan2) || ( !isnan1 && isnan2 ) )
+        {
+            return FALSE;
+        }
+        
+        /*-------------------------------------------------------------------------
+        * both are not NaNs, compare
+        *-------------------------------------------------------------------------
+        */
+        
+        
     }
-
-   /*-------------------------------------------------------------------------
-    * both are not NaNs, compare
-    *-------------------------------------------------------------------------
-    */
-
     
     BOTH_ZERO(value,expected)
     if (both_zero)
@@ -5346,7 +5414,7 @@ hbool_t equal_float(float value, float expected)
 
     IS_ZERO(expected)
     if (is_zero)
-        return(equal_float(expected,value));
+        return(equal_float(expected,value,options));
 
     if ( ABS( (value-expected) / expected) < H5DIFF_FLT_EPSILON)
         return TRUE;