mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-01-30 15:32:37 +08:00
Code Issues Packages Projects Releases Wiki Activity
c37bcc12fc
hdf5/tools/h5diff/h5diff.c
Pedro Vicente Nunes c37bcc12fc [svn-r6771] Purpose: 
added more tests, described in the test matrix

Description:
test -r
test -l
expanded -d, -p and -n tests
test different types to include links and named types
test for non supported classes, e.g bitfield, opaque , etc

Platforms tested:
 Linux 2.4 (rockaway)
 SunOS 5.7 (arabica)
 IRIX 6.5 (modi4)

Misc. update:
2003-04-28 18:56:32 -05:00

2026 lines
48 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <assert.h>
#include "hdf5.h"
#include "h5trav.h"
#define FFORMAT "%-15g %-15g %-15g\n"
#define IFORMAT "%-15d %-15d %-15d\n"
#define LIFORMAT "%-15ld %-15ld %-15d\n"
#define SPACES " "
typedef struct options_t
{
int l_; /* list */
int r_; /* report only what objects differ */
int d_; /* delta difference */
double d_delta; /* delta value */
int p_; /* relative error */
double p_relative; /* relative error value */
int n_; /* count */
int n_number_count; /* value */
} options_t;
/*-------------------------------------------------------------------------
* prototypes
*-------------------------------------------------------------------------
*/
int diff_dataset( hid_t file1_id, hid_t file2_id, const char *obj1_name,
const char *obj2_name, options_t options );
int array_diff( void *buf1, void *buf2, hsize_t tot_cnt, hid_t type_id, int rank,
hsize_t *dims, options_t options, const char *obj1, const char *obj2 );
void print_class( H5T_class_t tclass, char *sclass );
void list( const char *filename, int nobjects, info_t *info );
void diff( hid_t file1_id, const char *obj1_name, hid_t file2_id, const char *obj2_name,
options_t options, int type );
void compare( hid_t file1_id, const char *file1_name, const char *obj1_name,
int nobjects1, info_t *info1,
hid_t file2_id, const char *file2_name, const char *obj2_name,
int nobjects2, info_t *info2,
options_t options );
void match( hid_t file1_id, const char *file1_name, int nobjects1, info_t *info1,
hid_t file2_id, const char *file2_name, int nobjects2, info_t *info2,
options_t options );
void print_pos( int *ph, unsigned int curr_pos, int *acc,
int *pos, int rank, const char *obj1, const char *obj2 );
/*-------------------------------------------------------------------------
* utility functions
*-------------------------------------------------------------------------
*/
hid_t fixtype( hid_t f_type );
void print_datatype(hid_t type);
int check_n_input( const char* );
int check_f_input( const char* );
int get_index( const char *obj, int nobjects, info_t *info );
int compare_object( char *obj1, char *obj2 );
void usage(void);
void leave();
/* diff tst*/
int do_test_files(void);
int write_dataset( hid_t file_id, int rank, hsize_t *dims, const char *dset_name,
hid_t type_id, void *data );
/*-------------------------------------------------------------------------
* Function: usage
*
* Purpose: print a usage message
*
* Return: void
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: April 9, 2003
*
*-------------------------------------------------------------------------
*/
void usage(void)
{
printf("Usage: h5diff [obj1_name] [obj2_name] [OPTIONS] file1_name file2_name\n");
printf("Items in [ ] are optional\n");
printf("[obj1_name] Name of an HDF5 object\n");
printf("[obj2_name] Name of an HDF5 object\n");
printf("file1_name File name of the first HDF5 file\n");
printf("file2_name File name of the second HDF5 file\n");
printf("[OPTIONS] are:\n");
printf("[-h ] Print out this information\n");
printf("[-l ] List contents of file\n");
printf("[-r ] Print only what objects differ\n");
printf("[-n count] Print difference up to count number for each variable\n");
printf("[-d delta] Print difference when it is greater than limit delta\n");
printf("[-p relative] Print differences which are within a relative error value\n");
}
/*-------------------------------------------------------------------------
* Function: leave
*
* Purpose: exit and print newline
*
*-------------------------------------------------------------------------
*/
void leave()
{
exit(EXIT_SUCCESS);
printf("\n");
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: H5diff main program
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: October 8, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int main(int argc, const char *argv[])
{
int i;
const char *s = NULL;
hid_t file1_id, file2_id;
herr_t status;
int nobjects1, nobjects2;
info_t *info1=NULL;
info_t *info2=NULL;
options_t options = {0,0,0,0,0,0,0,0};
void *edata;
hid_t (*func)(void*);
const char *file1_name;
const char *file2_name;
const char *obj1_name = NULL;
const char *obj2_name = NULL;
/*do_test_files();*/
/*-------------------------------------------------------------------------
* print the command line options
*-------------------------------------------------------------------------
*/
printf("$h5diff");
for (i=1; i<argc ; i++)
{
printf(" %s", argv[i] );
}
printf("\n");
/*-------------------------------------------------------------------------
* parse command line options
*-------------------------------------------------------------------------
*/
if (argc < 3) {
printf("Number of arguments is only %d\n", argc );
usage();
leave();
}
/* last 2 items are the file names */
for (i=1; i<argc ; i++)
{
/* get the single-letter switches */
if ( '-'==argv[i][0] )
{
for (s=argv[i]+1; *s; s++)
{
switch (*s) {
default:
printf("-%s is an invalid option\n", s );
usage();
leave();
break;
case 'h':
usage();
leave();
case 'l':
options.l_ = 1;
break;
case 'r':
options.r_ = 1;
break;
case 'd':
/* if it is not another option */
if ( '-' !=argv[i+1][0] )
{
options.d_ = 1;
if ( check_f_input(argv[i+1])==-1)
{
printf("<-d %s> is not a valid option\n", argv[i+1] );
usage();
leave();
}
options.d_delta = atof(argv[i+1]);
}
else
{
printf("<-d %s> is not a valid option\n", argv[i+1] );
usage();
leave();
}
break;
case 'p':
if ( '-' !=argv[i+1][0] )
{
options.p_ = 1;
if ( check_f_input(argv[i+1])==-1)
{
printf("<-p %s> is not a valid option\n", argv[i+1] );
usage();
leave();
}
options.p_relative = atof(argv[i+1]);
}
break;
case 'n':
if ( '-' !=argv[i+1][0] )
{
options.n_ = 1;
if ( check_n_input(argv[i+1])==-1)
{
printf("<-n %s> is not a valid option\n", argv[i+1] );
usage();
leave();
}
options.n_number_count = atoi(argv[i+1]);
}
break;
} /*switch*/
} /*for*/
} /*if*/
else
{
/* 2 last args are the file names, and it is not a -switch parameter */
if ( i < argc-2 && '-' !=argv[i-1][0] )
{
if ( obj1_name == NULL )
obj1_name = argv[i];
if ( obj2_name == NULL )
{
/* check if we have a second object name */
if ( i+1 < argc-2 && '-' !=argv[i+1][0] )
/* yes */
obj2_name = argv[i+1];
else
/* no */
obj2_name = obj1_name;
}
}
}
}/*for*/
/*-------------------------------------------------------------------------
* process the files
*-------------------------------------------------------------------------
*/
file1_name = argv[argc-2];
file2_name = argv[argc-1];
/* disable error reporting */
H5Eget_auto(&func, &edata);
H5Eset_auto(NULL, NULL);
/* Open the files */
if ((file1_id=H5Fopen(file1_name,H5F_ACC_RDONLY,H5P_DEFAULT))<0 )
{
printf("h5diff: %s: No such file or directory\n", file1_name );
leave();
}
if ((file2_id=H5Fopen(file2_name,H5F_ACC_RDONLY,H5P_DEFAULT))<0 )
{
printf("h5diff: %s: No such file or directory\n", file2_name );
leave();
}
/* enable error reporting */
H5Eset_auto(func, edata);
/*-------------------------------------------------------------------------
* get the number of objects in the files
*-------------------------------------------------------------------------
*/
nobjects1 = H5get_object_info( file1_id, NULL );
nobjects2 = H5get_object_info( file2_id, NULL );
/*-------------------------------------------------------------------------
* get the list of objects in the files
*-------------------------------------------------------------------------
*/
info1 = (info_t*) malloc( nobjects1 * sizeof(info_t));
info2 = (info_t*) malloc( nobjects2 * sizeof(info_t));
H5get_object_info( file1_id, info1 );
H5get_object_info( file2_id, info2 );
if ( options.l_ )
{
list ( file1_name, nobjects1, info1 );
list ( file2_name, nobjects2, info2 );
printf("\n");
}
/*-------------------------------------------------------------------------
* object name was supplied
*-------------------------------------------------------------------------
*/
if ( obj1_name )
{
compare(file1_id,file1_name,obj1_name,nobjects1,info1,
file2_id,file2_name,obj2_name,nobjects2,info2,options);
}
/*-------------------------------------------------------------------------
* compare all
*-------------------------------------------------------------------------
*/
else
{
match(file1_id,file1_name,nobjects1,info1,
file2_id,file2_name,nobjects2,info2,options);
}
/* close */
status = H5Fclose(file1_id);
status = H5Fclose(file2_id);
if ( info1 )
free(info1);
if ( info2 )
free(info2);
printf("\n");
return 0;
}
/*-------------------------------------------------------------------------
* Function: check_n_input
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int check_n_input( const char *str )
{
unsigned i;
char c;
for ( i = 0; i < strlen(str); i++)
{
c = str[i];
if ( c < 49 || c > 57 ) /* ascii values between 1 and 9 */
return -1;
}
return 1;
}
/*-------------------------------------------------------------------------
* Function: check_f_input
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int check_f_input( const char *str )
{
unsigned i;
char c;
/* '0' values not allowed */
if ( strlen(str)==1 && str[0]=='0' )
return -1;
for ( i = 0; i < strlen(str); i++)
{
c = str[i];
if ( c < 48 || c > 57 ) /* ascii values between 0 and 9 */
if ( c!= 46) /* . */
return -1;
}
return 1;
}
/*-------------------------------------------------------------------------
* Function: list
*
* Purpose: print list of objects in file
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void list( const char *filename, int nobjects, info_t *info )
{
int i;
printf("File <%s>: # of entries = %d\n", filename, nobjects );
for ( i = 0; i < nobjects; i++)
{
switch ( info[i].type )
{
case H5G_GROUP:
printf("%s %20s\n", info[i].name, "group" );
break;
case H5G_DATASET:
printf("%s %20s\n", info[i].name, "dataset" );
break;
case H5G_TYPE:
printf("%s %20s\n", info[i].name, "datatype" );
break;
case H5G_LINK:
printf("%s %20s\n", info[i].name, "link" );
break;
default:
printf("%s %20s\n", info[i].name, "User defined object" );
break;
}
}
}
/*-------------------------------------------------------------------------
* Function: get_index
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int get_index( const char *obj, int nobjects, info_t *info )
{
char *pdest;
int result;
int i;
for ( i = 0; i < nobjects; i++)
{
if ( strcmp(obj,info[i].name)==0 )
return i;
pdest = strstr( info[i].name, obj );
result = (int)(pdest - info[i].name);
/* found at position 1, meaning without '/' */
if( pdest != NULL && result==1 )
return i;
}
return -1;
}
/*-------------------------------------------------------------------------
* Function: compare
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void compare( hid_t file1_id, const char *file1_name, const char *obj1_name,
int nobjects1, info_t *info1,
hid_t file2_id, const char *file2_name, const char *obj2_name,
int nobjects2, info_t *info2,
options_t options )
{
int f1=0, f2=0;
int i = get_index( obj1_name, nobjects1, info1 );
int j = get_index( obj2_name, nobjects2, info2 );
if ( i == -1 )
{
printf( "Object <%s> could not be found in <%s>\n", obj1_name, file1_name );
f1=1;
}
if ( j == -1 )
{
printf( "Object <%s> could not be found in <%s>\n", obj2_name, file2_name );
f2=1;
}
if ( f1 || f2 )
return;
/* objects are not the same type */
if ( info1[i].type != info2[j].type )
{
printf( "<%s> in <%s> is of different type than <%s> in <%s>\n",
obj1_name, file1_name, obj2_name, file2_name );
return;
}
diff( file1_id, obj1_name, file2_id, obj2_name, options, info1[i].type );
}
/*-------------------------------------------------------------------------
* Function: diff
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void diff( hid_t file1_id, const char *obj1_name, hid_t file2_id, const char *obj2_name,
options_t options, int type )
{
switch ( type )
{
case H5G_DATASET:
diff_dataset(file1_id,file2_id,obj1_name,obj2_name,options);
break;
case H5G_GROUP:
printf( "<%s> and <%s> are of type H5G_GROUP\n", obj1_name, obj2_name );
break;
case H5G_TYPE:
printf( "<%s> and <%s> are of type H5G_TYPE\n", obj1_name, obj2_name );
break;
case H5G_LINK:
printf( "<%s> and <%s> are of type H5G_LINK\n", obj1_name, obj2_name );
break;
default:
printf( "<%s> and <%s> are user defined types\n", obj1_name, obj2_name );
break;
} /* switch */
}
/*-------------------------------------------------------------------------
* Function: compare_object
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int compare_object( char *obj1, char *obj2 )
{
int cmp;
cmp = strcmp(obj1,obj2);
return cmp;
}
/*-------------------------------------------------------------------------
* Function: match
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 10, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void match( hid_t file1_id, const char *file1_name, int nobjects1, info_t *info1,
hid_t file2_id, const char *file2_name, int nobjects2, info_t *info2,
options_t options )
{
int cmp;
int more_names_exist = (nobjects1>0 && nobjects2>0) ? 1 : 0;
int curr1=0;
int curr2=0;
while ( more_names_exist )
{
cmp = compare_object( info1[curr1].name, info2[curr2].name );
if ( cmp == 0 )
{
printf( "<%s> found in <%s> and <%s> found in <%s>\n",
info1[curr1].name, file1_name, info2[curr2].name, file2_name);
/* do the diff */
diff( file1_id, info1[curr1].name, file2_id, info1[curr1].name, options,
info1[curr1].type );
curr1++;
curr2++;
}
else if ( cmp < 0 )
{
printf( "<%s> is in <%s>, but not in <%s>\n", info1[curr1].name,
file1_name, file2_name);
curr1++;
}
else
{
printf( "<%s> is in <%s>, but not in <%s>\n", info2[curr2].name,
file2_name, file1_name);
curr2++;
}
more_names_exist = (curr1<nobjects1 && curr2<nobjects2) ? 1 : 0;
} /* end while */
/* list1 did not end */
if (curr1<nobjects1)
{
while ( curr1<nobjects1 )
{
printf( "<%s> is in <%s>, but not in <%s>\n", info1[curr1].name,
file1_name, file2_name);
curr1++;
}
}
/* list2 did not end */
if (curr2<nobjects2)
{
while ( curr2<nobjects2 )
{
printf( "<%s> is in <%s>, but not in <%s>\n", info2[curr2].name,
file1_name, file2_name);
curr2++;
}
}
}
/*-------------------------------------------------------------------------
* Function: diff_dataset
*
* Purpose:
*
* Return: Success: 0, Failure: -1
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: October 8, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int diff_dataset( hid_t file1_id, hid_t file2_id, const char *obj1_name,
const char *obj2_name, options_t options )
{
hid_t dset1_id, dset2_id;
hid_t space1_id, space2_id;
hid_t type1_id, type2_id;
hid_t rank1, rank2;
void *buf1, *buf2;
hsize_t tot_cnt, tot_cnt1, tot_cnt2;
hsize_t dims1[32], dims2[32], maxdim1[32], maxdim2[32];
int i, j;
herr_t status;
H5T_class_t tclass1;
H5T_class_t tclass2;
char sclass1[20];
char sclass2[20];
int nfound;
hid_t type_mem =-1; /* read to memory type */
void *edata;
hid_t (*func)(void*);
htri_t is1, is2;
/* disable error reporting */
H5Eget_auto(&func, &edata);
H5Eset_auto(NULL, NULL);
/*-------------------------------------------------------------------------
* open the handles
*-------------------------------------------------------------------------
*/
/* Open the datasets */
if ( (dset1_id = H5Dopen(file1_id,obj1_name)) < 0 )
{
printf("Cannot open dataset <%s>\n", obj1_name );
return -1;
}
if ( (dset2_id = H5Dopen(file2_id,obj2_name)) < 0 )
{
printf("Cannot open dataset <%s>\n", obj2_name );
return -1;
}
printf( "Comparing <%s> with <%s>\n", obj1_name, obj2_name );
/* enable error reporting */
H5Eset_auto(func, edata);
/* Get the datatype */
if ( (type1_id = H5Dget_type(dset1_id)) < 0 )
goto out;
/* Get the datatype */
if ( (type2_id = H5Dget_type(dset2_id)) < 0 )
goto out;
/* Get the dataspace handle */
if ( (space1_id = H5Dget_space(dset1_id)) < 0 )
return -1;
/* Get rank */
if ( (rank1 = H5Sget_simple_extent_ndims(space1_id)) < 0 )
return -1;
/* Get the dataspace handle */
if ( (space2_id = H5Dget_space(dset2_id)) < 0 )
return -1;
/* Get rank */
if ( (rank2 = H5Sget_simple_extent_ndims(space2_id)) < 0 )
return -1;
/* Get dimensions */
if ( H5Sget_simple_extent_dims(space1_id,dims1,maxdim1) < 0 )
goto out;
/* Get dimensions */
if ( H5Sget_simple_extent_dims(space2_id,dims2,maxdim2) < 0 )
goto out;
/*-------------------------------------------------------------------------
* check for the same class
*-------------------------------------------------------------------------
*/
if ((tclass1=H5Tget_class(type1_id))<0)
goto out;
if ((tclass2=H5Tget_class(type2_id))<0)
goto out;
if ( tclass1 != tclass2 )
{
print_class( tclass1, sclass1 );
print_class( tclass2, sclass2 );
printf( "<%s> is of class %s and <%s> is of class %s\n",
obj1_name, sclass1, obj2_name, sclass2 );
goto out;
}
/*-------------------------------------------------------------------------
* check for non supported classes
*-------------------------------------------------------------------------
*/
switch (tclass1)
{
case H5T_TIME:
printf( "H5T_TIME comparison is not supported\n");
goto out;
case H5T_STRING:
printf( "H5T_STRING comparison is not supported\n");
goto out;
case H5T_BITFIELD:
printf( "H5T_BITFIELD comparison is not supported\n");
goto out;
case H5T_OPAQUE:
printf( "H5T_OPAQUE comparison is not supported\n");
goto out;
case H5T_COMPOUND:
printf( "H5T_COMPOUND comparison is not supported\n");
goto out;
case H5T_REFERENCE:
printf( "H5T_REFERENCE comparison is not supported\n");
goto out;
case H5T_ENUM:
printf( "H5T_ENUM comparison is not supported\n");
goto out;
case H5T_VLEN:
printf( "H5T_VLEN comparison is not supported\n");
goto out;
case H5T_ARRAY:
printf( "H5T_ARRAY comparison is not supported\n");
goto out;
default:
break;
}
/*-------------------------------------------------------------------------
* check for equal datatype
*-------------------------------------------------------------------------
*/
if ( (H5Tequal(type1_id, type2_id)==0) )
{
printf("Warning: <%s> has different storage datatype than <%s>\n", obj1_name, obj2_name );
printf("<%s> has datatype ", obj1_name);
print_datatype(type1_id);
printf(" and <%s> has datatype ", obj2_name);
print_datatype(type2_id);
printf("\n");
}
/*-------------------------------------------------------------------------
* check for the same rank
*-------------------------------------------------------------------------
*/
if ( rank1 != rank2 )
{
printf( "<%s> is of rank %d and <%s> is of rank %d\n",
obj1_name, rank1, obj2_name, rank2 );
printf( "<%s>: ", obj1_name );
printf("[ " );
for (j = 0; j < rank1; j++)
printf("%d ", (int)dims1[j] );
printf("]\n" );
printf( "<%s>: ", obj2_name );
printf("[ " );
for (j = 0; j < rank1; j++)
printf("%d ", (int)dims2[j] );
printf("]\n" );
goto out;
}
/*-------------------------------------------------------------------------
* check for different maximum dimensions; just give a warning
*-------------------------------------------------------------------------
*/
for (i = 0; i < rank1; i++)
{
if ( maxdim1[i] != maxdim2[i] )
{
printf( "Warning: <%s> has different maximum dimensions than <%s>\n", obj1_name, obj2_name );
printf( "<%s>: ", obj1_name );
printf("[ " );
for (j = 0; j < rank1; j++)
printf("%d ", (int)maxdim1[j] );
printf("]\n" );
printf( "<%s>: ", obj2_name );
printf("[ " );
for (j = 0; j < rank1; j++)
printf("%d ", (int)maxdim2[j] );
printf("]\n" );
}
}
/*-------------------------------------------------------------------------
* check for the same dimensionality
*-------------------------------------------------------------------------
*/
for (i = 0; i < rank1; i++)
{
if ( dims1[i] != dims2[i] )
{
printf( "<%s> has different dimensions than <%s>\n", obj1_name, obj2_name );
printf( "<%s>: ", obj1_name );
printf("[ " );
for (j = 0; j < rank1; j++)
printf("%d ", (int)dims1[j] );
printf("]\n" );
printf( "<%s>: ", obj2_name );
printf("[ " );
for (j = 0; j < rank1; j++)
printf("%d ", (int)dims2[j] );
printf("]\n" );
goto out;
}
}
/*-------------------------------------------------------------------------
* check for simple dataspace
*-------------------------------------------------------------------------
*/
is1 = H5Sis_simple(space1_id);
is2 = H5Sis_simple(space2_id);
tot_cnt1 = 1;
for (i = 0; i < rank1; i++)
{
tot_cnt1 *= dims1[i];
}
tot_cnt2 = 1;
for (i = 0; i < rank2; i++)
{
tot_cnt2 *= dims2[i];
}
buf1 = (void *) malloc((unsigned) (tot_cnt1*H5Tget_size(type1_id)));
buf2 = (void *) malloc((unsigned) (tot_cnt2*H5Tget_size(type2_id)));
if ( buf1 == NULL || buf2 == NULL )
{
printf( "cannot read into memory\n" );
if ( buf1) free((char *) buf1);
if ( buf2) free((char *) buf2);
goto out;
}
/*-------------------------------------------------------------------------
* memory type
*-------------------------------------------------------------------------
*/
type_mem = fixtype( type1_id );
/*-------------------------------------------------------------------------
* read
*-------------------------------------------------------------------------
*/
if ( H5Dread(dset1_id,type_mem,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf1) < 0 )
goto out;
if ( H5Dread(dset2_id,type_mem,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf2) < 0 )
goto out;
if (tot_cnt1 > tot_cnt2)
tot_cnt = tot_cnt2;
else
tot_cnt = tot_cnt1;
nfound = array_diff(buf1,buf2,tot_cnt,type1_id,rank1,dims1,options,obj1_name,obj2_name);
printf("%d differences found\n", nfound );
free((char *) buf1);
free((char *) buf2);
/*-------------------------------------------------------------------------
* close
*-------------------------------------------------------------------------
*/
out:
/* Close */
status = H5Dclose(dset1_id);
status = H5Dclose(dset2_id);
status = H5Sclose(space1_id);
status = H5Sclose(space2_id);
status = H5Tclose(type1_id);
status = H5Tclose(type2_id);
return 0;
}
/*-------------------------------------------------------------------------
* Function: array_diff
*
* Purpose:
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: October 8, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int array_diff( void *buf1, void *buf2, hsize_t tot_cnt, hid_t type_id, int rank,
hsize_t *dims, options_t options, const char *obj1, const char *obj2 )
{
char *i1ptr1, *i1ptr2;
short *i2ptr1, *i2ptr2;
int *i4ptr1, *i4ptr2;
long *i8ptr1, *i8ptr2;
float *fptr1, *fptr2;
double *dptr1, *dptr2;
int nfound=0; /* number of differences found */
int ph=1; /* print header */
int i8diff;
/* accumulator and matrix position */
int acc[32];
int pos[32];
unsigned int i; int j;
H5T_class_t type_class;
size_t type_size;
acc[rank-1]=1;
for(j=(rank-2); j>=0; j--)
{
acc[j]=acc[j+1]*(int)dims[j+1];
}
/* Get the class. */
type_class = H5Tget_class( type_id );
/* Get the size. */
type_size = H5Tget_size( type_id );
switch(type_class)
{
default:
return -1;
case H5T_INTEGER:
switch(type_size)
{
/*-------------------------------------------------------------------------
* H5T_INTEGER 1
*-------------------------------------------------------------------------
*/
case 1:
i1ptr1 = (char *) buf1;
i1ptr2 = (char *) buf2;
for ( i = 0; i < tot_cnt; i++)
{
/* delta but not percentage */
if ( options.d_ && !options.p_ )
{
if ( abs(*i1ptr1 - *i1ptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i1ptr1, *i1ptr2, abs(*i1ptr1 - *i1ptr2));
}
nfound++;
}
}
/* percentage but not delta */
else if ( !options.d_ && options.p_ )
{
if (*i1ptr1!=0)
{
if ( abs(1 - *i1ptr2 / *i1ptr1) > options.p_relative )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i1ptr1, *i1ptr2, abs(*i1ptr1 - *i1ptr2));
}
nfound++;
}
}
}
/* percentage and delta */
else if ( options.d_ && options.p_ )
{
if (*i1ptr1!=0)
{
if ( abs(1 - *i1ptr2 / *i1ptr1) > options.p_relative &&
abs(*i1ptr1 - *i1ptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i1ptr1, *i1ptr2, abs(*i1ptr1 - *i1ptr2));
}
nfound++;
}
}
}
else
if (*i1ptr1 != *i1ptr2)
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i1ptr1, *i1ptr2, abs(*i1ptr1 - *i1ptr2));
}
nfound++;
}
i1ptr1++; i1ptr2++;
}
break;
/*-------------------------------------------------------------------------
* H5T_INTEGER 2
*-------------------------------------------------------------------------
*/
case 2:
i2ptr1 = (short *) buf1;
i2ptr2 = (short *) buf2;
for ( i = 0; i < tot_cnt; i++)
{
/* delta but not percentage */
if ( options.d_ && !options.p_ )
{
if ( abs(*i2ptr1 - *i2ptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i2ptr1, *i2ptr2, abs(*i2ptr1 - *i2ptr2));
}
nfound++;
}
}
/* percentage but not delta */
else if ( !options.d_ && options.p_ )
{
if (*i2ptr1!=0)
{
if ( abs(1 - *i2ptr2 / *i2ptr1) > options.p_relative )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i2ptr1, *i2ptr2, abs(*i2ptr1 - *i2ptr2));
}
nfound++;
}
}
}
/* percentage and delta */
else if ( options.d_ && options.p_ )
{
if (*i2ptr1!=0)
{
if ( abs(1 - *i2ptr2 / *i2ptr1) > options.p_relative &&
abs(*i2ptr1 - *i2ptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i2ptr1, *i2ptr2, abs(*i2ptr1 - *i2ptr2));
}
nfound++;
}
}
}
else
if (*i2ptr1 != *i2ptr2)
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i2ptr1, *i2ptr2, abs(*i2ptr1 - *i2ptr2));
}
nfound++;
}
i2ptr1++; i2ptr2++;
}
break;
/*-------------------------------------------------------------------------
* H5T_INTEGER 4
*-------------------------------------------------------------------------
*/
case 4:
i4ptr1 = (int *) buf1;
i4ptr2 = (int *) buf2;
for ( i = 0; i < tot_cnt; i++)
{
/* delta but not percentage */
if ( options.d_ && !options.p_ )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( abs(*i4ptr1 - *i4ptr2) > options.d_delta )
{
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i4ptr1, *i4ptr2, abs(*i4ptr1 - *i4ptr2));
}
nfound++;
}
}
/* percentage but not delta */
else if ( !options.d_ && options.p_ )
{
if (*i4ptr1!=0)
{
if ( abs(1 - *i4ptr2 / *i4ptr1) > options.p_relative )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i4ptr1, *i4ptr2, abs(*i4ptr1 - *i4ptr2));
}
nfound++;
}
}
}
/* percentage and delta */
else if ( options.d_ && options.p_ )
{
if (*i4ptr1!=0)
{
if ( abs(1 - *i4ptr2 / *i4ptr1) > options.p_relative &&
abs(*i4ptr1 - *i4ptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i4ptr1, *i4ptr2, abs(*i4ptr1 - *i4ptr2));
}
nfound++;
}
}
}
else
if (*i4ptr1 != *i4ptr2)
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(IFORMAT, *i4ptr1, *i4ptr2, abs(*i4ptr1 - *i4ptr2));
}
nfound++;
}
i4ptr1++; i4ptr2++;
} /*for */
break;
/*-------------------------------------------------------------------------
* H5T_INTEGER 8
*-------------------------------------------------------------------------
*/
case 8:
i8ptr1 = (long *) buf1;
i8ptr2 = (long *) buf2;
i8diff = (int)(*i8ptr1 - *i8ptr2);
for ( i = 0; i < tot_cnt; i++)
{
/* delta but not percentage */
if ( options.d_ && !options.p_ )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( abs(i8diff) > options.d_delta )
{
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(LIFORMAT, *i8ptr1, *i8ptr2, i8diff);
}
nfound++;
}
}
/* percentage but not delta */
else if ( !options.d_ && options.p_ )
{
if (*i8ptr1!=0)
{
if ( abs((int)(1 - *i8ptr2 / *i8ptr1)) > options.p_relative )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(LIFORMAT, *i8ptr1, *i8ptr2, i8diff);
}
nfound++;
}
}
}
/* percentage and delta */
else if ( options.d_ && options.p_ )
{
if (*i8ptr1!=0)
{
if ( abs((int)(1 - *i8ptr2 / *i8ptr1)) > options.p_relative &&
abs(i8diff) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(LIFORMAT, *i8ptr1, *i8ptr2, i8diff);
}
nfound++;
}
}
}
else
if (*i8ptr1 != *i8ptr2)
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(LIFORMAT, *i8ptr1, *i8ptr2, i8diff);
}
nfound++;
}
i8ptr1++; i8ptr2++;
} /*for */
break;
default:
printf("no valid H5T_INTEGER size found" );
break;
} /*switch*/
break; /* H5T_INTEGER */
case H5T_FLOAT:
switch(type_size)
{
/*-------------------------------------------------------------------------
* H5T_FLOAT 4
*-------------------------------------------------------------------------
*/
case 4:
fptr1 = (float *) buf1;
fptr2 = (float *) buf2;
for ( i = 0; i < tot_cnt; i++)
{
/* delta but not percentage */
if ( options.d_ && !options.p_ )
{
if ( fabs(*fptr1 - *fptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *fptr1, *fptr2, fabs(*fptr1 - *fptr2));
}
nfound++;
}
}
/* percentage but not delta */
else if ( !options.d_ && options.p_ )
{
if (*fptr1!=0)
{
if ( fabs(1 - *fptr2 / *fptr1) > options.p_relative )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *fptr1, *fptr2, fabs(*fptr1 - *fptr2));
}
nfound++;
}
}
}
/* percentage and delta */
else if ( options.d_ && options.p_ )
{
if (*fptr1!=0)
{
if ( fabs(1 - *fptr2 / *fptr1) > options.p_relative &&
fabs(*fptr1 - *fptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *fptr1, *fptr2, fabs(*fptr1 - *fptr2));
}
nfound++;
}
}
}
else
if (*fptr1 != *fptr2)
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *fptr1, *fptr2, fabs(*fptr1 - *fptr2));
}
nfound++;
}
fptr1++; fptr2++;
}
break;
/*-------------------------------------------------------------------------
* H5T_FLOAT 8
*-------------------------------------------------------------------------
*/
case 8:
dptr1 = (double *) buf1;
dptr2 = (double *) buf2;
for ( i = 0; i < tot_cnt; i++)
{
/* delta but not percentage */
if ( options.d_ && !options.p_ )
{
if ( fabs(*dptr1 - *dptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *dptr1, *dptr2, fabs(*dptr1 - *dptr2));
}
nfound++;
}
}
/* percentage but not delta */
else if ( !options.d_ && options.p_ )
{
if (*dptr1!=0)
{
if ( fabs(1 - *dptr2 / *dptr1) > options.p_relative )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *dptr1, *dptr2, fabs(*dptr1 - *dptr2));
}
nfound++;
}
}
}
/* percentage and delta */
else if ( options.d_ && options.p_ )
{
if (*dptr1!=0)
{
if ( fabs(1 - *dptr2 / *dptr1) > options.p_relative &&
fabs(*dptr1 - *dptr2) > options.d_delta )
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *dptr1, *dptr2, fabs(*dptr1 - *dptr2));
}
nfound++;
}
}
}
else
if (*dptr1 != *dptr2)
{
if ( options.n_ && nfound>=options.n_number_count)
return nfound;
if ( options.r_==0 )
{
print_pos( &ph, i, acc, pos, rank, obj1, obj2 );
printf(SPACES);
printf(FFORMAT, *dptr1, *dptr2, fabs(*dptr1 - *dptr2));
}
nfound++;
}
dptr1++; dptr2++;
}
break;
default:
printf("no valid H5T_FLOAT size found" );
break;
} /*switch*/
break; /* H5T_FLOAT 8 */
} /*switch*/
return nfound;
}
/*-------------------------------------------------------------------------
* Function: print_pos
*
* Purpose: convert an array index position to matrix notation
*
* Return: pos matrix array
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: December 19, 2002
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void print_pos( int *ph, unsigned int curr_pos, int *acc,
int *pos, int rank, const char *obj1, const char *obj2 )
{
int i;
/* print header */
if ( *ph==1 )
{
printf("%-15s %-15s %-15s %-20s\n", "position", obj1, obj2, "difference");
printf("------------------------------------------------------------\n");
*ph=0;
}
for ( i = 0; i < rank; i++)
pos[i]=0;
for ( i = 0; i < rank; i++)
{
pos[i] = curr_pos/acc[i];
curr_pos -= acc[i]*pos[i];
}
assert( curr_pos == 0 );
printf("[ " );
for ( i = 0; i < rank; i++)
{
printf("%d ", pos[i] );
}
printf("]" );
}
/*-------------------------------------------------------------------------
* Function: print_class
*
* Purpose: print the class name
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: February 24, 2003
*
* Comments:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
void print_class( H5T_class_t tclass, char *sclass )
{
switch (tclass)
{
default:
printf("Invalid class");
break;
case H5T_TIME:
strcpy(sclass,"H5T_TIME");
break;
case H5T_INTEGER:
strcpy(sclass,"H5T_INTEGER");
break;
case H5T_FLOAT:
strcpy(sclass,"H5T_FLOAT");
break;
case H5T_STRING:
strcpy(sclass,"H5T_STRING");
break;
case H5T_BITFIELD:
strcpy(sclass,"H5T_BITFIELD");
break;
case H5T_OPAQUE:
strcpy(sclass,"H5T_OPAQUE");
break;
case H5T_COMPOUND:
strcpy(sclass,"H5T_COMPOUND");
break;
case H5T_REFERENCE:
strcpy(sclass,"H5T_REFERENCE");
break;
case H5T_ENUM:
strcpy(sclass,"H5T_ENUM");
break;
case H5T_VLEN:
strcpy(sclass,"H5T_VLEN");
break;
case H5T_ARRAY:
strcpy(sclass,"H5T_ARRAY");
break;
}
}
/*-------------------------------------------------------------------------
* Function: fixtype
*
* Purpose: Given a file data type choose a memory data type which is
* appropriate
*
* Return: Memory data type
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: March 5, 2003
*
* Comments: Adapted from h5tools_fixtype
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
hid_t fixtype(hid_t f_type)
{
hid_t m_type = -1;
size_t size;
size = H5Tget_size(f_type);
switch (H5Tget_class(f_type))
{
default:
return -1;
case H5T_INTEGER:
/*
* Use the smallest native integer type of the same sign as the file
* such that the memory type is at least as large as the file type.
* If there is no memory type large enough then use the largest
* memory type available.
*/
if (size <= sizeof(char)) {
m_type = H5Tcopy(H5T_NATIVE_SCHAR);
printf("using memory type H5T_NATIVE_SCHAR\n");
} else if (size <= sizeof(short)) {
m_type = H5Tcopy(H5T_NATIVE_SHORT);
printf("using memory type H5T_NATIVE_SHORT\n");
} else if (size <= sizeof(int)) {
m_type = H5Tcopy(H5T_NATIVE_INT);
printf("using memory type H5T_NATIVE_INT\n");
} else if (size <= sizeof(long)) {
m_type = H5Tcopy(H5T_NATIVE_LONG);
printf("using memory type H5T_NATIVE_LONG\n");
} else {
m_type = H5Tcopy(H5T_NATIVE_LLONG);
printf("using memory type H5T_NATIVE_LLONG\n");
}
H5Tset_sign(m_type, H5Tget_sign(f_type));
break;
case H5T_FLOAT:
/*
* Use the smallest native floating point type available such that
* its size is at least as large as the file type. If there is not
* native type large enough then use the largest native type.
*/
if (size <= sizeof(float)) {
m_type = H5Tcopy(H5T_NATIVE_FLOAT);
printf("using memory type H5T_NATIVE_FLOAT\n");
} else if (size <= sizeof(double)) {
m_type = H5Tcopy(H5T_NATIVE_DOUBLE);
printf("using memory type H5T_NATIVE_DOUBLE\n");
} else {
m_type = H5Tcopy(H5T_NATIVE_LDOUBLE);
printf("using memory type H5T_NATIVE_LDOUBLE\n");
}
break;
}
return m_type;
}
/*-------------------------------------------------------------------------
* Function: print_datatype
*
* Purpose: Print name of datatype
*
* Return:
*
* Programmer: Pedro Vicente, pvn@ncsa.uiuc.edu
*
* Date: April 17, 2003
*
* Comments: Adapted from h5dump for H5T_INTEGER and H5T_FLOAT classes only
*
*-------------------------------------------------------------------------
*/
void print_datatype(hid_t type)
{
switch (H5Tget_class(type))
{
default:
return;
case H5T_INTEGER:
if (H5Tequal(type, H5T_STD_I8BE)) {
printf("H5T_STD_I8BE");
} else if (H5Tequal(type, H5T_STD_I8LE)) {
printf("H5T_STD_I8LE");
} else if (H5Tequal(type, H5T_STD_I16BE)) {
printf("H5T_STD_I16BE");
} else if (H5Tequal(type, H5T_STD_I16LE)) {
printf("H5T_STD_I16LE");
} else if (H5Tequal(type, H5T_STD_I32BE)) {
printf("H5T_STD_I32BE");
} else if (H5Tequal(type, H5T_STD_I32LE)) {
printf("H5T_STD_I32LE");
} else if (H5Tequal(type, H5T_STD_I64BE)) {
printf("H5T_STD_I64BE");
} else if (H5Tequal(type, H5T_STD_I64LE)) {
printf("H5T_STD_I64LE");
} else if (H5Tequal(type, H5T_STD_U8BE)) {
printf("H5T_STD_U8BE");
} else if (H5Tequal(type, H5T_STD_U8LE)) {
printf("H5T_STD_U8LE");
} else if (H5Tequal(type, H5T_STD_U16BE)) {
printf("H5T_STD_U16BE");
} else if (H5Tequal(type, H5T_STD_U16LE)) {
printf("H5T_STD_U16LE");
} else if (H5Tequal(type, H5T_STD_U32BE)) {
printf("H5T_STD_U32BE");
} else if (H5Tequal(type, H5T_STD_U32LE)) {
printf("H5T_STD_U32LE");
} else if (H5Tequal(type, H5T_STD_U64BE)) {
printf("H5T_STD_U64BE");
} else if (H5Tequal(type, H5T_STD_U64LE)) {
printf("H5T_STD_U64LE");
} else if (H5Tequal(type, H5T_NATIVE_SCHAR)) {
printf("H5T_NATIVE_SCHAR");
} else if (H5Tequal(type, H5T_NATIVE_UCHAR)) {
printf("H5T_NATIVE_UCHAR");
} else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
printf("H5T_NATIVE_SHORT");
} else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
printf("H5T_NATIVE_USHORT");
} else if (H5Tequal(type, H5T_NATIVE_INT)) {
printf("H5T_NATIVE_INT");
} else if (H5Tequal(type, H5T_NATIVE_UINT)) {
printf("H5T_NATIVE_UINT");
} else if (H5Tequal(type, H5T_NATIVE_LONG)) {
printf("H5T_NATIVE_LONG");
} else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
printf("H5T_NATIVE_ULONG");
} else if (H5Tequal(type, H5T_NATIVE_LLONG)) {
printf("H5T_NATIVE_LLONG");
} else if (H5Tequal(type, H5T_NATIVE_ULLONG)) {
printf("H5T_NATIVE_ULLONG");
} else {
printf("undefined integer");
}
break;
case H5T_FLOAT:
if (H5Tequal(type, H5T_IEEE_F32BE)) {
printf("H5T_IEEE_F32BE");
} else if (H5Tequal(type, H5T_IEEE_F32LE)) {
printf("H5T_IEEE_F32LE");
} else if (H5Tequal(type, H5T_IEEE_F64BE)) {
printf("H5T_IEEE_F64BE");
} else if (H5Tequal(type, H5T_IEEE_F64LE)) {
printf("H5T_IEEE_F64LE");
} else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
printf("H5T_NATIVE_FLOAT");
} else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
printf("H5T_NATIVE_DOUBLE");
} else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) {
printf("H5T_NATIVE_LDOUBLE");
} else {
printf("undefined float");
}
break;
}/*switch*/
}
Reference in New Issue View Git Blame Copy Permalink