[svn-r14382] bug fix: enable NaN detection for double type

note: RFC at http://www.hdfgroup.uiuc.edu/RFC/HDF5/NaNs_and_HDF5/

tested: windows, linux, solaris

2 files changed, 2249 insertions, 1953 deletions

diff --git a/tools/h5diff/h5diffgentest.c b/tools/h5diff/h5diffgentest.c
index 51e0a83..d1219e8 100644
--- a/tools/h5diff/h5diffgentest.c
+++ b/tools/h5diff/h5diffgentest.c
@@ -249,10 +249,12 @@ int test_basic(const char *fname1,
     
      
    /*-------------------------------------------------------------------------
-    * NaNs in floating point
+    * NaNs in H5T_NATIVE_FLOAT
     *-------------------------------------------------------------------------
     */
     {
+
+#if 1
         float data15[6];
         float data16[6];
 
@@ -272,10 +274,78 @@ int test_basic(const char *fname1,
 
         write_dset(gid1,1,dims1,"fp15",H5T_NATIVE_FLOAT,data15);
         write_dset(gid1,1,dims1,"fp16",H5T_NATIVE_FLOAT,data16);
+#else
+
+#define NU_ELMTS 1000000
+
+        hsize_t i;
+
+        hsize_t dims2[1] = { NU_ELMTS };
+
+        float *data15 = malloc (NU_ELMTS * sizeof(float) );
+        float *data16 = malloc (NU_ELMTS * sizeof(float) );
+
+        data15[0] = (float) sqrt( (double)-1 );
+        data15[1] = 1;
+        data15[2] = (float) sqrt( (double)-1 );
+        data15[3] = 1;
+        data15[4] = 1;
+        data15[5] = 1;
+
+        data16[0] = (float) sqrt( (double)-1 );
+        data16[1] = (float) sqrt( (double)-1 );
+        data16[2] = 1;
+        data16[3] = 1;
+        data16[4] = 1;
+        data16[5] = 1;
+
+        for ( i = 6; i < NU_ELMTS; i++ )
+        {
+            data15[i] = /*data15[0];*/ 2;
+            data16[i] = 1;
+        }
+
+        write_dset(gid1,1,dims2,"fp15",H5T_NATIVE_FLOAT,data15);
+        write_dset(gid1,1,dims2,"fp16",H5T_NATIVE_FLOAT,data16);
 
+        free( data15 );
+        free( data16 );
+#endif
+
+    }
+
+       
         
+   /*-------------------------------------------------------------------------
+    * NaNs in H5T_NATIVE_DOUBLE
+    *-------------------------------------------------------------------------
+    */
+    {
+
+        double data17[6];
+        double data18[6];
+
+        data17[0] = sqrt( (double)-1 );
+        data17[1] = 1;
+        data17[2] = sqrt( (double)-1 );
+        data17[3] = 1;
+        data17[4] = 1;
+        data17[5] = 1;
+
+        data18[0] = (float) sqrt( (double)-1 );
+        data18[1] = (float) sqrt( (double)-1 );
+        data18[2] = 1;
+        data18[3] = 1;
+        data18[4] = 1;
+        data18[5] = 1;
+
+        write_dset(gid1,1,dims1,"fp17",H5T_NATIVE_DOUBLE,data17);
+        write_dset(gid1,1,dims1,"fp18",H5T_NATIVE_DOUBLE,data18);
 
     }
+        
+
+  
     
    /*-------------------------------------------------------------------------
     * close
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index 75b773a..008b6b9 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -21,6 +21,12 @@
 #include <sys/timeb.h>
 #include <time.h>
 
+#if 0
+#define H5DIFF_DO_TIME
+#endif
+#if 1
+#define H5DIFF_DO_NAN
+#endif
 
 /*-------------------------------------------------------------------------
  * printf formatting
@@ -61,8 +67,6 @@
 #define H5DIFF_FLT_EPSILON  .00001
 #define H5DIFF_DBL_EPSILON  .000000001
 
-static hbool_t equal_float(float value, float expected);
-static hbool_t equal_double(double value, double expected);
 
 /*-------------------------------------------------------------------------
  * -p relative error formula
@@ -126,8 +130,13 @@ static hbool_t all_zero(const void *_mem, size_t size);
 static int     ull2float(unsigned long_long ull_value, float *f_value);
 static hsize_t character_compare(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 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);
 
-
+/*-------------------------------------------------------------------------
+ * NaN detection
+ *-------------------------------------------------------------------------
+ */
 typedef enum dtype_t 
 {
     FLT_FLOAT, FLT_DOUBLE,
@@ -154,7 +163,7 @@ static int my_isnan(dtype_t type, void *val);
 static
 int print_data(diff_opt_t *options)
 {
- return ( (options->m_report || options->m_verbose) && !options->m_quiet)?1:0;
+    return ( (options->m_report || options->m_verbose) && !options->m_quiet)?1:0;
 }
 
 /*-------------------------------------------------------------------------
@@ -253,170 +262,135 @@ hsize_t diff_array( void *_mem1,
                     hid_t container1_id,
                     hid_t container2_id) /* dataset where the reference came from*/
 {
- hsize_t       nfound=0;          /* number of differences found */
- size_t        size;              /* size of datum */
- unsigned char *mem1 = (unsigned char*)_mem1;
- unsigned char *mem2 = (unsigned char*)_mem2;
- unsigned char *tmp1;
- unsigned char *tmp2;
- hsize_t       acc[32];    /* accumulator position */
- hsize_t       pos[32];    /* matrix position */
- int           ph=1;       /* print header  */
- hsize_t       i;
- int           j;
-
-
- /* get the size. */
- size = H5Tget_size( m_type );
-
- acc[rank-1]=1;
- for(j=(rank-2); j>=0; j--)
- {
-  acc[j]=acc[j+1]*dims[j+1];
- }
- for ( j = 0; j < rank; j++)
-  pos[j]=0;
-
- if(H5Tis_variable_str(m_type))
- {
-  tmp1 = ((unsigned char**)mem1)[0];
-  tmp2 = ((unsigned char**)mem2)[0];
-  nfound+=diff_datum(
-   tmp1,
-   tmp2,
-   m_type,
-   (hsize_t)0,
-   rank,
-   dims,
-   acc,
-   pos,
-   options,
-   name1,
-   name2,
-   container1_id,
-   container2_id,
-   &ph);
- }
-
- else
- {
-  switch (H5Tget_class(m_type))
-  {
-  default:
-   assert(0);
-   break;
-
- /*-------------------------------------------------------------------------
-  * float and integer atomic types
-  *-------------------------------------------------------------------------
-  */
- 
-  case H5T_FLOAT:
-
-      if (H5Tequal(m_type, H5T_NATIVE_FLOAT))
-      {
-
-#if defined (H5DIFF_DO_TIME)
-          int time;
-
-     #if defined (WIN32)
-          struct _timeb *tbstart = malloc(sizeof(struct _timeb));
-	      struct _timeb *tbstop = malloc(sizeof(struct _timeb));
-          _ftime( tbstart);
-     #else
-          struct timeb *tbstart = malloc(sizeof(struct timeb));
-	      struct timeb *tbstop = malloc(sizeof(struct timeb));
-          ftime( tbstart);
-     #endif
-
-#endif
-          
-         
-          
-          nfound=diff_float(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-
-
-#if defined (H5DIFF_DO_TIME)
-
-      #if defined (WIN32)
-          _ftime( tbstop );
-      #else
-          ftime( tbstop );
-      #endif
-
-          time = tbstop->time - tbstart->time;
-          printf(" TIME = %d\n", time );
-
-#endif
-          
-      }
-   else if (H5Tequal(m_type, H5T_NATIVE_DOUBLE))
-    nfound=diff_double(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   break;
-
-  case H5T_INTEGER:
-
-   if (H5Tequal(m_type, H5T_NATIVE_SCHAR))
-    nfound=diff_schar(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_UCHAR))
-    nfound=diff_uchar(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_SHORT))
-    nfound=diff_short(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_USHORT))
-    nfound=diff_ushort(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_INT))
-    nfound=diff_int(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_UINT))
-    nfound=diff_uint(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_LONG))
-    nfound=diff_long(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_ULONG))
-    nfound=diff_ulong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_LLONG))
-    nfound=diff_llong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-   else if (H5Tequal(m_type, H5T_NATIVE_ULLONG))
-    nfound=diff_ullong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
-
-   break;
-
- /*-------------------------------------------------------------------------
-  * Other types than float and integer
-  *-------------------------------------------------------------------------
-  */
-
-  case H5T_COMPOUND:
-  case H5T_STRING:
-  case H5T_BITFIELD:
-  case H5T_OPAQUE:
-  case H5T_ENUM:
-  case H5T_ARRAY:
-  case H5T_VLEN:
-  case H5T_REFERENCE:
-
-   for ( i = 0; i < nelmts; i++)
-   {
-    nfound+=diff_datum(
-     mem1 + i * size,
-     mem2 + i * size, /* offset */
-     m_type,
-     i,
-     rank,
-     dims,
-     acc,
-     pos,
-     options,
-     name1,
-     name2,
-     container1_id,
-     container2_id,
-     &ph);
-    if (options->n && nfound>=options->count)
-     return nfound;
-   } /* i */
-  } /* switch */
- } /* else */
-
- return nfound;
+    hsize_t       nfound=0;          /* number of differences found */
+    size_t        size;              /* size of datum */
+    unsigned char *mem1 = (unsigned char*)_mem1;
+    unsigned char *mem2 = (unsigned char*)_mem2;
+    unsigned char *tmp1;
+    unsigned char *tmp2;
+    hsize_t       acc[32];    /* accumulator position */
+    hsize_t       pos[32];    /* matrix position */
+    int           ph=1;       /* print header  */
+    hsize_t       i;
+    int           j;
+    
+    
+    /* get the size. */
+    size = H5Tget_size( m_type );
+    
+    acc[rank-1]=1;
+    for(j=(rank-2); j>=0; j--)
+    {
+        acc[j]=acc[j+1]*dims[j+1];
+    }
+    for ( j = 0; j < rank; j++)
+        pos[j]=0;
+    
+    if(H5Tis_variable_str(m_type))
+    {
+        tmp1 = ((unsigned char**)mem1)[0];
+        tmp2 = ((unsigned char**)mem2)[0];
+        nfound+=diff_datum(
+            tmp1,
+            tmp2,
+            m_type,
+            (hsize_t)0,
+            rank,
+            dims,
+            acc,
+            pos,
+            options,
+            name1,
+            name2,
+            container1_id,
+            container2_id,
+            &ph);
+    }
+    
+    else
+    {
+        switch (H5Tget_class(m_type))
+        {
+        default:
+            assert(0);
+            break;
+            
+       /*-------------------------------------------------------------------------
+        * float and integer atomic types
+        *-------------------------------------------------------------------------
+        */
+            
+        case H5T_FLOAT:
+            
+            if (H5Tequal(m_type, H5T_NATIVE_FLOAT))            
+                nfound=diff_float(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_DOUBLE))
+                nfound=diff_double(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            break;
+            
+        case H5T_INTEGER:
+            
+            if (H5Tequal(m_type, H5T_NATIVE_SCHAR))
+                nfound=diff_schar(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_UCHAR))
+                nfound=diff_uchar(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_SHORT))
+                nfound=diff_short(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_USHORT))
+                nfound=diff_ushort(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_INT))
+                nfound=diff_int(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_UINT))
+                nfound=diff_uint(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_LONG))
+                nfound=diff_long(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_ULONG))
+                nfound=diff_ulong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_LLONG))
+                nfound=diff_llong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            else if (H5Tequal(m_type, H5T_NATIVE_ULLONG))
+                nfound=diff_ullong(mem1,mem2,nelmts,hyper_start,rank,dims,acc,pos,options,name1,name2,&ph);
+            
+            break;
+            
+        /*-------------------------------------------------------------------------
+         * Other types than float and integer
+         *-------------------------------------------------------------------------
+         */
+            
+        case H5T_COMPOUND:
+        case H5T_STRING:
+        case H5T_BITFIELD:
+        case H5T_OPAQUE:
+        case H5T_ENUM:
+        case H5T_ARRAY:
+        case H5T_VLEN:
+        case H5T_REFERENCE:
+            
+            for ( i = 0; i < nelmts; i++)
+            {
+                nfound+=diff_datum(
+                    mem1 + i * size,
+                    mem2 + i * size, /* offset */
+                    m_type,
+                    i,
+                    rank,
+                    dims,
+                    acc,
+                    pos,
+                    options,
+                    name1,
+                    name2,
+                    container1_id,
+                    container2_id,
+                    &ph);
+                if (options->n && nfound>=options->count)
+                    return nfound;
+            } /* i */
+        } /* switch */
+    } /* else */
+    
+    return nfound;
 }
 
 /*-------------------------------------------------------------------------
@@ -472,1640 +446,1778 @@ hsize_t diff_datum(void       *_mem1,
                    hid_t      container2_id, /*where the reference came from*/
                    int        *ph)           /*print header */
 {
- unsigned char *mem1 = (unsigned char*)_mem1;
- unsigned char *mem2 = (unsigned char*)_mem2;
- unsigned      u;
- hid_t         memb_type;
- size_t        type_size;
- size_t        offset;
- int           nmembs;
- int           j;
- hsize_t       nelmts;
- size_t        size=0;
- int           iszero1;
- int           iszero2;
- hid_t         obj1_id;
- hid_t         obj2_id;
- hsize_t       nfound=0;   /* differences found */
- int           ret=0;      /* check return error */
- float         f1, f2;
- double        per;
- int           both_zero;
-
- type_size = H5Tget_size( m_type );
-
- switch (H5Tget_class(m_type))
- {
- default:
-  assert(0);
-  break;
- case H5T_TIME:
-  assert(0);
-  break;
-
- /*-------------------------------------------------------------------------
-  * H5T_COMPOUND
-  *-------------------------------------------------------------------------
-  */
- case H5T_COMPOUND:
-  nmembs = H5Tget_nmembers(m_type);
-  for (j = 0; j < nmembs; j++)
-  {
-   offset    = H5Tget_member_offset(m_type, (unsigned)j);
-   memb_type = H5Tget_member_type(m_type, (unsigned)j);
-   nfound+=diff_datum(
-    mem1+offset,
-    mem2+offset,
-    memb_type,
-    i,
-    rank,
-    dims,
-    acc,
-    pos,
-    options,
-    obj1,
-    obj2,
-    container1_id,
-    container2_id,
-    ph);
-   H5Tclose(memb_type);
-  }
-  break;
-
- /*-------------------------------------------------------------------------
-  * H5T_STRING
-  *-------------------------------------------------------------------------
-  */
- case H5T_STRING:
-  {
-
-   H5T_str_t pad;
-   char      *s;
-
-   if(H5Tis_variable_str(m_type))
-   {
-   /* mem1 is the pointer into the struct where a `char*' is stored. So we have
-    * to dereference the pointer to get the `char*' to pass to HDstrlen(). */
-    s = *(char**)mem1;
-    if(s!=NULL)
-     size = HDstrlen(s);
-   }
-   else
-   {
-    s = (char *)mem1;
-    size = H5Tget_size(m_type);
-   }
-
-   pad = H5Tget_strpad(m_type);
-
-   /* check for NULL pointer for string */
-   if(s!=NULL)
-    for (u=0; u<size && (s[u] || pad!=H5T_STR_NULLTERM); u++)
-     nfound+=character_compare(
-     mem1 + u,
-     mem2 + u, /* offset */
-     i,        /* index position */
-     rank,
-     dims,
-     acc,
-     pos,
-     options,
-     obj1,
-     obj2,
-     ph);
-
-  }
-  break;
-
- /*-------------------------------------------------------------------------
-  * H5T_BITFIELD
-  *-------------------------------------------------------------------------
-  */
- case H5T_BITFIELD:
-  {
-   /* byte-by-byte comparison */
-   for (u=0; u<type_size; u++)
-    nfound+=character_compare_opt(
-    mem1 + u,
-    mem2 + u, /* offset */
-    i,        /* index position */
-    rank,
-    dims,
-    acc,
-    pos,
-    options,
-    obj1,
-    obj2,
-    ph);
-
-  }
-  break;
-
- /*-------------------------------------------------------------------------
-  * H5T_OPAQUE
-  *-------------------------------------------------------------------------
-  */
- case H5T_OPAQUE:
-
-  /* byte-by-byte comparison */
-  for (u=0; u<type_size; u++)
-   nfound+=character_compare_opt(
-   mem1 + u,
-   mem2 + u, /* offset */
-   i,        /* index position */
-   rank,
-   dims,
-   acc,
-   pos,
-   options,
-   obj1,
-   obj2,
-   ph);
-
-  break;
+    unsigned char *mem1 = (unsigned char*)_mem1;
+    unsigned char *mem2 = (unsigned char*)_mem2;
+    unsigned      u;
+    hid_t         memb_type;
+    size_t        type_size;
+    size_t        offset;
+    int           nmembs;
+    int           j;
+    hsize_t       nelmts;
+    size_t        size=0;
+    int           iszero1;
+    int           iszero2;
+    hid_t         obj1_id;
+    hid_t         obj2_id;
+    hsize_t       nfound=0;   /* differences found */
+    int           ret=0;      /* check return error */
+    float         f1, f2;
+    double        per;
+    int           both_zero;
+    
+    type_size = H5Tget_size( m_type );
+    
+    switch (H5Tget_class(m_type))
+    {
+    default:
+        assert(0);
+        break;
+    case H5T_TIME:
+        assert(0);
+        break;
+        
+   /*-------------------------------------------------------------------------
+    * H5T_COMPOUND
+    *-------------------------------------------------------------------------
+    */
+    case H5T_COMPOUND:
 
+        nmembs = H5Tget_nmembers(m_type);
 
- /*-------------------------------------------------------------------------
-  * H5T_ENUM
-  *-------------------------------------------------------------------------
-  */
- case H5T_ENUM:
+        for (j = 0; j < nmembs; j++)
+        {
+            offset    = H5Tget_member_offset(m_type, (unsigned)j);
+            memb_type = H5Tget_member_type(m_type, (unsigned)j);
+            nfound+=diff_datum(
+                mem1+offset,
+                mem2+offset,
+                memb_type,
+                i,
+                rank,
+                dims,
+                acc,
+                pos,
+                options,
+                obj1,
+                obj2,
+                container1_id,
+                container2_id,
+                ph);
+            H5Tclose(memb_type);
+        }
+        break;
+        
+   /*-------------------------------------------------------------------------
+    * H5T_STRING
+    *-------------------------------------------------------------------------
+    */
+    case H5T_STRING:
 
- /* For enumeration types we compare the names instead of the
+        {
+            
+            H5T_str_t pad;
+            char      *s;
+            
+            if(H5Tis_variable_str(m_type))
+            {
+               /* mem1 is the pointer into the struct where a `char*' is stored. So we have
+                * to dereference the pointer to get the `char*' to pass to HDstrlen(). */
+                s = *(char**)mem1;
+                if(s!=NULL)
+                    size = HDstrlen(s);
+            }
+            else
+            {
+                s = (char *)mem1;
+                size = H5Tget_size(m_type);
+            }
+            
+            pad = H5Tget_strpad(m_type);
+            
+            /* check for NULL pointer for string */
+            if(s!=NULL)
+            {
+                for (u=0; u<size && (s[u] || pad!=H5T_STR_NULLTERM); u++)
+                    nfound+=character_compare(
+                    mem1 + u,
+                    mem2 + u, /* offset */
+                    i,        /* index position */
+                    rank,
+                    dims,
+                    acc,
+                    pos,
+                    options,
+                    obj1,
+                    obj2,
+                    ph);
+            }
+                
+        }
+        break;
+        
+   /*-------------------------------------------------------------------------
+    * H5T_BITFIELD
+    *-------------------------------------------------------------------------
+    */
+    case H5T_BITFIELD:
+        
+        /* byte-by-byte comparison */
+        for (u=0; u<type_size; u++)
+            nfound+=character_compare_opt(
+            mem1 + u,
+            mem2 + u, /* offset */
+            i,        /* index position */
+            rank,
+            dims,
+            acc,
+            pos,
+            options,
+            obj1,
+            obj2,
+            ph);
+        
+        break;
+        
+    /*-------------------------------------------------------------------------
+     * H5T_OPAQUE
+     *-------------------------------------------------------------------------
+     */
+    case H5T_OPAQUE:
+        
+        /* byte-by-byte comparison */
+        for (u=0; u<type_size; u++)
+            nfound+=character_compare_opt(
+            mem1 + u,
+            mem2 + u, /* offset */
+            i,        /* index position */
+            rank,
+            dims,
+            acc,
+            pos,
+            options,
+            obj1,
+            obj2,
+            ph);
+        
+        break;
+        
+        
+   /*-------------------------------------------------------------------------
+    * H5T_ENUM
+    *-------------------------------------------------------------------------
+    */
+    case H5T_ENUM:
+        
+    /* For enumeration types we compare the names instead of the
     integer values.  For each pair of elements being
     compared, we convert both bit patterns to their corresponding
     enumeration constant and do a string comparison
-  */
-
-  {
-   char enum_name1[1024];
-   char enum_name2[1024];
-
-   /* disable error reporting */
-   H5E_BEGIN_TRY {
-
-    if ((H5Tenum_nameof(m_type, mem1, enum_name1, sizeof enum_name1) >= 0) &&
-     (H5Tenum_nameof(m_type, mem2, enum_name2, sizeof enum_name2) >= 0))
-    {
-     if (HDstrcmp(enum_name1,enum_name2)!=0)
-     {
-      nfound=1;
-      if ( print_data(options) )
-      {
-       print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-       parallel_print(SPACES);
-       parallel_print(S_FORMAT,enum_name1,enum_name2);
-      }
-     }
-     else
-     {
-      for (u=0; u<type_size; u++)
-       nfound+=character_compare_opt(
-       mem1 + u,
-       mem2 + u, /* offset */
-       i,        /* index position */
-       rank,
-       dims,
-       acc,
-       pos,
-       options,
-       obj1,
-       obj2,
-       ph);
-     }
-    }
-    /* enable error reporting */
-   } H5E_END_TRY;
-  }
-
-
-  break;
-
- /*-------------------------------------------------------------------------
-  * H5T_ARRAY
-  *-------------------------------------------------------------------------
-  */
- case H5T_ARRAY:
-     {
-         hsize_t adims[H5S_MAX_RANK];
-         hsize_t       ndims;
-         /* get the array's base datatype for each element */
-         memb_type = H5Tget_super(m_type);
-         size      = H5Tget_size(memb_type);
-         ndims     = H5Tget_array_ndims(m_type);
-         H5Tget_array_dims2(m_type, adims);
-         assert(ndims >= 1 && ndims <= H5S_MAX_RANK);
-         
-         /* calculate the number of array elements */
-         for (u = 0, nelmts = 1; u <ndims; u++)
-             nelmts *= adims[u];
-         for (u = 0; u < nelmts; u++)
-             nfound+=diff_datum(
-             mem1 + u * size,
-             mem2 + u * size, /* offset */
-             memb_type,
-             i,               /* index position */
-             rank,
-             dims,
-             acc,
-             pos,
-             options,
-             obj1,
-             obj2,
-             container1_id,
-             container2_id,
-             ph);
-         H5Tclose(memb_type);
-     }
-  break;
-
- /*-------------------------------------------------------------------------
-  * H5T_VLEN
-  *-------------------------------------------------------------------------
-  */
-
- case H5T_VLEN:
-
-  /* get the VL sequences's base datatype for each element */
-  memb_type = H5Tget_super(m_type);
-  size      = H5Tget_size(memb_type);
-
-  /* get the number of sequence elements */
-  nelmts = ((hvl_t *)mem1)->len;
-
-  for (j = 0; j < (int)nelmts; j++)
-   nfound+=diff_datum(
-   ((char *)(((hvl_t *)mem1)->p)) + j * size,
-   ((char *)(((hvl_t *)mem2)->p)) + j * size, /* offset */
-   memb_type,
-   i,         /* index position */
-   rank,
-   dims,
-   acc,
-   pos,
-   options,
-   obj1,
-   obj2,
-   container1_id,
-   container2_id,
-   ph);
-
-  H5Tclose(memb_type);
-
-  break;
-
-
- case H5T_REFERENCE:
-
-  iszero1=all_zero(_mem1, H5Tget_size(m_type));
-  iszero2=all_zero(_mem2, H5Tget_size(m_type));
-  if (iszero1 != iszero2)
-  {
-   return 1;
-  }
-  else if (!iszero1 && !iszero2)
-  {
- 
- /*-------------------------------------------------------------------------
-  * H5T_STD_REF_DSETREG
-  * Dataset region reference
-  *-------------------------------------------------------------------------
-  */
-
-   if (H5Tequal(m_type, H5T_STD_REF_DSETREG))
-   {
-    hid_t  region1_id;
-    hid_t  region2_id;
-
-    if ((obj1_id = H5Rdereference(container1_id, H5R_DATASET_REGION, _mem1))<0)
-     ret= -1;
-    if ((obj2_id = H5Rdereference(container2_id, H5R_DATASET_REGION, _mem2))<0)
-     ret= -1;
-    if ((region1_id = H5Rget_region(container1_id, H5R_DATASET_REGION, _mem1))<0)
-     ret= -1;
-    if ((region2_id = H5Rget_region(container2_id, H5R_DATASET_REGION, _mem2))<0)
-     ret= -1;
-
-    if (ret==-1) {
-     options->err_stat=1;
-     return 0;
-    }
-
-    nfound = diff_region(obj1_id,obj2_id,region1_id,region2_id,options);
-
-    H5Oclose(obj1_id);
-    H5Oclose(obj2_id);
-    H5Sclose(region1_id);
-    H5Sclose(region2_id);
-
-   }/*dataset reference*/
-
-
- /*-------------------------------------------------------------------------
-  * H5T_STD_REF_OBJ
-  * Object references. get the type and OID of the referenced object
-  *-------------------------------------------------------------------------
-  */
-   else if (H5Tequal(m_type, H5T_STD_REF_OBJ))
-   {
-    H5O_type_t     obj1_type;
-    H5O_type_t     obj2_type;
-
-    if(H5Rget_obj_type2(container1_id, H5R_OBJECT, _mem1, &obj1_type) < 0)
-     ret = -1;
-    if(H5Rget_obj_type2(container2_id, H5R_OBJECT, _mem2, &obj2_type) < 0)
-     ret = -1;
-    if(ret == -1) {
-     options->err_stat = 1;
-     return 0;
-    } /* end if */
-
-    /* check object type */
-    if(obj1_type != obj2_type)
-    {
-     parallel_print("Different object types referenced: <%s> and <%s>", obj1, obj2);
-     options->not_cmp = 1;
-     return 0;
-    }
-
-    if((obj1_id = H5Rdereference(container1_id, H5R_OBJECT, _mem1)) < 0)
-     ret = -1;
-    if((obj2_id = H5Rdereference(container2_id, H5R_OBJECT, _mem2)) < 0)
-     ret = -1;
-    if(ret == -1) {
-     options->err_stat = 1;
-     return 0;
-    } /* end if */
-
-    /* compare */
-    if(obj1_type == H5O_TYPE_DATASET)
-     nfound = diff_datasetid(obj1_id,
-      obj2_id,
-      NULL,
-      NULL,
-      options);
-    else {
-     parallel_print("Warning: Comparison not possible of object types referenced: <%s> and <%s>",
-      obj1, obj2);
-     options->not_cmp = 1;
-    }
-
-    H5Oclose(obj1_id);
-    H5Oclose(obj2_id);
-
-   }/*object reference*/
-
-  }/*is zero*/
-
-
-  break;
-
-
- case H5T_INTEGER:
-
-
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_SCHAR
-  *-------------------------------------------------------------------------
-  */
-  if (H5Tequal(m_type, H5T_NATIVE_SCHAR))
-  {
-      char        temp1_char;
-      char        temp2_char;
-      assert(type_size==sizeof(char));
-      memcpy(&temp1_char, mem1, sizeof(char));
-      memcpy(&temp2_char, mem2, sizeof(char));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if (ABS(temp1_char-temp2_char) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER(temp1_char,temp2_char);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_char,temp2_char,ABS(temp1_char-temp2_char),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER(temp1_char,temp2_char);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && ABS(temp1_char-temp2_char) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_char,temp2_char,ABS(temp1_char-temp2_char),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_char != temp2_char)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
-          }
-          nfound++;
-      }
-      
-  } /*H5T_NATIVE_SCHAR*/
-
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_UCHAR
-  *-------------------------------------------------------------------------
-  */
-  else if (H5Tequal(m_type, H5T_NATIVE_UCHAR))
-  {
-      unsigned char      temp1_uchar;
-      unsigned char      temp2_uchar;
-      assert(type_size==sizeof(unsigned char));
-      
-      memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
-      memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if ( PDIFF(temp1_uchar,temp2_uchar) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_uchar != temp2_uchar)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
-          }
-          nfound++;
-      }
-      
-  } /*H5T_NATIVE_UCHAR*/
-
-
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_SHORT
-  *-------------------------------------------------------------------------
-  */
-
-  else if (H5Tequal(m_type, H5T_NATIVE_SHORT))
-  {
-      short       temp1_short;
-      short       temp2_short;
-      assert(type_size==sizeof(short));
-      
-      memcpy(&temp1_short, mem1, sizeof(short));
-      memcpy(&temp2_short, mem2, sizeof(short));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if (ABS(temp1_short-temp2_short) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER(temp1_short,temp2_short);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_short,temp2_short,ABS(temp1_short-temp2_short),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER(temp1_short,temp2_short);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && ABS(temp1_short-temp2_short) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_short,temp2_short,ABS(temp1_short-temp2_short),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_short != temp2_short)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
-          }
-          nfound++;
-      }
-      
-      
-  } /*H5T_NATIVE_SHORT*/
-
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_USHORT
-  *-------------------------------------------------------------------------
-  */
-
-  else if (H5Tequal(m_type, H5T_NATIVE_USHORT))
-  {
-      unsigned short       temp1_ushort;
-      unsigned short       temp2_ushort;
-      assert(type_size==sizeof(short));
-      
-      memcpy(&temp1_ushort, mem1, sizeof(unsigned short));
-      memcpy(&temp2_ushort, mem2, sizeof(unsigned short));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if ( PDIFF(temp1_ushort,temp2_ushort) > options->delta)
-          {
-              
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,
-                      PDIFF(temp1_ushort,temp2_ushort));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && PDIFF(temp1_ushort,temp2_ushort) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_ushort != temp2_ushort)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
-          }
-          nfound++;
-      }
-  } /*H5T_NATIVE_USHORT*/
-
-
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_INT
-  *-------------------------------------------------------------------------
-  */
-
-  else if (H5Tequal(m_type, H5T_NATIVE_INT))
-  {
-      int         temp1_int;
-      int         temp2_int;
-      assert(type_size==sizeof(int));
-      
-      memcpy(&temp1_int, mem1, sizeof(int));
-      memcpy(&temp2_int, mem2, sizeof(int));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if (ABS(temp1_int-temp2_int) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER(temp1_int,temp2_int);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_int,temp2_int,ABS(temp1_int-temp2_int),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER(temp1_int,temp2_int);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && ABS(temp1_int-temp2_int) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_int,temp2_int,ABS(temp1_int-temp2_int),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_int != temp2_int)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
-          }
-          nfound++;
-      }
-  } /*H5T_NATIVE_INT*/
-
-
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_UINT
-  *-------------------------------------------------------------------------
-  */
-
-  else if (H5Tequal(m_type, H5T_NATIVE_UINT))
-  {
-      unsigned int         temp1_uint;
-      unsigned int         temp2_uint;
-      assert(type_size==sizeof(int));
-      
-      memcpy(&temp1_uint, mem1, sizeof(unsigned int));
-      memcpy(&temp2_uint, mem2, sizeof(unsigned int));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if ( PDIFF(temp1_uint,temp2_uint) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(UI_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER_UNSIGN(signed int,temp1_uint,temp2_uint);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER_UNSIGN(signed int,temp1_uint,temp2_uint);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(I_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && PDIFF(temp1_uint,temp2_uint) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_uint != temp2_uint)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(UI_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
-          }
-          nfound++;
-      }
-  } /*H5T_NATIVE_UINT*/
+        */
+        
+        {
+            char enum_name1[1024];
+            char enum_name2[1024];
+            
+            /* disable error reporting */
+            H5E_BEGIN_TRY {
+                
+                if ((H5Tenum_nameof(m_type, mem1, enum_name1, sizeof enum_name1) >= 0) &&
+                    (H5Tenum_nameof(m_type, mem2, enum_name2, sizeof enum_name2) >= 0))
+                {
+                    if (HDstrcmp(enum_name1,enum_name2)!=0)
+                    {
+                        nfound=1;
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(S_FORMAT,enum_name1,enum_name2);
+                        }
+                    }
+                    else
+                    {
+                        for (u=0; u<type_size; u++)
+                            nfound+=character_compare_opt(
+                            mem1 + u,
+                            mem2 + u, /* offset */
+                            i,        /* index position */
+                            rank,
+                            dims,
+                            acc,
+                            pos,
+                            options,
+                            obj1,
+                            obj2,
+                            ph);
+                    }
+                }
+                /* enable error reporting */
+            } H5E_END_TRY;
+        }
+        
+        
+        break;
+        
+   /*-------------------------------------------------------------------------
+    * H5T_ARRAY
+    *-------------------------------------------------------------------------
+    */
+    case H5T_ARRAY:
 
+        {
+            hsize_t adims[H5S_MAX_RANK];
+            hsize_t       ndims;
+            /* get the array's base datatype for each element */
+            memb_type = H5Tget_super(m_type);
+            size      = H5Tget_size(memb_type);
+            ndims     = H5Tget_array_ndims(m_type);
+            H5Tget_array_dims2(m_type, adims);
+            assert(ndims >= 1 && ndims <= H5S_MAX_RANK);
+            
+            /* calculate the number of array elements */
+            for (u = 0, nelmts = 1; u <ndims; u++)
+                nelmts *= adims[u];
+            for (u = 0; u < nelmts; u++)
+                nfound+=diff_datum(
+                mem1 + u * size,
+                mem2 + u * size, /* offset */
+                memb_type,
+                i,               /* index position */
+                rank,
+                dims,
+                acc,
+                pos,
+                options,
+                obj1,
+                obj2,
+                container1_id,
+                container2_id,
+                ph);
+            H5Tclose(memb_type);
+        }
+        break;
+        
+   
+        
+   /*-------------------------------------------------------------------------
+    * H5T_REFERENCE
+    *-------------------------------------------------------------------------
+    */
+        
+    case H5T_REFERENCE:
+        
+        iszero1=all_zero(_mem1, H5Tget_size(m_type));
+        iszero2=all_zero(_mem2, H5Tget_size(m_type));
+        if (iszero1 != iszero2)
+        {
+            return 1;
+        }
+        else if (!iszero1 && !iszero2)
+        {
+            
+        /*-------------------------------------------------------------------------
+        * H5T_STD_REF_DSETREG
+        * Dataset region reference
+        *-------------------------------------------------------------------------
+            */
+            
+            if (H5Tequal(m_type, H5T_STD_REF_DSETREG))
+            {
+                hid_t  region1_id;
+                hid_t  region2_id;
+                
+                if ((obj1_id = H5Rdereference(container1_id, H5R_DATASET_REGION, _mem1))<0)
+                    ret= -1;
+                if ((obj2_id = H5Rdereference(container2_id, H5R_DATASET_REGION, _mem2))<0)
+                    ret= -1;
+                if ((region1_id = H5Rget_region(container1_id, H5R_DATASET_REGION, _mem1))<0)
+                    ret= -1;
+                if ((region2_id = H5Rget_region(container2_id, H5R_DATASET_REGION, _mem2))<0)
+                    ret= -1;
+                
+                if (ret==-1) {
+                    options->err_stat=1;
+                    return 0;
+                }
+                
+                nfound = diff_region(obj1_id,obj2_id,region1_id,region2_id,options);
+                
+                H5Oclose(obj1_id);
+                H5Oclose(obj2_id);
+                H5Sclose(region1_id);
+                H5Sclose(region2_id);
+                
+            }/*dataset reference*/
+            
+            
+           /*-------------------------------------------------------------------------
+            * H5T_STD_REF_OBJ
+            * Object references. get the type and OID of the referenced object
+            *-------------------------------------------------------------------------
+            */
+            else if (H5Tequal(m_type, H5T_STD_REF_OBJ))
+            {
+                H5O_type_t     obj1_type;
+                H5O_type_t     obj2_type;
+                
+                if(H5Rget_obj_type2(container1_id, H5R_OBJECT, _mem1, &obj1_type) < 0)
+                    ret = -1;
+                if(H5Rget_obj_type2(container2_id, H5R_OBJECT, _mem2, &obj2_type) < 0)
+                    ret = -1;
+                if(ret == -1) {
+                    options->err_stat = 1;
+                    return 0;
+                } /* end if */
+                
+                /* check object type */
+                if(obj1_type != obj2_type)
+                {
+                    parallel_print("Different object types referenced: <%s> and <%s>", obj1, obj2);
+                    options->not_cmp = 1;
+                    return 0;
+                }
+                
+                if((obj1_id = H5Rdereference(container1_id, H5R_OBJECT, _mem1)) < 0)
+                    ret = -1;
+                if((obj2_id = H5Rdereference(container2_id, H5R_OBJECT, _mem2)) < 0)
+                    ret = -1;
+                if(ret == -1) {
+                    options->err_stat = 1;
+                    return 0;
+                } /* end if */
+                
+                /* compare */
+                if(obj1_type == H5O_TYPE_DATASET)
+                    nfound = diff_datasetid(obj1_id,
+                    obj2_id,
+                    NULL,
+                    NULL,
+                    options);
+                else {
+                    parallel_print("Warning: Comparison not possible of object types referenced: <%s> and <%s>",
+                        obj1, obj2);
+                    options->not_cmp = 1;
+                }
+                
+                H5Oclose(obj1_id);
+                H5Oclose(obj2_id);
+                
+            }/*object reference*/
+            
+        }/*is zero*/
+        
+        
+        break;
 
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_LONG
-  *-------------------------------------------------------------------------
-  */
+   /*-------------------------------------------------------------------------
+    * H5T_VLEN
+    *-------------------------------------------------------------------------
+    */
+        
+    case H5T_VLEN:
+        
+        /* get the VL sequences's base datatype for each element */
+        memb_type = H5Tget_super(m_type);
+        size      = H5Tget_size(memb_type);
+        
+        /* get the number of sequence elements */
+        nelmts = ((hvl_t *)mem1)->len;
+        
+        for (j = 0; j < (int)nelmts; j++)
+            nfound+=diff_datum(
+            ((char *)(((hvl_t *)mem1)->p)) + j * size,
+            ((char *)(((hvl_t *)mem2)->p)) + j * size, /* offset */
+            memb_type,
+            i,         /* index position */
+            rank,
+            dims,
+            acc,
+            pos,
+            options,
+            obj1,
+            obj2,
+            container1_id,
+            container2_id,
+            ph);
+        
+        H5Tclose(memb_type);
+        
+        break;
+        
 
-  else if (H5Tequal(m_type, H5T_NATIVE_LONG))
-  {
-      long        temp1_long;
-      long        temp2_long;
-      assert(type_size==sizeof(long));
-      
-      memcpy(&temp1_long, mem1, sizeof(long));
-      memcpy(&temp2_long, mem2, sizeof(long));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if (ABS(temp1_long-temp2_long) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER(temp1_long,temp2_long);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,
-                      ABS(temp1_long-temp2_long));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(LI_FORMAT_P,temp1_long,temp2_long,ABS(temp1_long-temp2_long),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER(temp1_long,temp2_long);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && ABS(temp1_long-temp2_long) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
-                          ABS(temp1_long-temp2_long),
-                          per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_long != temp2_long)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
-          }
-          nfound++;
-      }
-  } /*H5T_NATIVE_LONG*/
+    
+   /*-------------------------------------------------------------------------
+    * H5T_INTEGER
+    *-------------------------------------------------------------------------
+    */        
+        
+    case H5T_INTEGER:
+        
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_SCHAR
+        *-------------------------------------------------------------------------
+        */
+        if (H5Tequal(m_type, H5T_NATIVE_SCHAR))
+        {
+            char        temp1_char;
+            char        temp2_char;
+            assert(type_size==sizeof(char));
+            memcpy(&temp1_char, mem1, sizeof(char));
+            memcpy(&temp2_char, mem2, sizeof(char));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if (ABS(temp1_char-temp2_char) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER(temp1_char,temp2_char);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_char,temp2_char,ABS(temp1_char-temp2_char),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER(temp1_char,temp2_char);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && ABS(temp1_char-temp2_char) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_char,temp2_char,ABS(temp1_char-temp2_char),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_char != temp2_char)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT,temp1_char,temp2_char,ABS(temp1_char-temp2_char));
+                }
+                nfound++;
+            }
+            
+        } /*H5T_NATIVE_SCHAR*/
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_UCHAR
+        *-------------------------------------------------------------------------
+        */
+        else if (H5Tequal(m_type, H5T_NATIVE_UCHAR))
+        {
+            unsigned char      temp1_uchar;
+            unsigned char      temp2_uchar;
+            assert(type_size==sizeof(unsigned char));
+            
+            memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
+            memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if ( PDIFF(temp1_uchar,temp2_uchar) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_uchar != temp2_uchar)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+                }
+                nfound++;
+            }
+            
+        } /*H5T_NATIVE_UCHAR*/
+        
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_SHORT
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_SHORT))
+        {
+            short       temp1_short;
+            short       temp2_short;
+            assert(type_size==sizeof(short));
+            
+            memcpy(&temp1_short, mem1, sizeof(short));
+            memcpy(&temp2_short, mem2, sizeof(short));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if (ABS(temp1_short-temp2_short) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER(temp1_short,temp2_short);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_short,temp2_short,ABS(temp1_short-temp2_short),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER(temp1_short,temp2_short);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && ABS(temp1_short-temp2_short) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_short,temp2_short,ABS(temp1_short-temp2_short),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_short != temp2_short)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT,temp1_short,temp2_short,ABS(temp1_short-temp2_short));
+                }
+                nfound++;
+            }
+            
+            
+        } /*H5T_NATIVE_SHORT*/
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_USHORT
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_USHORT))
+        {
+            unsigned short       temp1_ushort;
+            unsigned short       temp2_ushort;
+            assert(type_size==sizeof(short));
+            
+            memcpy(&temp1_ushort, mem1, sizeof(unsigned short));
+            memcpy(&temp2_ushort, mem2, sizeof(unsigned short));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if ( PDIFF(temp1_ushort,temp2_ushort) > options->delta)
+                {
+                    
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,
+                            PDIFF(temp1_ushort,temp2_ushort));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER_UNSIGN(signed short,temp1_ushort,temp2_ushort);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && PDIFF(temp1_ushort,temp2_ushort) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_ushort != temp2_ushort)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT,temp1_ushort,temp2_ushort,PDIFF(temp1_ushort,temp2_ushort));
+                }
+                nfound++;
+            }
+        } /*H5T_NATIVE_USHORT*/
+        
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_INT
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_INT))
+        {
+            int         temp1_int;
+            int         temp2_int;
+            assert(type_size==sizeof(int));
+            
+            memcpy(&temp1_int, mem1, sizeof(int));
+            memcpy(&temp2_int, mem2, sizeof(int));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if (ABS(temp1_int-temp2_int) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER(temp1_int,temp2_int);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_int,temp2_int,ABS(temp1_int-temp2_int),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER(temp1_int,temp2_int);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && ABS(temp1_int-temp2_int) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_int,temp2_int,ABS(temp1_int-temp2_int),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_int != temp2_int)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(I_FORMAT,temp1_int,temp2_int,ABS(temp1_int-temp2_int));
+                }
+                nfound++;
+            }
+        } /*H5T_NATIVE_INT*/
+        
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_UINT
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_UINT))
+        {
+            unsigned int         temp1_uint;
+            unsigned int         temp2_uint;
+            assert(type_size==sizeof(int));
+            
+            memcpy(&temp1_uint, mem1, sizeof(unsigned int));
+            memcpy(&temp2_uint, mem2, sizeof(unsigned int));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if ( PDIFF(temp1_uint,temp2_uint) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(UI_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER_UNSIGN(signed int,temp1_uint,temp2_uint);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER_UNSIGN(signed int,temp1_uint,temp2_uint);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(I_FORMAT_P_NOTCOMP,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && PDIFF(temp1_uint,temp2_uint) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_uint != temp2_uint)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(UI_FORMAT,temp1_uint,temp2_uint,PDIFF(temp1_uint,temp2_uint));
+                }
+                nfound++;
+            }
+        } /*H5T_NATIVE_UINT*/
+        
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_LONG
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_LONG))
+        {
+            long        temp1_long;
+            long        temp2_long;
+            assert(type_size==sizeof(long));
+            
+            memcpy(&temp1_long, mem1, sizeof(long));
+            memcpy(&temp2_long, mem2, sizeof(long));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if (ABS(temp1_long-temp2_long) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER(temp1_long,temp2_long);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,
+                            ABS(temp1_long-temp2_long));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(LI_FORMAT_P,temp1_long,temp2_long,ABS(temp1_long-temp2_long),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER(temp1_long,temp2_long);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LI_FORMAT_P_NOTCOMP,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && ABS(temp1_long-temp2_long) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+                                ABS(temp1_long-temp2_long),
+                                per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_long != temp2_long)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(LI_FORMAT,temp1_long,temp2_long,ABS(temp1_long-temp2_long));
+                }
+                nfound++;
+            }
+        } /*H5T_NATIVE_LONG*/
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_ULONG
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_ULONG))
+        {
+            unsigned long        temp1_ulong;
+            unsigned long        temp2_ulong;
+            assert(type_size==sizeof(unsigned long));
+            
+            memcpy(&temp1_ulong, mem1, sizeof(unsigned long));
+            memcpy(&temp2_ulong, mem2, sizeof(unsigned long));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if ( PDIFF(temp1_ulong,temp2_ulong) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && PDIFF(temp1_ulong,temp2_ulong) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_ulong != temp2_ulong)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(ULI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
+                }
+                nfound++;
+            }
+            
+            
+        } /*H5T_NATIVE_ULONG*/
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_LLONG
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_LLONG))
+        {
+            long_long        temp1_llong;
+            long_long        temp2_llong;
+            assert(type_size==sizeof(long_long));
+            
+            memcpy(&temp1_llong, mem1, sizeof(long_long));
+            memcpy(&temp2_llong, mem2, sizeof(long_long));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if (ABS(temp1_llong-temp2_llong) > options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                PER(temp1_llong,temp2_llong);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LLI_FORMAT_P_NOTCOMP,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                PER(temp1_llong,temp2_llong);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(LLI_FORMAT_P_NOTCOMP,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent  && ABS(temp1_llong-temp2_llong) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_llong != temp2_llong)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
+                }
+                nfound++;
+            }
+            
+        } /*H5T_NATIVE_LLONG*/
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_ULLONG
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_ULLONG))
+        {
+            unsigned long_long        temp1_ullong;
+            unsigned long_long        temp2_ullong;
+            assert(type_size==sizeof(unsigned long_long));
+            
+            memcpy(&temp1_ullong, mem1, sizeof(unsigned long_long));
+            memcpy(&temp2_ullong, mem2, sizeof(unsigned long_long));
+            /* -d and !-p */
+            if (options->d && !options->p)
+            {
+                if ( PDIFF(temp1_ullong,temp2_ullong) > (unsigned long_long)options->delta)
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                    }
+                    nfound++;
+                }
+            }
+            /* !-d and -p */
+            else if (!options->d && options->p)
+            {
+                ull2float(temp1_ullong,&f1);
+                ull2float(temp2_ullong,&f2);
+                PER(f1,f2);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
+                        }
+                        nfound++;
+                    }
+            }
+            /* -d and -p */
+            else if ( options->d && options->p)
+            {
+                ull2float(temp1_ullong,&f1);
+                ull2float(temp2_ullong,&f2);
+                PER(f1,f2);
+                
+                if (not_comparable && !both_zero) /* not comparable */
+                {
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                    }
+                    options->not_cmp=1;
+                    nfound++;
+                }
+                
+                else
+                    
+                    if ( per > options->percent && PDIFF(temp1_ullong,temp2_ullong) > (unsigned long_long)options->delta )
+                    {
+                        
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            
+                            parallel_print(SPACES);
+                            parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
+                        }
+                        nfound++;
+                    }
+            }
+            else if (temp1_ullong != temp2_ullong)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
+                }
+                nfound++;
+            }
+            
+        } /*H5T_NATIVE_ULLONG*/
+        
+        
+        break; /* H5T_INTEGER class */
 
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_ULONG
-  *-------------------------------------------------------------------------
-  */
+     
+   /*-------------------------------------------------------------------------
+    * H5T_FLOAT
+    *-------------------------------------------------------------------------
+    */
+        
+    case H5T_FLOAT:
+        
+        
+        
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_FLOAT
+        *-------------------------------------------------------------------------
+        */
+        if (H5Tequal(m_type, H5T_NATIVE_FLOAT))
+        {
+            float temp1_float;
+            float temp2_float;
+            int   isnan1;
+            int   isnan2;
 
-  else if (H5Tequal(m_type, H5T_NATIVE_ULONG))
-  {
-      unsigned long        temp1_ulong;
-      unsigned long        temp2_ulong;
-      assert(type_size==sizeof(unsigned long));
-      
-      memcpy(&temp1_ulong, mem1, sizeof(unsigned long));
-      memcpy(&temp2_ulong, mem2, sizeof(unsigned long));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if ( PDIFF(temp1_ulong,temp2_ulong) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(ULI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER_UNSIGN(signed long,temp1_ulong,temp2_ulong);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(ULI_FORMAT_P_NOTCOMP,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && PDIFF(temp1_ulong,temp2_ulong) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_ulong != temp2_ulong)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(ULI_FORMAT,temp1_ulong,temp2_ulong,PDIFF(temp1_ulong,temp2_ulong));
-          }
-          nfound++;
-      }
-      
-      
-  } /*H5T_NATIVE_ULONG*/
+            assert(type_size==sizeof(float));
 
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_LLONG
-  *-------------------------------------------------------------------------
-  */
+            memcpy(&temp1_float, mem1, sizeof(float));
+            memcpy(&temp2_float, mem2, sizeof(float));
 
-  else if (H5Tequal(m_type, H5T_NATIVE_LLONG))
-  {
-      long_long        temp1_llong;
-      long_long        temp2_llong;
-      assert(type_size==sizeof(long_long));
-      
-      memcpy(&temp1_llong, mem1, sizeof(long_long));
-      memcpy(&temp2_llong, mem2, sizeof(long_long));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if (ABS(temp1_llong-temp2_llong) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          PER(temp1_llong,temp2_llong);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(LLI_FORMAT_P_NOTCOMP,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          PER(temp1_llong,temp2_llong);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(LLI_FORMAT_P_NOTCOMP,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent  && ABS(temp1_llong-temp2_llong) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_llong != temp2_llong)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,ABS(temp1_llong-temp2_llong));
-          }
-          nfound++;
-      }
-      
-  } /*H5T_NATIVE_LLONG*/
+            /* logic for detecting NaNs is different with options -d, -p and no options */  
 
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_ULLONG
-  *-------------------------------------------------------------------------
-  */
+           /*-------------------------------------------------------------------------
+            * -d and !-p
+            *-------------------------------------------------------------------------
+            */
+            if (options->d && !options->p)
+            {
+                
+                
+               /*-------------------------------------------------------------------------
+                * detect NaNs
+                *-------------------------------------------------------------------------
+                */
+                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                
+                if ( !isnan1 && !isnan2)
+                {             
+                                    
+                    if (ABS(temp1_float-temp2_float) > options->delta)
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                        }
+                        nfound++;
+                    }
+                    
+                } /* NaN */
+            }
+           /*-------------------------------------------------------------------------
+            * !-d and -p
+            *-------------------------------------------------------------------------
+            */
+            else if (!options->d && options->p)
+            {
+                
+               /*-------------------------------------------------------------------------
+                * detect NaNs
+                *-------------------------------------------------------------------------
+                */
+                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                
+                if ( !isnan1 && !isnan2)
+                {   
+                    
+                    PER(temp1_float,temp2_float);
+                    
+                    if (not_comparable && !both_zero) /* not comparable */
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                        }
+                        options->not_cmp=1;
+                        nfound++;
+                    }
+                    
+                    else
+                        
+                        if ( per > options->percent && ABS(temp1_float-temp2_float) > options->delta )
+                        {
+                            if ( print_data(options) )
+                            {
+                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                                parallel_print(SPACES);
+                                parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+                                    ABS(temp1_float-temp2_float),
+                                    ABS(1-temp2_float/temp1_float));
+                            }
+                            nfound++;
+                        }
+                        
+                } /* NaN */
+            }
 
-  else if (H5Tequal(m_type, H5T_NATIVE_ULLONG))
-  {
-      unsigned long_long        temp1_ullong;
-      unsigned long_long        temp2_ullong;
-      assert(type_size==sizeof(unsigned long_long));
-      
-      memcpy(&temp1_ullong, mem1, sizeof(unsigned long_long));
-      memcpy(&temp2_ullong, mem2, sizeof(unsigned long_long));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if ( PDIFF(temp1_ullong,temp2_ullong) > (unsigned long_long)options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          ull2float(temp1_ullong,&f1);
-          ull2float(temp2_ullong,&f2);
-          PER(f1,f2);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
-                  }
-                  nfound++;
-              }
-      }
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          ull2float(temp1_ullong,&f1);
-          ull2float(temp2_ullong,&f2);
-          PER(f1,f2);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && PDIFF(temp1_ullong,temp2_ullong) > (unsigned long_long)options->delta )
-              {
-                  
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      
-                      parallel_print(SPACES);
-                      parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
-                  }
-                  nfound++;
-              }
-      }
-      else if (temp1_ullong != temp2_ullong)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
-          }
-          nfound++;
-      }
+           /*-------------------------------------------------------------------------
+            * -d and -p
+            *-------------------------------------------------------------------------
+            */
+            
+            else if ( options->d && options->p)
+            {
+                
+               /*-------------------------------------------------------------------------
+                * detect NaNs
+                *-------------------------------------------------------------------------
+                */
+                isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+                isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+                
+                if ( !isnan1 && !isnan2)
+                {   
+                    
+                    PER(temp1_float,temp2_float);
+                    
+                    if (not_comparable && !both_zero) /* not comparable */
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,
+                                ABS(temp1_float-temp2_float));
+                        }
+                        options->not_cmp=1;
+                        nfound++;
+                    }
+                    
+                    else
+                        
+                        if ( per > options->percent )
+                        {
+                            if ( print_data(options) )
+                            {
+                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                                parallel_print(SPACES);
+                                parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+                                    ABS(temp1_float-temp2_float), 
+                                    ABS(1-temp2_float/temp1_float));
+                            }
+                            nfound++;
+                        }
+                        
+                } /* NaN */
+            }
+            
+           /*-------------------------------------------------------------------------
+            * no -d and -p
+            *-------------------------------------------------------------------------
+            */
+            else if (equal_float(temp1_float,temp2_float)==FALSE)
+            {
+                
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                }
+                nfound++;
+            }
+        } /*H5T_NATIVE_FLOAT*/
       
-  } /*H5T_NATIVE_ULLONG*/
+       /*-------------------------------------------------------------------------
+        * H5T_NATIVE_DOUBLE
+        *-------------------------------------------------------------------------
+        */
+        
+        else if (H5Tequal(m_type, H5T_NATIVE_DOUBLE))
+        {
+            double temp1_double;
+            double temp2_double;
+            int    isnan1;
+            int    isnan2;
 
 
-  break; /* H5T_INTEGER class */
+            assert(type_size==sizeof(double));
+            
+            memcpy(&temp1_double, mem1, sizeof(double));
+            memcpy(&temp2_double, mem2, sizeof(double));
 
- case H5T_FLOAT:
+           /* logic for detecting NaNs is different with options -d, -p and no options */  
 
- /*-------------------------------------------------------------------------
-  * H5T_NATIVE_FLOAT
-  *-------------------------------------------------------------------------
-  */
+           /*-------------------------------------------------------------------------
+            * -d and !-p
+            *-------------------------------------------------------------------------
+            */
+            if (options->d && !options->p)
+            {
 
-  if (H5Tequal(m_type, H5T_NATIVE_FLOAT))
-  {
-      float       temp1_float;
-      float       temp2_float;
-      assert(type_size==sizeof(float));
-      memcpy(&temp1_float, mem1, sizeof(float));
-      memcpy(&temp2_float, mem2, sizeof(float));
-      
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if (ABS(temp1_float-temp2_float) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-
-          PER(temp1_float,temp2_float);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && ABS(temp1_float-temp2_float) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(F_FORMAT_P,temp1_float,temp2_float,
-                          ABS(temp1_float-temp2_float),
-                          ABS(1-temp2_float/temp1_float));
-                  }
-                  nfound++;
-              }
-      }
-      
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          
-          PER(temp1_float,temp2_float);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,
-                      ABS(temp1_float-temp2_float));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(F_FORMAT_P,temp1_float,temp2_float,
-                          ABS(temp1_float-temp2_float), 
-                          ABS(1-temp2_float/temp1_float));
-                  }
-                  nfound++;
-              }
-      }
-      
-      else if (equal_float(temp1_float,temp2_float)==FALSE)
-      {
-          
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
-          }
-          nfound++;
-      }
-      
-  } /*H5T_NATIVE_FLOAT*/
-
-  /*-------------------------------------------------------------------------
-   * H5T_NATIVE_DOUBLE
-   *-------------------------------------------------------------------------
-   */
-
-  else if (H5Tequal(m_type, H5T_NATIVE_DOUBLE))
-  {
-      double      temp1_double;
-      double      temp2_double;
-      assert(type_size==sizeof(double));
-      
-      memcpy(&temp1_double, mem1, sizeof(double));
-      memcpy(&temp2_double, mem2, sizeof(double));
-      /* -d and !-p */
-      if (options->d && !options->p)
-      {
-          if (ABS(temp1_double-temp2_double) > options->delta)
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
-              }
-              nfound++;
-          }
-      }
-      /* !-d and -p */
-      else if (!options->d && options->p)
-      {
-          
-          PER(temp1_double,temp2_double);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                      ABS(temp1_double-temp2_double));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                          ABS(temp1_double-temp2_double),
-                          ABS(1-temp2_double/temp1_double));
-                  }
-                  nfound++;
-              }
-      }
-      
-      
-      /* -d and -p */
-      else if ( options->d && options->p)
-      {
-          
-          PER(temp1_double,temp2_double);
-          
-          if (not_comparable && !both_zero) /* not comparable */
-          {
-              if ( print_data(options) )
-              {
-                  print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                  parallel_print(SPACES);
-                  parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                      ABS(temp1_double-temp2_double));
-              }
-              options->not_cmp=1;
-              nfound++;
-          }
-          
-          else
-              
-              if ( per > options->percent && 
-                  ABS(temp1_double-temp2_double) > options->delta )
-              {
-                  if ( print_data(options) )
-                  {
-                      print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-                      parallel_print(SPACES);
-                      parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                          ABS(temp1_double-temp2_double),
-                          ABS(1-temp2_double/temp1_double));
-                  }
-                  nfound++;
-              }
-      }
-      
-      else if (equal_double(temp1_double,temp2_double)==FALSE)
-      {
-          if ( print_data(options) )
-          {
-              print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-              parallel_print(SPACES);
-              parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
-          }
-          nfound++;
-      }
-  } /*H5T_NATIVE_DOUBLE*/
+               /*-------------------------------------------------------------------------
+                * detect NaNs
+                *-------------------------------------------------------------------------
+                */
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                
+                if ( !isnan1 && !isnan2)
+                {           
+                    
+                    if (ABS(temp1_double-temp2_double) > options->delta)
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                        }
+                        nfound++;
+                    }
+                    
+                } /* NaN */
+            }
 
+           /*-------------------------------------------------------------------------
+            * !-d and -p
+            *-------------------------------------------------------------------------
+            */
+            else if (!options->d && options->p)
+            {
 
-  break;   /* H5T_FLOAT class */
+               /*-------------------------------------------------------------------------
+                * detect NaNs
+                *-------------------------------------------------------------------------
+                */
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                
+                if ( !isnan1 && !isnan2)
+                {           
+                    
+                    PER(temp1_double,temp2_double);
+                    
+                    if (not_comparable && !both_zero) /* not comparable */
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                                ABS(temp1_double-temp2_double));
+                        }
+                        options->not_cmp=1;
+                        nfound++;
+                    }
+                    
+                    else
+                        
+                        if ( per > options->percent )
+                        {
+                            if ( print_data(options) )
+                            {
+                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                                parallel_print(SPACES);
+                                parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+                                    ABS(temp1_double-temp2_double),
+                                    ABS(1-temp2_double/temp1_double));
+                            }
+                            nfound++;
+                        }
+                        
+                } /* NaN */
+            }
+            
+           /*-------------------------------------------------------------------------
+            * -d and -p 
+            *-------------------------------------------------------------------------
+            */
+            else if ( options->d && options->p)
+            {
 
+               /*-------------------------------------------------------------------------
+                * detect NaNs
+                *-------------------------------------------------------------------------
+                */
+                isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
+                isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+                
+                if ( !isnan1 && !isnan2)
+                {           
+                    
+                    PER(temp1_double,temp2_double);
+                    
+                    if (not_comparable && !both_zero) /* not comparable */
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                                ABS(temp1_double-temp2_double));
+                        }
+                        options->not_cmp=1;
+                        nfound++;
+                    }
+                    
+                    else
+                        
+                        if ( per > options->percent && 
+                            ABS(temp1_double-temp2_double) > options->delta )
+                        {
+                            if ( print_data(options) )
+                            {
+                                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                                parallel_print(SPACES);
+                                parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+                                    ABS(temp1_double-temp2_double),
+                                    ABS(1-temp2_double/temp1_double));
+                            }
+                            nfound++;
+                        }
+                        
+                } /* NaN */
+            }
+            
+           /*-------------------------------------------------------------------------
+            * no -d and -p 
+            *-------------------------------------------------------------------------
+            */
+            else if (equal_double(temp1_double,temp2_double)==FALSE)
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
+                }
+                nfound++;
+            }
+    } /*H5T_NATIVE_DOUBLE*/
+    
+    
+    break; /* H5T_FLOAT class */
+    
  } /* switch */
-
+ 
  return nfound;
 }
 
@@ -2143,17 +2255,17 @@ static hbool_t all_zero(const void *_mem, size_t size)
 static
 void print_region_block(int i, hsize_t *ptdata, int ndims)
 {
- int j;
-
- parallel_print("        ");
- for (j = 0; j < ndims; j++)
-  parallel_print("%s%lu", j ? "," : "   (",
-  (unsigned long)ptdata[i * 2 * ndims + j]);
- for (j = 0; j < ndims; j++)
-  parallel_print("%s%lu", j ? "," : ")-(",
-  (unsigned long)ptdata[i * 2 * ndims + j + ndims]);
- parallel_print(")");
-
+    int j;
+    
+    parallel_print("        ");
+    for (j = 0; j < ndims; j++)
+        parallel_print("%s%lu", j ? "," : "   (",
+        (unsigned long)ptdata[i * 2 * ndims + j]);
+    for (j = 0; j < ndims; j++)
+        parallel_print("%s%lu", j ? "," : ")-(",
+        (unsigned long)ptdata[i * 2 * ndims + j + ndims]);
+    parallel_print(")");
+    
 }
 
 
@@ -2170,14 +2282,14 @@ void print_region_block(int i, hsize_t *ptdata, int ndims)
 static
 void print_points(int i, hsize_t *ptdata, int ndims)
 {
- int j;
-
- parallel_print("              ");
- for (j = 0; j < ndims; j++)
-  parallel_print("%s%lu", j ? "," : "(",
-  (unsigned long)(ptdata[i * ndims + j]));
- parallel_print(")");
-
+    int j;
+    
+    parallel_print("              ");
+    for (j = 0; j < ndims; j++)
+        parallel_print("%s%lu", j ? "," : "(",
+        (unsigned long)(ptdata[i * ndims + j]));
+    parallel_print(")");
+    
 }
 
 /*-------------------------------------------------------------------------
@@ -2383,25 +2495,25 @@ hsize_t character_compare(unsigned char *mem1,
                   const char    *obj2,
                   int           *ph)
 {
- hsize_t            nfound=0;  /* differences found */
- unsigned char      temp1_uchar;
- unsigned char      temp2_uchar;
-
- memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
- memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
-
- if (temp1_uchar != temp2_uchar)
- {
-  if ( print_data(options) )
-  {
-   print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-   parallel_print(SPACES);
-   parallel_print(C_FORMAT,temp1_uchar,temp2_uchar);
-  }
-  nfound++;
- }
-
- return nfound;
+    hsize_t            nfound=0;  /* differences found */
+    unsigned char      temp1_uchar;
+    unsigned char      temp2_uchar;
+    
+    memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
+    memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
+    
+    if (temp1_uchar != temp2_uchar)
+    {
+        if ( print_data(options) )
+        {
+            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            parallel_print(SPACES);
+            parallel_print(C_FORMAT,temp1_uchar,temp2_uchar);
+        }
+        nfound++;
+    }
+    
+    return nfound;
 }
 
 
@@ -2427,73 +2539,73 @@ hsize_t character_compare_opt(unsigned char *mem1,
                           const char    *obj2,
                           int           *ph)
 {
- hsize_t            nfound=0;  /* differences found */
- unsigned char      temp1_uchar;
- unsigned char      temp2_uchar;
- double             per;
- int                both_zero;
+    hsize_t            nfound=0;  /* differences found */
+    unsigned char      temp1_uchar;
+    unsigned char      temp2_uchar;
+    double             per;
+    int                both_zero;
+    
+    memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
+    memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
+    
+    /* -d and !-p */
+    
+    if (options->d && !options->p)
+    {
+        if ( PDIFF(temp1_uchar,temp2_uchar) > options->delta)
+        {
+            if ( print_data(options) )
+            {
+                print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+                parallel_print(SPACES);
+                parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+            }
+            nfound++;
+        }
+    }
+    /* !-d and -p */
+    else if (!options->d && options->p)
+    {
+        PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
+        if ( per > options->percent )
+        {
+            if ( print_data(options) )
+            {
+                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                parallel_print(SPACES);
+                parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
+            }
+            nfound++;
+        }
+    }
+    /* -d and -p */
+    else if ( options->d && options->p)
+    {
+        PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
+        if ( per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta )
+        {
+            if ( print_data(options) )
+            {
+                print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
+                parallel_print(SPACES);
+                parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
+            }
+            nfound++;
+        }
+    }
+    else if (temp1_uchar != temp2_uchar)
+    {
+        if ( print_data(options) )
+        {
+            print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
+            parallel_print(SPACES);
+            parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
+        }
+        nfound++;
+    }
+    
+    return nfound;
     
- memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
- memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
- 
- /* -d and !-p */
- 
- if (options->d && !options->p)
- {
-     if ( PDIFF(temp1_uchar,temp2_uchar) > options->delta)
-     {
-         if ( print_data(options) )
-         {
-             print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-             parallel_print(SPACES);
-             parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
-         }
-         nfound++;
-     }
- }
- /* !-d and -p */
- else if (!options->d && options->p)
- {
-     PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-     if ( per > options->percent )
-     {
-         if ( print_data(options) )
-         {
-             print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-             parallel_print(SPACES);
-             parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
-         }
-         nfound++;
-     }
- }
- /* -d and -p */
- else if ( options->d && options->p)
- {
-     PER_UNSIGN(signed char,temp1_uchar,temp2_uchar);
-     if ( per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta )
-     {
-         if ( print_data(options) )
-         {
-             print_pos(ph,1,i,acc,pos,rank,dims,obj1,obj2);
-             parallel_print(SPACES);
-             parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar),per);
-         }
-         nfound++;
-     }
- }
- else if (temp1_uchar != temp2_uchar)
- {
-     if ( print_data(options) )
-     {
-         print_pos(ph,0,i,acc,pos,rank,dims,obj1,obj2);
-         parallel_print(SPACES);
-         parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,PDIFF(temp1_uchar,temp2_uchar));
-     }
-     nfound++;
- }
- 
- return nfound;
- 
 }
 
 
@@ -2526,34 +2638,53 @@ hsize_t diff_float(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
+    int         isnan1;
+    int         isnan2;
     
-    
-    /* -d and !-p */
+
+ /*-------------------------------------------------------------------------
+  * -d and !-p 
+  *-------------------------------------------------------------------------
+  */
+ 
     if (options->d && !options->p)
     {
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_float, mem1, sizeof(float));
             memcpy(&temp2_float, mem2, sizeof(float));
-            
-            if (ABS(temp1_float-temp2_float) > options->delta)
-            {
-                if ( print_data(options) )
+
+           /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+            isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
+
+            if ( !isnan1 && !isnan2)
+            {             
+                if (ABS(temp1_float-temp2_float) > options->delta)
                 {
-                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                    parallel_print(SPACES);
-                    parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                    if ( print_data(options) )
+                    {
+                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                        parallel_print(SPACES);
+                        parallel_print(F_FORMAT,temp1_float,temp2_float,ABS(temp1_float-temp2_float));
+                    }
+                    nfound++;
                 }
-                nfound++;
-            }
+            } /* NaN */
             mem1+=sizeof(float);
             mem2+=sizeof(float);
             if (options->n && nfound>=options->count)
                 return nfound;
-        }
+        } /* i */
     }
-    
-    /* !-d and -p */
+
+ /*-------------------------------------------------------------------------
+  * !-d and -p 
+  *-------------------------------------------------------------------------
+  */
     else if (!options->d && options->p)
     {
         for ( i = 0; i < nelmts; i++)
@@ -2561,43 +2692,57 @@ hsize_t diff_float(unsigned char *mem1,
             memcpy(&temp1_float, mem1, sizeof(float));
             memcpy(&temp2_float, mem2, sizeof(float));
             
-            PER(temp1_float,temp2_float);
-            
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                    parallel_print(SPACES);
-                    parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,
-                        ABS(temp1_float-temp2_float));
-                }
-                options->not_cmp=1;
-                nfound++;
-            }
+           /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+            isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
             
-            else
+            if ( !isnan1 && !isnan2)
+            {        
                 
-                if ( per > options->percent )
+                PER(temp1_float,temp2_float);
+                
+                if (not_comparable && !both_zero) /* not comparable */
                 {
                     if ( print_data(options) )
                     {
                         print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P,temp1_float,temp2_float,
-                            ABS(temp1_float-temp2_float),
-                            ABS(1-temp2_float/temp1_float));
+                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,
+                            ABS(temp1_float-temp2_float));
                     }
+                    options->not_cmp=1;
                     nfound++;
                 }
-                mem1+=sizeof(float);
-                mem2+=sizeof(float);
-                if (options->n && nfound>=options->count)
-                    return nfound;
-        }
+                
+                else
+                    
+                    if ( per > options->percent )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+                                ABS(temp1_float-temp2_float),
+                                ABS(1-temp2_float/temp1_float));
+                        }
+                        nfound++;
+                    }
+            } /* NaN */
+            mem1+=sizeof(float);
+            mem2+=sizeof(float);
+            if (options->n && nfound>=options->count)
+                return nfound;
+        } /* i */
     }
     
-    /* -d and -p */
+ /*-------------------------------------------------------------------------
+  * -d and -p 
+  *-------------------------------------------------------------------------
+  */
     else if ( options->d && options->p)
     {
         
@@ -2606,43 +2751,75 @@ hsize_t diff_float(unsigned char *mem1,
             memcpy(&temp1_float, mem1, sizeof(float));
             memcpy(&temp2_float, mem2, sizeof(float));
             
-            PER(temp1_float,temp2_float);
-            
-            if (not_comparable && !both_zero) /* not comparable */
-            {
-                if ( print_data(options) )
-                {
-                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                    parallel_print(SPACES);
-                    parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,
-                        ABS(temp1_float-temp2_float));
-                }
-                options->not_cmp=1;
-                nfound++;
-            }
+            /*-------------------------------------------------------------------------
+            * detect NaNs
+            *-------------------------------------------------------------------------
+            */
+            isnan1 = my_isnan(FLT_FLOAT,&temp1_float);
+            isnan2 = my_isnan(FLT_FLOAT,&temp2_float);
             
-            else
+            if ( !isnan1 && !isnan2)
+            {        
                 
-                if ( per > options->percent && ABS(temp1_float-temp2_float) > options->delta )
+                PER(temp1_float,temp2_float);
+                
+                if (not_comparable && !both_zero) /* not comparable */
                 {
                     if ( print_data(options) )
                     {
                         print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P,temp1_float,temp2_float,
-                            ABS(temp1_float-temp2_float),
-                            ABS(1-temp2_float/temp1_float));
+                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_float,temp2_float,
+                            ABS(temp1_float-temp2_float));
                     }
+                    options->not_cmp=1;
                     nfound++;
                 }
-                mem1+=sizeof(float);
-                mem2+=sizeof(float);
-                if (options->n && nfound>=options->count)
-                    return nfound;
-        }
+                
+                else
+                    
+                    if ( per > options->percent && ABS(temp1_float-temp2_float) > options->delta )
+                    {
+                        if ( print_data(options) )
+                        {
+                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                            parallel_print(SPACES);
+                            parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+                                ABS(temp1_float-temp2_float),
+                                ABS(1-temp2_float/temp1_float));
+                        }
+                        nfound++;
+                    }
+                    
+            } /* NaN */
+            mem1+=sizeof(float);
+            mem2+=sizeof(float);
+            if (options->n && nfound>=options->count)
+                return nfound;
+        } /* i */
     }
+
+ /*-------------------------------------------------------------------------
+  * no -d and -p 
+  *-------------------------------------------------------------------------
+  */
     else
     {
+
+#if defined (H5DIFF_DO_TIME)
+          int time;
+
+     #if defined (WIN32)
+          struct _timeb *tbstart = malloc(sizeof(struct _timeb));
+	      struct _timeb *tbstop = malloc(sizeof(struct _timeb));
+          _ftime( tbstart);
+     #else
+          struct timeb *tbstart = malloc(sizeof(struct timeb));
+	      struct timeb *tbstop = malloc(sizeof(struct timeb));
+          ftime( tbstart);
+     #endif
+
+#endif
         
         for ( i = 0; i < nelmts; i++)
         {
@@ -2665,7 +2842,24 @@ hsize_t diff_float(unsigned char *mem1,
             mem2+=sizeof(float);
             if (options->n && nfound>=options->count)
                 return nfound;
+
         } /* nelmts */
+
+
+
+#if defined (H5DIFF_DO_TIME)
+
+      #if defined (WIN32)
+          _ftime( tbstop );
+      #else
+          ftime( tbstop );
+      #endif
+
+          time = tbstop->time - tbstart->time;
+          printf(" TIME = %d sec\n", time );
+
+#endif
+
         
     }
     
@@ -4705,7 +4899,7 @@ error:
 
 
 /*-------------------------------------------------------------------------
- * Function:    equal_float, equal_double
+ * Function:    equal_double
  *
  * Purpose:     use a relative error formula to deal with floating point 
  *              uncertainty 
@@ -4714,18 +4908,50 @@ error:
  *              October 24, 2006
  *
  * Modifications:
+ *  8/1/2007. handle NaNs
  *
  *-------------------------------------------------------------------------
  */
-
-
-
 static 
 hbool_t equal_double(double value, double expected)                               
 {
     int both_zero;
     int is_zero;
 
+#if defined (H5DIFF_DO_NAN)
+
+/*-------------------------------------------------------------------------
+ * 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
+    *-------------------------------------------------------------------------
+    */
+
+#endif
+
     BOTH_ZERO(value,expected)
     if (both_zero)
         return TRUE;
@@ -4741,8 +4967,6 @@ hbool_t equal_double(double value, double expected)
     
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function:    equal_float
  *
@@ -4763,6 +4987,8 @@ hbool_t equal_float(float value, float expected)
     int both_zero;
     int is_zero;
 
+#if defined (H5DIFF_DO_NAN)
+
 /*-------------------------------------------------------------------------
  * detect NaNs
  *-------------------------------------------------------------------------
@@ -4770,8 +4996,6 @@ hbool_t equal_float(float value, float expected)
     int isnan1 = my_isnan(FLT_FLOAT,&value);
     int isnan2 = my_isnan(FLT_FLOAT,&expected);
 
- 
-
    /*-------------------------------------------------------------------------
     * we consider NaN == NaN to be true 
     *-------------------------------------------------------------------------
@@ -4794,6 +5018,8 @@ hbool_t equal_float(float value, float expected)
     * both are not NaNs, compare
     *-------------------------------------------------------------------------
     */
+
+#endif
     
     BOTH_ZERO(value,expected)
     if (both_zero)