The HDF Group

HDF User’s Guide

Version 4.2r4


[Top] [Prev][Next]


create_sds.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf"  
#define SDS_NAME      "SDStemplate"  
#define X_LENGTH      5 
#define Y_LENGTH      16 
#define RANK          2  /* Number of dimensions of the SDS */ 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id;     /* SD interface and data set identifiers */ 
   int32 dim_sizes[2];      /* sizes of the SDS dimensions */ 
   intn  status;            /* status returned by some routines; has value 
                               SUCCEED or FAIL */ 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Create the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_CREATE); 
   /* 
   * Define the dimensions of the array to be created. 
   */ 
   dim_sizes[0] = Y_LENGTH; 
   dim_sizes[1] = X_LENGTH; 
   /* 
   * Create the data set with the name defined in SDS_NAME. Note that  
   * DFNT_INT32 indicates that the SDS data is of type int32. Refer to 
   * Table 2E for definitions of other types.  
   */ 
   sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
create_sds.f
      program  create_SDS  
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      character*11 SDS_NAME 
      integer      X_LENGTH, Y_LENGTH, RANK 
      parameter   (FILE_NAME = 'SDS.hdf', 
     +             SDS_NAME = 'SDStemplate', 
     +             X_LENGTH = 5, 
     +             Y_LENGTH = 16, 
     +             RANK     = 2) 
      integer      DFACC_CREATE, DFNT_INT32 
      parameter   (DFACC_CREATE = 4, 
     +             DFNT_INT32 = 24) 
C 
C     Function declaration. 
C 
      integer sfstart, sfcreate, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, dim_sizes(2) 
      integer status 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Create the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_CREATE) 
C 
C     Define dimensions of the array to be created. 
C 
      dim_sizes(1) = X_LENGTH 
      dim_sizes(2) = Y_LENGTH 
C 
C     Create the array with the name defined in SDS_NAME. 
C     Note that DFNT_INT32 indicates that the SDS data is of type 
C     integer. Refer to Tables 2E and 2I for the definition of other types.   
C 
      sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK,  
     .                  dim_sizes) 
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
write_to_sds.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
#define X_LENGTH      5 
#define Y_LENGTH      16 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index; 
   intn  status; 
   int32 start[2], edges[2]; 
   int32 data[Y_LENGTH][X_LENGTH]; 
   int   i, j; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Data set data initialization. 
   */ 
   for (j = 0; j < Y_LENGTH; j++) { 
       for (i = 0; i < X_LENGTH; i++) 
            data[j][i] = (i + j) + 1; 
   } 
   /* 
   * Open the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_WRITE); 
   /* 
   * Attach to the first data set. 
   */  
   sds_index = 0; 
   sds_id = SDselect (sd_id, sds_index); 
   /*  
   * Define the location and size of the data to be written to the data set. 
   */ 
   start[0] = 0; 
   start[1] = 0; 
   edges[0] = Y_LENGTH; 
   edges[1] = X_LENGTH; 
   /* 
   * Write the stored data to the data set. The third argument is set to NULL 
   * to specify contiguous data elements. The last argument must 
   * be explicitly cast to a generic pointer since SDwritedata is designed 
   * to write generic data.  
   */ 
   status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)data); 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
write_to_sds.f
      program  write_data 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      character*11 SDS_NAME 
      integer      X_LENGTH, Y_LENGTH, RANK 
      parameter   (FILE_NAME = 'SDS.hdf', 
     +             SDS_NAME = 'SDStemplate', 
     +             X_LENGTH = 5, 
     +             Y_LENGTH = 16, 
     +             RANK     = 2) 
      integer      DFACC_WRITE, DFNT_INT32 
      parameter   (DFACC_WRITE = 2, 
     +             DFNT_INT32 = 24) 
C 
C     Function declaration. 
C 
      integer sfstart, sfselect, sfwdata, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index, status 
      integer start(2), edges(2), stride(2) 
      integer i, j 
      integer data(X_LENGTH, Y_LENGTH) 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Data set data initialization.  
C 
      do 20 j = 1, Y_LENGTH 
         do 10 i = 1, X_LENGTH 
            data(i, j) = i + j - 1 
10         continue 
20    continue 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_WRITE) 
C 
C     Attach to the first data set. 
C 
      sds_index = 0 
      sds_id = sfselect(sd_id, sds_index) 
C 
C     Define the location and size of the data to be written 
C     to the data set. Note that setting values of the array stride to 1 
C     specifies the contiguous writing of data. 
C 
      start(1) = 0 
      start(2) = 0 
      edges(1) = X_LENGTH 
      edges(2) = Y_LENGTH 
      stride(1) = 1 
      stride(2) = 1 
C 
C     Write the stored data to the data set named in SDS_NAME. 
C     Note that the routine sfwdata is used instead of sfwcdata  
C     to write the numeric data. 
C 
      status = sfwdata(sds_id, start, stride, edges, data) 
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
write_slab.c
#include "mfhdf.h" 
#define FILE_NAME     "SLABS.hdf" 
#define SDS_NAME      "FilledBySlabs" 
#define X_LENGTH      4 
#define Y_LENGTH      5 
#define Z_LENGTH      6 
#define RANK          3   
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id; 
   intn  status; 
   int32 dim_sizes[3], start[3], edges[3]; 
   int32 data[Z_LENGTH][Y_LENGTH][X_LENGTH]; 
   int32 zx_data[Z_LENGTH][X_LENGTH]; 
   int   i, j, k; 
  
   /********************* End of variable declaration ***********************/ 
   /* 
   * Data initialization.  
   */ 
   for (k = 0; k < Z_LENGTH; k++) 
       for (j = 0; j < Y_LENGTH; j++) 
           for (i = 0; i < X_LENGTH; i++) 
               data[k][j][i] = (i + 1) + (j + 1) + (k + 1); 
   /* 
   * Create the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_CREATE); 
   /* 
   * Define dimensions of the array to be created. 
   */ 
   dim_sizes[0] = Z_LENGTH; 
   dim_sizes[1] = Y_LENGTH; 
   dim_sizes[2] = X_LENGTH; 
   /* 
   * Create the array with the name defined in SDS_NAME. 
   */ 
   sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); 
   /* 
   * Set the parameters start and edges to write   
   * a 6x4 element slab of data to the data set; note 
   * that edges[1] is set to 1 to define a 2-dimensional slab 
   * parallel to the ZX plane.   
   * start[1] (slab position in the array) is initialized inside 
   * the for loop. 
   */ 
   edges[0] = Z_LENGTH; 
   edges[1] = 1; 
   edges[2] = X_LENGTH; 
   start[0] = start[2] = 0; 
   for (j = 0; j < Y_LENGTH; j++) 
   { 
       start[1] = j; 
     
       /* 
       * Initialize zx_data buffer (data slab). 
       */  
       for ( k = 0; k < Z_LENGTH; k++) 
       { 
           for ( i = 0; i < X_LENGTH; i++) 
           { 
                 zx_data[k][i] = data[k][j][i]; 
           } 
   } 
   /* 
   * Write the data slab into the SDS array defined in SDS_NAME.  
   * Note that the 3rd parameter is NULL which indicates that consecutive 
   * slabs in the Y direction are written. 
   */ 
   status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)zx_data);  
   } 
   /* 
   * Terminate access to the data set. 
   */  
   status = SDendaccess (sds_id); 
     
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
write_slab.f
      program  write_slab 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*9  FILE_NAME 
      character*13 SDS_NAME 
      integer      X_LENGTH, Y_LENGTH, Z_LENGTH, RANK 
      parameter   (FILE_NAME = 'SLABS.hdf', 
     +             SDS_NAME = 'FilledBySlabs', 
     +             X_LENGTH = 4, 
     +             Y_LENGTH = 5, 
     +             Z_LENGTH = 6, 
     +             RANK     = 3) 
      integer      DFACC_CREATE, DFNT_INT32 
      parameter   (DFACC_CREATE = 4, 
     +             DFNT_INT32 = 24) 
C 
C     Function declaration. 
C 
      integer sfstart, sfcreate, sfwdata, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id 
      integer dim_sizes(3), start(3), edges(3), stride(3) 
      integer i, j, k, status 
      integer data(X_LENGTH, Y_LENGTH, Z_LENGTH) 
      integer xz_data(X_LENGTH, Z_LENGTH) 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Data initialization. 
C 
      do 30 k = 1, Z_LENGTH 
         do 20 j = 1, Y_LENGTH 
            do 10 i = 1, X_LENGTH 
               data(i, j, k) = i + j + k  
10            continue 
20         continue 
30    continue 
C 
C     Create the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_CREATE) 
C 
C     Define dimensions of the array to be created.  
C 
      dim_sizes(1) = X_LENGTH    
      dim_sizes(2) = Y_LENGTH    
      dim_sizes(3) = Z_LENGTH    
C 
C     Create the data set with the name defined in SDS_NAME.  
C 
      sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK,  
     .                  dim_sizes) 
C 
C     Set the parameters start and edges to write  
C     a 4x6 element slab of data to the data set; 
C     note that edges(2) is set to 1 to define a 2 dimensional slab 
C     parallel to the XZ plane; 
C     start(2) (slab position in the array) is initialized inside the 
C     for loop. 
C  
      edges(1) = X_LENGTH 
      edges(2) = 1 
      edges(3) = Z_LENGTH 
      start(1) = 0  
      start(3) = 0 
      stride(1) = 1 
      stride(2) = 1 
      stride(3) = 1 
      do 60 j = 1, Y_LENGTH 
       start(2) = j - 1  
C 
C     Initialize the buffer xz_data (data slab). 
C 
       do 50 k = 1, Z_LENGTH 
        do 40 i = 1, X_LENGTH 
         xz_data(i, k) = data(i, j, k) 
40      continue 
50     continue 
C 
C     Write the data slab into SDS array defined in SDS_NAME.  
C     Note that the elements of array stride are set to 1 to 
C     specify that the consecutive slabs in the Y direction are written. 
C 
         status = sfwdata(sds_id, start, stride, edges, xz_data) 
60    continue 
C 
C     Terminate access to the data set.  
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file.  
C 
      status = sfend(sd_id) 
      end 
alter_sds_values.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index; 
   intn  status; 
   int32 start[2], edges[2]; 
   int32 new_data[2]; 
   int   i, j; 
   /********************* End of variable declaration ***********************/ 
   /*  
   * Open the file and initialize the SD interface with write access. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_WRITE); 
   /* 
   * Select the first data set. 
   */ 
   sds_index = 0; 
   sds_id = SDselect (sd_id, sds_index); 
   /* 
   * Set up the start and edge parameters to write new element values 
   * into 10th row, 2nd column place, and 11th row, 2nd column place.  
   */ 
   start[0] = 9;     /* starting at 10th row   */ 
   start[1] = 1;     /* starting at 2nd column */ 
   edges[0] = 2;     /* rows 10th and 11th     */ 
   edges[1] = 1;     /* column 2nd only        */ 
        
   /* 
   * Initialize buffer with the new values to be written. 
   */ 
   new_data[0] = new_data[1] = 1000;  
         
   /* 
   * Write the new values.  
   */ 
   status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)new_data); 
   /* 
   * Terminate access to the data set. 
   */  
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
alter_sds_values.f
      program  alter_data 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      integer      DFACC_WRITE 
      parameter   (FILE_NAME = 'SDS.hdf', 
     +             DFACC_WRITE = 2) 
C 
C     Function declaration. 
C 
      integer sfstart, sfselect, sfwdata, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index 
      integer start(2), edges(2), stride(2) 
      integer status 
      integer new_data(2)  
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_WRITE) 
C 
C     Select the first data set. 
C      
      sds_index = 0 
      sds_id = sfselect(sd_id, sds_index) 
C 
C     Initialize the start, edge, and stride parameters to write  
C     two elements into 2nd row, 10th column and 11th column places. 
C      
C     Specify 2nd row. 
C 
      start(1) = 1  
C 
C     Specify 10th column. 
C 
      start(2) = 9  
      edges(1) = 1  
C 
C     Two elements are written along 2nd row. 
C 
      edges(2) = 2  
      stride(1) = 1 
      stride(2) = 1 
C 
C     Initialize the new values to be written. 
C 
      new_data(1) = 1000 
      new_data(2) = 1000 
C 
C     Write the new values.  
C 
      status = sfwdata(sds_id, start, stride, edges, new_data) 
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
unlimited_sds.c
#include "mfhdf.h" 
#define FILE_NAME     "SDSUNLIMITED.hdf" 
#define SDS_NAME      "AppendableData" 
#define X_LENGTH      10 
#define Y_LENGTH      10 
#define RANK          2 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index; 
   intn  status; 
   int32 dim_sizes[2]; 
   int32 data[Y_LENGTH][X_LENGTH], append_data[X_LENGTH]; 
   int32 start[2], edges[2]; 
   int   i, j; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Data initialization. 
   */ 
   for (j = 0; j < Y_LENGTH; j++)  
   { 
       for (i = 0; i < X_LENGTH; i++) 
           data[j][i] = (i + 1) + (j + 1); 
   } 
   /* 
   * Create the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_CREATE); 
   /* 
   * Define dimensions of the array. Make the first dimension  
   * appendable by defining its length to be unlimited. 
   */ 
   dim_sizes[0] = SD_UNLIMITED; 
   dim_sizes[1] = X_LENGTH; 
   /* 
   * Create the array data set. 
   */ 
   sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); 
   /* 
   * Define the location and the size of the data to be written  
   * to the data set.  
   */ 
   start[0] = start[1] = 0; 
   edges[0] = Y_LENGTH; 
   edges[1] = X_LENGTH; 
   /* 
   * Write the data.  
   */ 
   status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)data); 
   /* 
   * Terminate access to the array data set, terminate access  
   * to the SD interface, and close the file. 
   */ 
   status = SDendaccess (sds_id); 
   status = SDend (sd_id); 
   /* 
   * Store the array values to be appended to the data set. 
   */ 
   for (i = 0; i < X_LENGTH; i++) 
       append_data[i] = 1000 + i; 
   /* 
   * Reopen the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_WRITE); 
   /* 
   * Select the first data set.  
   */  
   sds_index = 0;  
   sds_id = SDselect (sd_id, sds_index); 
  
   /*   
   * Check if selected SDS is unlimited. If it is not, then terminate access 
   * to the SD interface and close the file.  
   */ 
   if ( SDisrecord (sds_id) )  
   { 
   /* 
   * Define the location of the append to start at the first column  
   * of the 11th row of the data set and to stop at the end of the 
   * eleventh row. 
   */ 
   start[0] = Y_LENGTH; 
   start[1] = 0; 
   edges[0] = 1; 
   edges[1] = X_LENGTH; 
   /* 
   * Append data to the data set. 
   */ 
   status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)append_data); 
   } 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
unlimited_sds.f
      program append_sds 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*16  FILE_NAME 
      character*14  SDS_NAME 
      integer       X_LENGTH, Y_LENGTH, RANK 
      parameter    (FILE_NAME = 'SDSUNLIMITED.hdf', 
     +              SDS_NAME = 'AppendableData', 
     +              X_LENGTH = 10,  
     +              Y_LENGTH = 10, 
     +              RANK     = 2) 
      integer       DFACC_CREATE, DFACC_WRITE, SD_UNLIMITED, 
     +              DFNT_INT32 
      parameter    (DFACC_CREATE = 4, 
     +              DFACC_WRITE  = 2, 
     +              SD_UNLIMITED = 0, 
     +              DFNT_INT32 =   24) 
C 
C     Function declaration. 
C 
      integer sfstart, sfcreate, sfwdata, sfselect  
      integer sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index, status 
      integer dim_sizes(2) 
      integer start(2), edges(2), stride(2) 
      integer i, j 
      integer data (X_LENGTH, Y_LENGTH), append_data(X_LENGTH) 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Data initialization. 
C  
      do 20 j = 1, Y_LENGTH 
         do 10 i = 1, X_LENGTH 
            data(i, j) = i + j 
10      continue 
20    continue 
C 
C     Create the file and initialize the SD interface.  
C 
      sd_id = sfstart(FILE_NAME, DFACC_CREATE) 
C 
C     Define dimensions of the array. Make the 
C     last dimension appendable by defining its length as unlimited. 
C 
      dim_sizes(1) = X_LENGTH 
      dim_sizes(2) = SD_UNLIMITED 
C     Create the array data set.  
      sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK,  
     .                  dim_sizes) 
C 
C     Define the location and the size of the data to be written 
C     to the data set. Note that the elements of array stride are 
C     set to 1 for contiguous writing.     
C 
      start(1) = 0 
      start(2) = 0 
      edges(1) = X_LENGTH 
      edges(2) = Y_LENGTH 
      stride(1) = 1 
      stride(2) = 1 
C 
C     Write the data.  
C 
      status = sfwdata(sds_id, start, stride, edges, data) 
C 
C     Terminate access to the data set, terminate access 
C     to the SD interface, and close the file.  
C 
      status = sfendacc(sds_id) 
      status = sfend(sd_id) 
C 
C     Store the array values to be appended to the data set.  
C 
      do 30 i = 1, X_LENGTH 
         append_data(i) = 1000 + i - 1  
30    continue 
C 
C     Reopen the file and initialize the SD.  
C 
      sd_id = sfstart(FILE_NAME, DFACC_WRITE) 
C 
C     Select the first data set.  
C 
      sds_index = 0  
      sds_id = sfselect(sd_id, sds_index) 
C 
C     Define the location of the append to start at the 11th  
C     column of the 1st row and to stop at the end of the 10th row. 
C 
      start(1) = 0 
      start(2) = Y_LENGTH 
      edges(1) = X_LENGTH 
      edges(2) = 1 
C 
C     Append the data to the data set.  
C 
      status = sfwdata(sds_id, start, stride, edges, append_data) 
C 
C     Terminate access to the data set.  
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file.  
C 
      status = sfend(sd_id) 
      end 
compress_sds.c
#include "mfhdf.h" 
#define FILE_NAME      "SDScompressed.hdf" 
#define SDS_NAME       "SDSgzip" 
#define X_LENGTH       5 
#define Y_LENGTH       16 
#define RANK           2 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32     sd_id, sds_id, sds_index; 
   intn      status; 
   int32     comp_type;    /* Compression flag */ 
   comp_info c_info;   /* Compression structure */ 
   int32     start[2], edges[2], dim_sizes[2]; 
   int32     data[Y_LENGTH][X_LENGTH]; 
   int       i, j; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Buffer array data and define array dimensions. 
   */ 
   for (j = 0; j < Y_LENGTH; j++)  
   { 
	for (i = 0; i < X_LENGTH; i++) 
		data[j][i] = (i + j) + 1; 
   } 
   dim_sizes[0] = Y_LENGTH; 
   dim_sizes[1] = X_LENGTH; 
   /* 
   * Create the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_CREATE); 
   /* 
   * Create the data set with the name defined in SDS_NAME.  
   */  
   sds_id = SDcreate (sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes); 
   /* 
   * Ininitialize compression structure element and compression 
   * flag for GZIP compression and call SDsetcompress. 
   * 
   *   To use the Skipping Huffman compression method, initialize 
   *          comp_type = COMP_CODE_SKPHUFF 
   *          c_info.skphuff.skp_size = value 
   * 
   *   To use the RLE compression method, initialize 
   *          comp_type = COMP_CODE_RLE 
   *   No structure element needs to be initialized. 
   */ 
   comp_type = COMP_CODE_DEFLATE; 
   c_info.deflate.level = 6; 
   status = SDsetcompress (sds_id, comp_type, &c_info);  
   /*  
   * Define the location and size of the data set 
   * to be written to the file. 
   */ 
   start[0] = 0; 
   start[1] = 0; 
   edges[0] = Y_LENGTH; 
   edges[1] = X_LENGTH; 
   /* 
   * Write the stored data to the data set. The last argument  
   * must be explicitly cast to a generic pointer since SDwritedata 
   * is designed to write generic data.  
   */ 
   status = SDwritedata (sds_id, start, NULL, edges, (VOIDP)data); 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
compress_sds.f
      program  write_compressed_data 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*17  FILE_NAME 
      character*7   SDS_NAME 
      integer       X_LENGTH, Y_LENGTH, RANK 
      parameter    (FILE_NAME = 'SDScompressed.hdf', 
     +              SDS_NAME = 'SDSgzip', 
     +              X_LENGTH = 5, 
     +              Y_LENGTH = 16, 
     +              RANK     = 2) 
      integer       DFACC_CREATE, DFNT_INT32 
      parameter    (DFACC_CREATE = 4, 
     +              DFNT_INT32 = 24) 
      integer       COMP_CODE_DEFLATE 
      parameter    (COMP_CODE_DEFLATE = 4) 
      integer       DEFLATE_LEVEL 
      parameter    (DEFLATE_LEVEL = 6) 
C     To use Skipping Huffman compression method, declare  
C            integer   COMP_CODE_SKPHUFF 
C            parameter(COMP_CODE_SKPHUFF = 3)  
C     To use RLE compression method, declare 
C            integer   COMP_CODE_RLE 
C            parameter(COMP_CODE_RLE = 1) 
C 
C 
C     Function declaration. 
C 
      integer sfstart, sfcreate, sfwdata, sfendacc, sfend, 
     +        sfscompress 
C 
C**** Variable declaration ******************************************* 
C 
      integer  sd_id, sds_id, status 
      integer  start(2), edges(2), stride(2), dim_sizes(2) 
      integer  comp_type 
      integer  comp_prm(1) 
      integer  data(X_LENGTH, Y_LENGTH) 
      integer  i, j 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Buffer array data and define array dimensions.  
C 
      do 20 j = 1, Y_LENGTH 
         do 10 i = 1, X_LENGTH 
            data(i, j) = i + j - 1 
10       continue 
20    continue 
      dim_sizes(1) = X_LENGTH 
      dim_sizes(2) = Y_LENGTH 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_CREATE) 
C 
C     Create the data set with the name SDS_NAME.   
C 
      sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT32, RANK, dim_sizes)  
C 
C     Initialize compression parameter (deflate level) 
C     and call sfscompress function 
C     For Skipping Huffman compression, comp_prm(1) should be set 
C     to skipping sizes value (skp_size). 
C  
      comp_type   = COMP_CODE_DEFLATE 
      comp_prm(1) = deflate_level 
      status      = sfscompress(sds_id, comp_type, comp_prm(1)) 
C 
C     Define the location and size of the data that will be written to 
C     the data set. 
C 
      start(1) = 0 
      start(2) = 0 
      edges(1) = X_LENGTH 
      edges(2) = Y_LENGTH 
      stride(1) = 1 
      stride(2) = 1 
C 
C     Write the stored data to the data set. 
C 
      status = sfwdata(sds_id, start, stride, edges, data) 
C 
C     Terminate access to the  data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
mv_sds_to_external.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
#define EXT_FILE_NAME "ExternalSDS" 
#define OFFSET        24 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index, offset; 
   intn  status; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Open the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_WRITE); 
   /* 
   * Select the first data set. 
   */ 
   sds_index = 0;    
   sds_id = SDselect (sd_id, sds_index); 
   /* 
   * Create a file with the name EXT_FILE_NAME and move the data set 
   * values into it, starting at byte location OFFSET. 
   */ 
   status = SDsetexternalfile (sds_id, EXT_FILE_NAME, OFFSET); 
   /* 
   * Terminate access to the data set, SD interface, and file. 
   */ 
   status = SDendaccess (sds_id); 
   status = SDend (sd_id); 
} 
mv_sds_to_external.f
      program  write_extfile 
      implicit none  
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      character*11 EXT_FILE_NAME 
      integer      OFFSET 
      integer      DFACC_WRITE 
      parameter   (FILE_NAME      = 'SDS.hdf', 
     +             EXT_FILE_NAME  = 'ExternalSDS', 
     +             OFFSET         = 24, 
     +             DFACC_WRITE    = 2) 
C 
C     Function declaration. 
C 
      integer sfstart, sfselect, sfsextf, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index, offset 
      integer status 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_WRITE) 
C 
C     Select the first data set. 
C 
      sds_index = 0 
      sds_id = sfselect(sd_id, sds_index) 
C 
C     Create a file with the name EXT_FILE_NAME and move the data set 
C     into it, starting at byte location OFFSET. 
C 
      status = sfsextf(sds_id, EXT_FILE_NAME, OFFSET) 
C 
C     Terminate access to the data set.  
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file.  
C 
      status = sfend(sd_id) 
      end 
read_from_sds.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
#define X_LENGTH      5 
#define Y_LENGTH      16 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index; 
   intn  status; 
   int32 start[2], edges[2]; 
   int32 data[Y_LENGTH][X_LENGTH]; 
   int   i, j; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Open the file for reading and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_READ); 
   /* 
   * Select the first data set. 
   */  
   sds_index = 0; 
   sds_id = SDselect (sd_id, sds_index); 
   /*  
   * Set elements of array start to 0, elements of array edges  
   * to SDS dimensions,and use NULL for the argument stride in SDreaddata 
   * to read the entire data. 
   */ 
   start[0] = 0; 
   start[1] = 0; 
   edges[0] = Y_LENGTH; 
   edges[1] = X_LENGTH; 
   /* 
   * Read entire data into data array. 
   */ 
   status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)data); 
   /*  
   * Print 10th row; the following numbers should be displayed. 
   * 
   *         10 1000 12 13 14 
   */ 
   for (j = 0; j < X_LENGTH; j++) printf ("%d ", data[9][j]); 
   printf ("\n"); 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
read_from_sds.f
      program  read_data 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      integer      X_LENGTH, Y_LENGTH 
      parameter   (FILE_NAME  = 'SDS.hdf', 
     +             X_LENGTH = 5,  
     +             Y_LENGTH = 16) 
      integer      DFACC_READ, DFNT_INT32 
      parameter   (DFACC_READ = 1, 
     +             DFNT_INT32 = 24) 
C 
C     Function declaration. 
C 
      integer sfstart, sfselect, sfrdata, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index, status 
      integer start(2), edges(2), stride(2) 
      integer data(X_LENGTH, Y_LENGTH) 
      integer j 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_READ) 
C 
C     Select the first data set. 
C 
      sds_index = 0 
      sds_id = sfselect(sd_id, sds_index) 
C 
C     Set elements of the array start to 0, elements of the array edges to  
C     SDS dimensions, and elements of the array stride to 1 to read the 
C     entire data.  
C 
      start(1) = 0 
      start(2) = 0 
      edges(1) = X_LENGTH 
      edges(2) = Y_LENGTH 
      stride(1) = 1 
      stride(2) = 1 
C 
C     Read entire data into data array. Note that sfrdata is used 
C     to read the numeric data.  
C 
      status = sfrdata(sds_id, start, stride, edges, data) 
       
C 
C     Print 10th column; the following numbers are displayed: 
C 
C           10 1000 12 13 14 
C 
      write(*,*) (data(j,10), j = 1, X_LENGTH) 
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
read_subsets.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
#define SUB1_LENGTH   5 
#define SUB2_LENGTH   4 
#define SUB3_LENGTH1  2  
#define SUB3_LENGTH2  3  
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index; 
   intn  status; 
   int32 start[2], edges[2], stride[2]; 
   int32 sub1_data[SUB1_LENGTH]; 
   int32 sub2_data[SUB2_LENGTH]; 
   int32 sub3_data[SUB3_LENGTH2][SUB3_LENGTH1]; 
   int   i, j; 
   /********************* End of variable declaration ***********************/ 
         
   /* 
   * Open the file for reading and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_READ); 
   /* 
   * Select the first data set. 
   */  
   sds_index = 0; 
   sds_id = SDselect (sd_id, sds_index); 
   /* 
   *         Reading the first subset. 
   * 
   * Set elements of start, edges, and stride arrays to read 
   * every 3rd element in the 2nd column starting at 4th row.    
   */ 
   start[0] = 3;   /* 4th row */ 
   start[1] = 1;   /* 2nd column */ 
   edges[0] = SUB1_LENGTH; /* SUB1_LENGTH elements are read along 2nd column*/ 
   edges[1] = 1; 
   stride[0] = 3;  /* every 3rd element is read along 2nd column */ 
   stride[1] = 1; 
   /* 
   * Read the data from the file into sub1_data array. 
   */ 
   status = SDreaddata (sds_id, start, stride, edges, (VOIDP)sub1_data); 
   /*  
   * Print what we have just read; the following numbers should be displayed: 
   * 
   *             5 8 1000 14 17    
   */ 
   for (j = 0; j < SUB1_LENGTH; j++) printf ("%d ", sub1_data[j]); 
   printf ("\n"); 
   /*  
   *         Reading the second subset. 
   * 
   * Set elements of start and edges arrays to read 
   * first 4 elements of the 10th row.  
   */ 
   start[0] = 9;  /* 10th row  */ 
   start[1] = 0;  /* 1st column */ 
   edges[0] = 1;  
   edges[1] = SUB2_LENGTH; /* SUB2_LENGTH elements are read along 10th row */ 
   /* 
   * Read data from the file into sub2_data array. Note that the third 
   * parameter is set to NULL for contiguous reading. 
   */ 
   status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)sub2_data); 
   /*  
   * Print what we have just read; the following numbers should be displayed: 
   * 
   *            10 1000 12 13  
   */ 
   for (j = 0; j < SUB2_LENGTH; j++) printf ("%d ", sub2_data[j]); 
   printf ("\n"); 
   /*  
   *         Reading the third subset. 
   * 
   * Set elements of the arrays start, edges, and stride to read 
   * every 6th element in the column and 4th element in the row 
   * starting at 1st column, 3d row.     
   */ 
   start[0] = 2;  /* 3d row */ 
   start[1] = 0;  /* 1st column */ 
   edges[0] = SUB3_LENGTH2; /* SUB3_LENGTH2 elements are read along 
                               each column */ 
   edges[1] = SUB3_LENGTH1; /* SUB3_LENGTH1 elements are read along   
                               each row */ 
   stride[0] = 6; /* read every 6th element along each column */ 
   stride[1] = 4; /* read every 4th element along each row */ 
   /* 
   * Read the data from the file into sub3_data array. 
   */ 
   status = SDreaddata (sds_id, start, stride, edges, (VOIDP)sub3_data); 
   /*  
   * Print what we have just read; the following numbers should be displayed: 
   * 
   *            3 7  
   *            9 13   
   *            15 19  
   */ 
   for ( j = 0; j < SUB3_LENGTH2; j++ ) { 
       for (i = 0; i < SUB3_LENGTH1; i++) printf ("%d ", sub3_data[j][i]); 
       printf ("\n"); 
   } 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
read_subsets.f
      program  read_subsets 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      parameter   (FILE_NAME  = 'SDS.hdf') 
      integer      DFACC_READ, DFNT_INT32 
      parameter   (DFACC_READ = 1, 
     +             DFNT_INT32 = 24) 
      integer      SUB1_LENGTH, SUB2_LENGTH, SUB3_LENGTH1, 
     +             SUB3_LENGTH2  
      parameter   (SUB1_LENGTH  = 5, 
     +             SUB2_LENGTH  = 4,  
     +             SUB3_LENGTH1 = 2, 
     +             SUB3_LENGTH2 = 3) 
C 
C     Function declaration. 
C 
      integer sfstart, sfselect, sfrdata, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index, status 
      integer start(2), edges(2), stride(2) 
      integer sub1_data(SUB1_LENGTH) 
      integer sub2_data(SUB2_LENGTH) 
      integer sub3_data(SUB3_LENGTH1,SUB3_LENGTH2) 
      integer i, j 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_READ) 
C 
C     Select the first data set. 
C 
      sds_index = 0 
      sds_id =sfselect(sd_id, sds_index) 
C 
C            Reading the first subset. 
C 
C     Set elements of start, stride, and edges arrays to read  
C     every 3d element in in the 2nd row starting in the 4th column.  
C 
      start(1) = 1  
      start(2) = 3  
      edges(1) = 1  
      edges(2) = SUB1_LENGTH 
      stride(1) = 1 
      stride(2) = 3  
C 
C     Read the data from sub1_data array.  
C 
      status = sfrdata(sds_id, start, stride, edges, sub1_data) 
       
C 
C     Print what we have just read, the following numbers should be displayed: 
C 
C           5 8 1000 14 17  
C 
      write(*,*) (sub1_data(j), j = 1, SUB1_LENGTH) 
C 
C            Reading the second subset. 
C 
C     Set elements of start, stride, and edges arrays to read  
C     first 4 elements of 10th column.  
C 
      start(1) = 0  
      start(2) = 9  
      edges(1) = SUB2_LENGTH  
      edges(2) = 1  
      stride(1) = 1 
      stride(2) = 1  
C 
C     Read the data into sub2_data array.  
C 
      status = sfrdata(sds_id, start, stride, edges, sub2_data) 
       
C 
C     Print what we have just read; the following numbers should be displayed: 
C 
C          10 1000 12 13  
C 
      write(*,*) (sub2_data(j), j = 1, SUB2_LENGTH) 
C 
C            Reading the third subset. 
C 
C     Set elements of start, stride and edges arrays to read  
C     every 6th element in the row and every 4th element in the column 
C     starting at 1st row, 3rd column.   
C 
      start(1) = 0  
      start(2) = 2  
      edges(1) = SUB3_LENGTH1  
      edges(2) = SUB3_LENGTH2  
      stride(1) = 4  
      stride(2) = 6  
C 
C     Read the data from the file into sub3_data array.  
C 
      status = sfrdata(sds_id, start, stride, edges, sub3_data) 
       
C 
C     Print what we have just read; the following numbers should be displayed: 
C 
C         3 9 15 
C         7 13 19  
C 
      do 50 i = 1, SUB3_LENGTH1 
         write(*,*) (sub3_data(i,j), j = 1, SUB3_LENGTH2) 
50    continue     
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
get_info.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id; 
   intn  status; 
   int32 n_datasets, n_file_attrs, index; 
   int32 dim_sizes[MAX_VAR_DIMS]; 
   int32 rank, data_type, n_attrs; 
   char  name[MAX_NC_NAME]; 
   int   i; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Open the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_READ); 
   /* 
   * Determine the number of data sets in the file and the number 
   * of file attributes.  
   */ 
   status = SDfileinfo (sd_id, &n_datasets, &n_file_attrs); 
   /*   
   * Access every data set and print its name, rank, dimension sizes, 
   * data type, and number of attributes.  
   * The following information should be displayed: 
   * 
   *               name = SDStemplate 
   *               rank = 2 
   *               dimension sizes are : 16  5   
   *               data type is  24 
   *               number of attributes is  0 
   */ 
   for (index = 0; index < n_datasets; index++) 
   { 
       sds_id = SDselect (sd_id, index); 
       status = SDgetinfo (sds_id, name, &rank, dim_sizes,  
                           &data_type, &n_attrs); 
       printf ("name = %s\n", name); 
       printf ("rank = %d\n", rank); 
       printf ("dimension sizes are : "); 
       for (i=0; i< rank; i++) printf ("%d  ", dim_sizes[i]); 
       printf ("\n"); 
       printf ("data type is  %d\n", data_type); 
       printf ("number of attributes is  %d\n", n_attrs); 
       /* 
       * Terminate access to the data set. 
       */ 
       status = SDendaccess (sds_id); 
   } 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
get_info.f
      program get_data_set_info  
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      parameter   (FILE_NAME = 'SDS.hdf') 
      integer      DFACC_READ, DFNT_INT32 
      parameter   (DFACC_READ = 1, 
     +             DFNT_INT32 = 24) 
      integer      MAX_NC_NAME, MAX_VAR_DIMS 
      parameter   (MAX_NC_NAME  = 256, 
     +             MAX_VAR_DIMS = 32) 
C 
C     Function declaration. 
C 
      integer sfstart, sffinfo, sfselect, sfginfo 
      integer sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id 
      integer n_datasets, n_file_attrs, index 
      integer status, n_attrs 
      integer rank, data_type 
      integer dim_sizes(MAX_VAR_DIMS) 
      character name *(MAX_NC_NAME) 
      integer i 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_READ) 
C 
C     Determine the number of data sets in the file and the number of  
C     file attributes.  
C 
      status = sffinfo(sd_id, n_datasets, n_file_attrs) 
C 
C     Access every data set in the file and print its name, rank, 
C     dimension sizes, data type, and number of attributes. 
C     The following information should be displayed: 
C 
C                name = SDStemplate     
C                rank =   2 
C                dimension sizes are :   5  16 
C                data type is   24 
C                number of attributes is   0 
C 
      do 10 index = 0, n_datasets - 1 
         sds_id = sfselect(sd_id, index) 
         status = sfginfo(sds_id, name, rank, dim_sizes, data_type,  
     .                    n_attrs) 
         write(*,*)  "name = ", name(1:15) 
         write(*,*)  "rank = ", rank 
         write(*,*)  "dimension sizes are : ", (dim_sizes(i), i=1, rank) 
         write(*,*)  "data type is ", data_type 
         write(*,*)  "number of attributes is ", n_attrs    
C 
C     Terminate access to the current data set. 
C 
         status = sfendacc(sds_id) 
10    continue 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
find_sds_by_name.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
#define SDS_NAME      "SDStemplate" 
#define WRONG_NAME    "WrongName" 
#define X_LENGTH      5 
#define Y_LENGTH      16 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index; 
   intn  status; 
   int32 start[2], edges[2]; 
   int32 data[Y_LENGTH][X_LENGTH]; 
   int   i, j; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Open the file for reading and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_READ); 
   /* 
   * Find index of the data set with the name specified in WRONG_NAME. 
   * Error condition occurs, since the data set with that name does not exist  
   * in the file. 
   */  
   sds_index = SDnametoindex (sd_id, WRONG_NAME); 
   if (sds_index == FAIL) 
   printf ("Data set with the name \"WrongName\" does not exist\n");  
   /* 
   * Find index of the data set with the name specified in SDS_NAME and use  
   * the index to select the data set. 
   */  
   sds_index = SDnametoindex (sd_id, SDS_NAME); 
   sds_id = SDselect (sd_id, sds_index); 
   /*  
   * Set elements of the array start to 0, elements of the array edges to  
   * SDS dimensions, and use NULL for stride argument in SDreaddata to read 
   * the entire data. 
   */ 
   start[0] = 0; 
   start[1] = 0; 
   edges[0] = Y_LENGTH; 
   edges[1] = X_LENGTH; 
   /* 
   * Read the entire data into the buffer named data. 
   */ 
   status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)data); 
   /*  
   * Print 10th row; the following numbers should be displayed: 
   * 
   *             10 1000 12 13 14 
   */ 
   for (j = 0; j < X_LENGTH; j++) printf ("%d ", data[9][j]); 
   printf ("\n"); 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
find_sds_by_name.f
      program  locate_by_name 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      character*11 SDS_NAME 
      character*9  WRONG_NAME 
      integer      X_LENGTH, Y_LENGTH 
      parameter   (FILE_NAME  = 'SDS.hdf', 
     +             SDS_NAME   = 'SDStemplate', 
     +             WRONG_NAME = 'WrongName', 
     +             X_LENGTH = 5, 
     +             Y_LENGTH = 16) 
      integer      DFACC_READ, DFNT_INT32 
      parameter   (DFACC_READ = 1, 
     +             DFNT_INT32 = 24) 
C 
C     Function declaration. 
C 
      integer sfstart, sfn2index, sfselect, sfrdata, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C  
      integer sd_id, sds_id, sds_index, status 
      integer start(2), edges(2), stride(2) 
      integer data(X_LENGTH, Y_LENGTH) 
      integer j 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_READ) 
C 
C     Find index of the data set with the name specified in WRONG_NAME.  
C     Error condition occurs, since a data set with this name  
C     does not exist in the file. 
C 
      sds_index = sfn2index(sd_id, WRONG_NAME) 
      if (sds_index .eq. -1) then 
        write(*,*) "Data set with the name ", WRONG_NAME, 
     +             " does not exist"         
      endif 
C 
C     Find index of the data set with the name specified in SDS_NAME   
C     and use the index to attach to the data set.  
C 
      sds_index = sfn2index(sd_id, SDS_NAME) 
      sds_id    = sfselect(sd_id, sds_index) 
C 
C     Set elements of start array to 0, elements of edges array  
C     to SDS dimensions, and elements of stride array to 1 to read entire data.  
C 
      start(1) = 0 
      start(2) = 0 
      edges(1) = X_LENGTH 
      edges(2) = Y_LENGTH 
      stride(1) = 1 
      stride(2) = 1 
C 
C     Read entire data into array named data.  
C 
      status = sfrdata(sds_id, start, stride, edges, data) 
C 
C     Print 10th column; the following numbers should be displayed: 
C 
C           10 1000 12 13 14 
C 
      write(*,*) (data(j,10), j = 1, X_LENGTH) 
C 
C     Terminate access to the data set.  
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
set_get_dim_info.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
#define SDS_NAME      "SDStemplate" 
#define DIM_NAME_X     "X_Axis" 
#define DIM_NAME_Y     "Y_Axis" 
#define NAME_LENGTH   6 
#define X_LENGTH      5 
#define Y_LENGTH      16 
#define RANK          2 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32   sd_id, sds_id, sds_index; 
   intn    status; 
   int32   dim_index, dim_id; 
   int32   n_values, data_type, n_attrs; 
   int16   data_X[X_LENGTH];    /* X dimension dimension scale */ 
   int16   data_X_out[X_LENGTH]; 
   float64 data_Y[Y_LENGTH];  /* Y dimension dimension scale */ 
   float64 data_Y_out[Y_LENGTH];  
   char    dim_name[NAME_LENGTH]; 
   int     i, j, nrow; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Initialize dimension scales. 
   */ 
   for (i=0; i < X_LENGTH; i++) data_X[i] = i; 
   for (i=0; i < Y_LENGTH; i++) data_Y[i] = 0.1 * i; 
       
   /*  
   * Open the file and initialize SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_WRITE); 
   /* 
   * Get the index of the data set specified in SDS_NAME. 
   */ 
   sds_index = SDnametoindex (sd_id, SDS_NAME); 
   /* 
   * Select the data set corresponding to the returned index. 
   */ 
   sds_id = SDselect (sd_id, sds_index); 
   /* For each dimension of the data set specified in SDS_NAME, 
   *  get its dimension identifier and set dimension name 
   *  and dimension scale. Note that data type of dimension scale  
   *  can be different between dimensions and can be different from  
   *  SDS data type. 
   */ 
   for (dim_index = 0; dim_index < RANK; dim_index++)  
   { 
       /*  
       * Select the dimension at position dim_index. 
       */ 
       dim_id = SDgetdimid (sds_id, dim_index); 
       /*  
       * Assign name and dimension scale to selected dimension. 
       */ 
       switch (dim_index) 
       { 
	case 0:	status = SDsetdimname (dim_id, DIM_NAME_Y); 
                n_values = Y_LENGTH; 
                status = SDsetdimscale (dim_id,n_values,DFNT_FLOAT64, \ 
                                       (VOIDP)data_Y);   
		break; 
	case 1:	status = SDsetdimname (dim_id, DIM_NAME_X); 
                n_values = X_LENGTH;  
                status = SDsetdimscale (dim_id,n_values,DFNT_INT16, \ 
                                       (VOIDP)data_X);   
		break; 
	default: break; 
       } 
       /* 
       * Get and display info about the dimension and its scale values. 
       * The following information is displayed: 
       *                          
       *         Information about 1 dimension: 
       *         dimension name is Y_Axis 
       *         number of scale values is 16 
       *         dimension scale data type is float64 
       *         number of dimension attributes is 0 
       * 
       *         Scale values are : 
       *               0.000    0.100    0.200    0.300   
       *               0.400    0.500    0.600    0.700   
       *               0.800    0.900    1.000    1.100   
       *               1.200    1.300    1.400    1.500   
       * 
       *         Information about 2 dimension: 
       *         dimension name is X_Axis 
       *         number of scale values is 5 
       *         dimension scale data type is int16 
       *         number of dimension attributes is 0 
       * 
       *         Scale values are : 
       *               0  1  2  3  4 
       */ 
       status = SDdiminfo (dim_id, dim_name, &n_values, &data_type, &n_attrs); 
       printf ("Information about %d dimension:\n", dim_index+1); 
       printf ("dimension name is %s\n", dim_name); 
       printf ("number of scale values is %d\n", n_values); 
       if( data_type == DFNT_FLOAT64) 
       printf ("dimension scale data type is float64\n"); 
       if( data_type == DFNT_INT16) 
       printf ("dimension scale data type is int16\n"); 
       printf ("number of dimension attributes is %d\n", n_attrs); 
       printf ("\n"); 
       printf ("Scale values are :\n"); 
       switch (dim_index)  
       { 
         case 0:  status = SDgetdimscale (dim_id, (VOIDP)data_Y_out); 
                  nrow = 4; 
                  for (i=0; i<n_values/nrow; i++ ) 
                  { 
                      for (j=0; j<nrow; j++) 
                          printf ("  %-6.3f", data_Y_out[i*nrow + j]); 
                          printf ("\n"); 
                  } 
                  break;  
         case 1:  status = SDgetdimscale (dim_id, (VOIDP)data_X_out); 
                  for (i=0; i<n_values; i++) printf ("  %d", data_X_out[i]); 
                  break;  
         default: break; 
        } 
        printf ("\n"); 
   } /*for dim_index */ 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
set_get_dim_info.f
      program  dimension_info  
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      character*11 SDS_NAME 
      character*6  DIM_NAME_X 
      character*6  DIM_NAME_Y 
      integer      X_LENGTH, Y_LENGTH, RANK 
      parameter   (FILE_NAME  = 'SDS.hdf', 
     +             SDS_NAME   = 'SDStemplate', 
     +             DIM_NAME_X  = 'X_Axis', 
     +             DIM_NAME_Y  = 'Y_Axis', 
     +             X_LENGTH = 5, 
     +             Y_LENGTH = 16, 
     +             RANK     = 2) 
      integer      DFACC_WRITE, DFNT_INT16, DFNT_FLOAT64 
      parameter   (DFACC_WRITE   = 2, 
     +             DFNT_INT16   = 22, 
     +             DFNT_FLOAT64 = 6) 
C 
C     Function declaration. 
C 
      integer sfstart, sfn2index, sfdimid, sfgdinfo 
      integer sfsdscale, sfgdscale, sfsdmname, sfendacc 
      integer sfend, sfselect 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index, status 
      integer dim_index, dim_id 
      integer n_values, n_attrs, data_type 
      integer*2 data_X(X_LENGTH) 
      integer*2 data_X_out(X_LENGTH) 
      real*8    data_Y(Y_LENGTH) 
      real*8    data_Y_out(Y_LENGTH) 
      character*6 dim_name 
      integer   i 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Initialize dimension scales. 
C 
      do 10 i = 1, X_LENGTH   
         data_X(i) = i - 1 
10     continue 
      do 20 i = 1, Y_LENGTH   
         data_Y(i) = 0.1 * (i - 1) 
20     continue 
C 
C     Open the file and initialize SD interface. 
C  
      sd_id = sfstart(FILE_NAME, DFACC_WRITE) 
C 
C     Get the index of the data set with the name specified in SDS_NAME.  
C 
      sds_index = sfn2index(sd_id, SDS_NAME) 
C 
C     Select the data set corresponding to the returned index. 
C 
      sds_id = sfselect(sd_id, sds_index) 
C 
C     For each dimension of the data set, 
C     get its dimension identifier and set dimension name 
C     and dimension scales. Note that data type of dimension scale can 
C     be different between dimensions and can be different from SDS data type. 
C 
      do 30 dim_index = 0, RANK - 1  
C 
C        Select the dimension at position dim_index. 
C 
         dim_id = sfdimid(sds_id, dim_index) 
C 
C        Assign name and dimension scale to the dimension.  
C 
         if (dim_index .eq. 0) then 
            status = sfsdmname(dim_id, DIM_NAME_X)  
            n_values = X_LENGTH 
            status = sfsdscale(dim_id, n_values, DFNT_INT16, data_X) 
         end if 
         if (dim_index .eq. 1) then 
            status = sfsdmname(dim_id, DIM_NAME_Y) 
            n_values = Y_LENGTH 
            status = sfsdscale(dim_id, n_values, DFNT_FLOAT64, data_Y) 
         end if 
C 
C      Get and display information about dimension and its scale values. 
C      The following information is displayed: 
C 
C                    Information about 1 dimension : 
C                    dimension name is X_Axis 
C                    number of scale values is  5 
C                    dimension scale data type is int16 
C 
C                    number of dimension attributes is   0 
C                    Scale values are: 
C                        0  1  2  3  4 
C 
C                    Information about 2 dimension : 
C                    dimension name is Y_Axis 
C                    number of scale values is  16 
C                    dimension scale data type is float64 
C                    number of dimension attributes is   0 
C 
C                    Scale values are: 
C                        0.000      0.100      0.200      0.300 
C                        0.400      0.500      0.600      0.700 
C                        0.800      0.900      1.000      1.100 
C                        1.200      1.300      1.400      1.500 
C 
       status = sfgdinfo(dim_id, dim_name, n_values, data_type, n_attrs) 
C 
       write(*,*) "Information about ", dim_index+1," dimension :" 
       write(*,*) "dimension name is ", dim_name 
       write(*,*) "number of scale values is", n_values 
       if (data_type. eq. 22) then 
           write(*,*) "dimension scale data type is int16" 
       endif  
       if (data_type. eq. 6) then 
           write(*,*) "dimension scale data type is float64" 
       endif  
       write(*,*) "number of dimension attributes is ", n_attrs 
C 
       write(*,*) "Scale values are:" 
       if (dim_index .eq. 0) then 
          status = sfgdscale(dim_id, data_X_out) 
          write(*,*) (data_X_out(i), i= 1, X_LENGTH) 
       endif  
       if (dim_index .eq. 1)  then 
          status = sfgdscale(dim_id, data_Y_out)  
          write(*,100) (data_Y_out(i), i= 1, Y_LENGTH) 
100       format(4(1x,f10.3)/) 
       endif  
30      continue 
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
dimscale_vs_sds.c
#include "mfhdf.h" 
#define FILE_NAME     "SDS.hdf" 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32 sd_id, sds_id, sds_index; 
   intn  status; 
   int32 rank, data_type, dim_sizes[MAX_VAR_DIMS]; 
   int32 n_datasets, n_file_attr, n_attrs;  
   char  sds_name[MAX_NC_NAME]; 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Open the file and initialize the SD interface. 
   */ 
   sd_id = SDstart(FILE_NAME, DFACC_READ); 
   /* 
   * Obtain information about the file. 
   */  
   status = SDfileinfo(sd_id, &n_datasets, &n_file_attr); 
   /* Get information about each SDS in the file. 
   *  Check whether it is a coordinate variable, then display retrieved  
   *  information. 
   *  Output displayed: 
   * 
   *            SDS array with the name SDStemplate 
   *            Coordinate variable with the name Y_Axis 
   *            Coordinate variable with the name X_Axis 
   * 
   */ 
   for (sds_index=0; sds_index< n_datasets; sds_index++)  
   { 
       sds_id = SDselect (sd_id, sds_index); 
       status = SDgetinfo(sds_id, sds_name, &rank, dim_sizes, &data_type, &n_attrs); 
       if (SDiscoordvar(sds_id))  
          printf(" Coordinate variable with the name %s\n", sds_name); 
       else 
          printf(" SDS array with the name %s\n", sds_name); 
   /* 
   * Terminate access to the selected data set. 
   */ 
   status = SDendaccess(sds_id); 
   } 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend(sd_id); 
} 
dimscale_vs_sds.f
      program  sds_vrs_coordvar  
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      parameter   (FILE_NAME = 'SDS.hdf') 
      integer      DFACC_READ, DFNT_INT32 
      parameter   (DFACC_READ = 1, 
     +             DFNT_INT32 = 24) 
      integer      MAX_VAR_DIMS 
      parameter   (MAX_VAR_DIMS = 32) 
C 
C     Function declaration. 
C  
      integer sfstart, sfselect, sfiscvar, sffinfo, sfginfo 
      integer sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer       sd_id, sds_id, sds_index, status 
      integer       rank, data_type 
      integer       n_datasets, n_file_attrs, n_attrs 
      integer       dim_sizes(MAX_VAR_DIMS) 
      character*256 sds_name 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize the SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_READ) 
C 
C     Obtain information about the file. 
C  
      status = sffinfo(sd_id, n_datasets, n_file_attrs)  
C 
C     Get information about each SDS in the file. 
C     Check whether it is a coordinate variable, then display retrieved  
C     information.  
C     Output displayed: 
C  
C           SDS array with the name SDStemplate 
C           Coordinate variable with the name X_Axis 
C           Coordinate variable with the name Y_Axis 
C 
      do 10 sds_index = 0, n_datasets-1 
         sds_id = sfselect(sd_id, sds_index) 
         status = sfginfo(sds_id, sds_name, rank, dim_sizes, 
     +                    data_type, n_attrs) 
         status = sfiscvar(sds_id) 
         if (status .eq. 1) then 
             write(*,*) "Coordinate variable with the name ", 
     +       sds_name(1:6)  
         else 
             write(*,*) "SDS array with the name ",  
     +       sds_name(1:11)  
         endif 
C 
C        Terminate access to the data set. 
C 
         status = sfendacc(sds_id) 
10    continue 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
set_attr.c
#include "mfhdf.h" 
#define FILE_NAME      "SDS.hdf" 
#define FILE_ATTR_NAME "File_contents" 
#define SDS_ATTR_NAME  "Valid_range" 
#define DIM_ATTR_NAME  "Dim_metric" 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32   sd_id, sds_id, sds_index; 
   intn    status; 
   int32   dim_id, dim_index; 
   int32   n_values;                /* number of values of the file, SDS or 
                                       dimension attribute         */ 
   char8   file_values[] = "Storm_track_data";  
                                   /* values of the file attribute */ 
   float32 sds_values[2] = {2., 10.}; 
                                   /* values of the SDS attribute  */ 
   char8   dim_values[]  = "Seconds";  
                                  /* values of the dimension attribute */ 
   /********************* End of variable declaration ***********************/ 
   /* 
   * Open the file and initialize the SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_WRITE); 
   /* 
   * Set an attribute that describes the file contents. 
   */ 
   n_values = 16; 
   status = SDsetattr (sd_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values,  
                       (VOIDP)file_values); 
   /* 
   * Select the first data set. 
   */ 
   sds_index = 0; 
   sds_id = SDselect (sd_id, sds_index); 
   /*  
   * Assign attribute to the first SDS. Note that attribute values 
   * may have different data type than SDS data. 
   */ 
   n_values  = 2; 
   status = SDsetattr (sds_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values,  
                       (VOIDP)sds_values); 
   /* 
   * Get the the second dimension identifier of the SDS. 
   */ 
   dim_index = 1; 
   dim_id = SDgetdimid (sds_id, dim_index); 
   /* 
   * Set an attribute of the dimension that specifies the dimension metric. 
   */ 
   n_values = 7; 
   status = SDsetattr (dim_id, DIM_ATTR_NAME, DFNT_CHAR8, n_values,  
                       (VOIDP)dim_values); 
   /* 
   * Terminate access to the data set. 
   */ 
   status = SDendaccess (sds_id); 
   /* 
   * Terminate access to the SD interface and close the file. 
   */ 
   status = SDend (sd_id); 
} 
set_attr.f
      program  set_attribs 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      character*13 FILE_ATTR_NAME 
      character*11 SDS_ATTR_NAME 
      character*10 DIM_ATTR_NAME 
      parameter   (FILE_NAME = 'SDS.hdf', 
     +             FILE_ATTR_NAME = 'File_contents', 
     +             SDS_ATTR_NAME  = 'Valid_range', 
     +             DIM_ATTR_NAME  = 'Dim_metric') 
      integer      DFACC_WRITE, DFNT_CHAR8, DFNT_FLOAT32 
      parameter   (DFACC_WRITE = 2, 
     +             DFNT_CHAR8  = 4, 
     +             DFNT_FLOAT32 = 5) 
C 
C     Function declaration. 
C 
      integer sfstart, sfscatt, sfsnatt, sfselect, sfdimid 
      integer sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer sd_id, sds_id, sds_index, status 
      integer dim_id, dim_index  
      integer n_values 
      character*16 file_values 
      real         sds_values(2) 
      character*7  dim_values 
      file_values   = 'Storm_track_data' 
      sds_values(1) = 2. 
      sds_values(2) = 10. 
      dim_values    = 'Seconds' 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize the SD interface.  
C 
      sd_id = sfstart(FILE_NAME, DFACC_WRITE) 
C 
C     Set an attribute that describes the file contents.  
C 
      n_values = 16 
      status = sfscatt(sd_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values,  
     +                 file_values) 
C 
C     Select the first data set.  
C 
      sds_index = 0 
      sds_id = sfselect(sd_id, sds_index) 
C 
C     Assign attribute to the first SDS. Note that attribute values 
C     may have different data type than SDS data. 
C 
      n_values = 2 
      status = sfsnatt(sds_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values,  
     +                 sds_values) 
C 
C     Get the identifier for the first dimension.  
C 
      dim_index = 0  
      dim_id = sfdimid(sds_id, dim_index) 
C 
C     Set an attribute to the dimension that specifies the 
C     dimension metric.  
C 
      n_values = 7 
      status = sfscatt(dim_id, DIM_ATTR_NAME, DFNT_CHAR8, n_values,  
     +                 dim_values) 
C 
C     Terminate access to the data set.  
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file. 
C 
      status = sfend(sd_id) 
      end 
get_attr.c
#include "mfhdf.h" 
#define FILE_NAME      "SDS.hdf" 
#define FILE_ATTR_NAME "File_contents" 
#define SDS_ATTR_NAME  "Valid_range" 
#define DIM_ATTR_NAME  "Dim_metric" 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   int32   sd_id, sds_id, dim_id; 
   intn    status; 
   int32   attr_index, data_type, n_values;  
   char    attr_name[MAX_NC_NAME]; 
   int8    *file_data; 
   int8    *dim_data; 
   float32 *sds_data; 
   int     i; 
    
   /********************* End of variable declaration ***********************/ 
   /* 
   * Open the file and initialize SD interface. 
   */ 
   sd_id = SDstart (FILE_NAME, DFACC_READ); 
   /* 
   * Find the file attribute defined by FILE_ATTR_NAME. 
   */ 
   attr_index = SDfindattr (sd_id, FILE_ATTR_NAME); 
   /* 
   * Get information about the file attribute. Note that the first 
   * parameter is an SD interface identifier. 
   */ 
   status = SDattrinfo (sd_id, attr_index, attr_name, &data_type, &n_values); 
   /* 
   * Allocate a buffer to hold the attribute data. 
   */ 
   file_data = (int8 *)malloc (n_values * sizeof (data_type)); 
   /* 
   * Read the file attribute data. 
   */ 
   status = SDreadattr (sd_id, attr_index, file_data); 
   /* 
   * Print out file attribute value.  
   */ 
   printf ("File attribute value is : %s\n", file_data); 
   /* 
   * Select the first data set. 
   */ 
   sds_id = SDselect (sd_id, 0); 
   /* 
   * Find the data set attribute defined by SDS_ATTR_NAME. Note that the 
   * first parameter is a data set identifier. 
   */ 
   attr_index = SDfindattr (sds_id, SDS_ATTR_NAME); 
   /* 
   * Get information about the data set attribute. 
   */ 
   status = SDattrinfo (sds_id, attr_index, attr_name, &data_type, &n_values); 
   /* 
   * Allocate a buffer to hold the data set attribute data. 
   */ 
   sds_data = (float32 *)malloc (n_values * sizeof (data_type)); 
   /* 
   * Read the SDS attribute data. 
   */ 
   status = SDreadattr (sds_id, attr_index, sds_data); 
   /* 
   * Print out SDS attribute data type and values.  
   */ 
   if (data_type == DFNT_FLOAT32)  
                 printf ("SDS attribute data type is : float32\n"); 
   printf ("SDS attribute values are :  "); 
   for (i=0; i<n_values; i++) printf (" %f", sds_data[i]); 
   printf ("\n");  
   /*     
   * Get the identifier for the second dimension of the SDS. 
   */ 
   dim_id = SDgetdimid (sds_id, 1); 
   /* 
   * Find dimension attribute defined by DIM_ATTR_NAME. 
   */ 
   attr_index = SDfindattr (dim_id, DIM_ATTR_NAME); 
   /* 
   * Get information about the dimension attribute. 
   */ 
   status = SDattrinfo (dim_id, attr_index, attr_name, &data_type, &n_values); 
   /* 
   * Allocate a buffer to hold the dimension attribute data. 
   */ 
   dim_data = (int8 *)malloc (n_values * sizeof (data_type)); 
   /* 
   * Read the dimension attribute data. 
   */ 
   status = SDreadattr (dim_id, attr_index, dim_data); 
   /* 
   * Print out dimension attribute value.  
   */ 
   printf ("Dimensional attribute values is : %s\n", dim_data); 
   /* 
   * Terminate access to the data set and to the SD interface and  
   * close the file. 
   */ 
   status = SDendaccess (sds_id); 
   status = SDend (sd_id); 
   /* 
   * Free all buffers. 
   */ 
   free (dim_data); 
   free (sds_data); 
   free (file_data); 
   /*   Output of this program is : 
   * 
   *    File attribute value is : Storm_track_data 
   *    SDS attribute data type is : float32 
   *    SDS attribute values are :   2.000000 10.000000 
   *    Dimensional attribute values is : Seconds 
   */ 
} 
get_attr.f
      program  attr_info 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*7  FILE_NAME 
      character*13 FILE_ATTR_NAME 
      character*11 SDS_ATTR_NAME 
      character*10 DIM_ATTR_NAME 
      parameter   (FILE_NAME = 'SDS.hdf', 
     +             FILE_ATTR_NAME = 'File_contents', 
     +             SDS_ATTR_NAME  = 'Valid_range', 
     +             DIM_ATTR_NAME  = 'Dim_metric') 
      integer      DFACC_READ, DFNT_FLOAT32 
      parameter   (DFACC_READ   = 1, 
     +             DFNT_FLOAT32 = 5) 
C 
C     Function declaration. 
C 
      integer sfstart, sffattr, sfgainfo, sfrattr, sfselect 
      integer sfdimid, sfendacc, sfend 
C 
C**** Variable declaration ******************************************* 
C 
      integer      sd_id, sds_id, dim_id 
      integer      attr_index, data_type, n_values, status 
      real         sds_data(2) 
      character*20 attr_name  
      character*16 file_data 
      character*7  dim_data 
      integer      i 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the file and initialize SD interface.  
C 
      sd_id = sfstart(FILE_NAME, DFACC_READ) 
C 
C     Find the file attribute defined by FILE_ATTR_NAME. 
C     Note that the first parameter is an SD interface identifier. 
C 
      attr_index = sffattr(sd_id, FILE_ATTR_NAME) 
C 
C     Get information about the file attribute.  
C 
      status = sfgainfo(sd_id, attr_index, attr_name, data_type,  
     +			n_values) 
C 
C     Read the file attribute data.  
C 
      status = sfrattr(sd_id, attr_index, file_data) 
C 
C     Print file attribute value. 
C 
      write(*,*) "File attribute value is : ", file_data  
C 
C     Select the first data set.  
C 
      sds_id = sfselect(sd_id, 0) 
C 
C     Find the data set attribute defined by SDS_ATTR_NAME. 
C     Note that the first parameter is a data set identifier.  
C 
      attr_index = sffattr(sds_id, SDS_ATTR_NAME) 
C 
C     Get information about the data set attribute.  
C 
      status = sfgainfo(sds_id, attr_index, attr_name, data_type,  
     +			n_values) 
C 
C     Read the SDS attribute data.  
C 
      status = sfrattr(sds_id, attr_index, sds_data) 
C 
C     Print SDS attribute data type and values.  
C 
      if (data_type .eq. DFNT_FLOAT32)  then 
         write(*,*) "SDS attribute data type is : float32 "   
      endif 
      write(*,*) "SDS attribute values are  : "  
      write(*,*)  (sds_data(i), i=1, n_values)  
C 
C     Get the identifier for the first dimension of the SDS.  
C 
      dim_id = sfdimid(sds_id, 0) 
C 
C     Find the dimensional attribute defined by DIM_ATTR_NAME. 
C     Note that the first parameter is a dimension identifier. 
C 
      attr_index = sffattr(dim_id, DIM_ATTR_NAME) 
C 
C     Get information about dimension attribute.  
C 
      status = sfgainfo(dim_id, attr_index, attr_name, data_type,  
     +			n_values) 
C 
C     Read the dimension attribute data.  
C 
      status = sfrattr(dim_id, attr_index, dim_data) 
C 
C     Print dimension attribute value. 
C 
      write(*,*) "Dimensional attribute value is : ", dim_data  
C 
C     Terminate access to the data set.  
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file.  
C 
      status = sfend(sd_id) 
C 
C     Output of this program is : 
C 
C 
C     File attribute value is : Storm_track_data 
C     SDS attribute data type is : float32  
C     SDS attribute values are  :  
C         2.00000   10.00000 
C      Dimensional attribute value is : Seconds 
C 
      end 
chunking_example.c
#include "mfhdf.h" 
#define FILE_NAME     "SDSchunked.hdf" 
#define SDS_NAME      "ChunkedData" 
#define RANK          2 
main() 
{ 
   /************************* Variable declaration **************************/ 
   int32         sd_id, sds_id, sds_index; 
   intn          status; 
   int32         flag, maxcache, new_maxcache; 
   int32         dim_sizes[2], origin[2]; 
   HDF_CHUNK_DEF c_def, c_def_out; /* Chunking definitions */  
   int32         comp_flag, c_flags; 
   int16         all_data[9][4]; 
   int32         start[2], edges[2]; 
   int16         chunk_out[3][2]; 
   int16         row[2] = { 5, 5 }; 
   int16         column[3] = { 4, 4, 4 }; 
   int16         fill_value = 0;   /* Fill value */ 
   int           i,j; 
   /* 
   * Declare chunks data type and initialize some of them.  
   */ 
          int16 chunk1[3][2] = { 1, 1, 
                                 1, 1, 
                                 1, 1 };  
          int16 chunk2[3][2] = { 2, 2, 
                                 2, 2, 
                                 2, 2 };  
          int16 chunk3[3][2] = { 3, 3, 
                                 3, 3, 
                                 3, 3 };  
          int16 chunk6[3][2] = { 6, 6, 
                                 6, 6, 
                                 6, 6 }; 
    /********************* End of variable declaration ***********************/ 
    /* 
    * Define chunk's dimensions. 
    * 
    *         In this example we do not use compression.  
    *         To use chunking with RLE, Skipping Huffman, and GZIP 
    *         compression, initialize 
    * 
    *                c_def.comp.chunk_lengths[0] = 3; 
    *                c_def.comp.chunk_lengths[1] = 2;  
    * 
    *         To use chunking with NBIT, initialize 
    * 
    *                c_def.nbit.chunk_lengths[0] = 3; 
    *                c_def.nbit.chunk_lengths[1] = 2;  
    * 
    */ 
    c_def.chunk_lengths[0] = 3; 
    c_def.chunk_lengths[1] = 2; 
    /* 
    * Create the file and initialize SD interface. 
    */ 
    sd_id = SDstart (FILE_NAME, DFACC_CREATE); 
    /* 
    * Create 9x4 SDS. 
    */ 
    dim_sizes[0] = 9; 
    dim_sizes[1] = 4; 
    sds_id = SDcreate (sd_id, SDS_NAME,DFNT_INT16, RANK, dim_sizes); 
    /* 
    * Fill the SDS array with the fill value. 
    */ 
    status = SDsetfillvalue (sds_id, (VOIDP)&fill_value); 
    /* 
    * Create chunked SDS. 
    * In this example we do not use compression ( third 
    * parameter of SDsetchunk is set to HDF_CHUNK). 
    * 
    * To use RLE compresssion, set compression type and flag 
    * 
    *            c_def.comp.comp_type = COMP_CODE_RLE; 
    *            comp_flag = HDF_CHUNK | HDF_COMP; 
    *           
    * To use Skipping Huffman compression, set compression type, flag 
    * and skipping size skp_size 
    * 
    *            c_def.comp.comp_type = COMP_CODE_SKPHUFF; 
    *            c_def.comp.cinfo.skphuff.skp_size = value;              
    *            comp_flag = HDF_CHUNK | HDF_COMP; 
    * 
    * To use GZIP compression, set compression type, flag and 
    * deflate level 
    *  
    *            c_def.comp.comp_type = COMP_CODE_DEFLATE; 
    *            c_def.comp.cinfo.deflate.level = value;              
    *            comp_flag = HDF_CHUNK | HDF_COMP; 
    * 
    * To use NBIT compression, set compression flag and 
    * compression parameters 
    *           
    *            comp_flag = HDF_CHUNK | HDF_NBIT; 
    *            c_def.nbit.start_bit = value1;              
    *            c_def.nbit.bit_len   = value2;              
    *            c_def.nbit.sign_ext  = value3;              
    *            c_def.nbit.fill_one  = value4;              
    */ 
    comp_flag = HDF_CHUNK; 
    status = SDsetchunk (sds_id, c_def, comp_flag); 
    /* 
    * Set chunk cache to hold maximum of 3 chunks. 
    */ 
    maxcache = 3; 
    flag = 0; 
    new_maxcache = SDsetchunkcache (sds_id, maxcache, flag); 
    /*  
    * Write chunks using SDwritechunk function. 
    * Chunks can be written in any order. 
    */ 
    /*  
    * Write the chunk with the coordinates (0,0). 
    */ 
    origin[0] = 0; 
    origin[1] = 0; 
    status = SDwritechunk (sds_id, origin, (VOIDP) chunk1); 
    /*    
    * Write the chunk with the coordinates (1,0). 
    */ 
    origin[0] = 1; 
    origin[1] = 0; 
    status = SDwritechunk (sds_id, origin, (VOIDP) chunk3); 
    /*    
    * Write the chunk with the coordinates (0,1).  
    */ 
    origin[0] = 0; 
    origin[1] = 1; 
    status = SDwritechunk (sds_id, origin, (VOIDP) chunk2); 
    /*  
    * Write chunk with the coordinates (1,2) using 
    * SDwritedata function. 
    */ 
    start[0] = 6; 
    start[1] = 2; 
    edges[0] = 3; 
    edges[1] = 2; 
    status = SDwritedata (sds_id, start, NULL, edges, (VOIDP) chunk6);  
    /*  
    * Fill second column in the chunk with the coordinates (1,1) 
    * using SDwritedata function. 
    */ 
    start[0] = 3; 
    start[1] = 3; 
    edges[0] = 3; 
    edges[1] = 1; 
    status = SDwritedata (sds_id, start, NULL, edges, (VOIDP) column);  
    /*  
    * Fill second row in the chunk with the coordinates (0,2) 
    * using SDwritedata function. 
    */ 
    start[0] = 7; 
    start[1] = 0; 
    edges[0] = 1; 
    edges[1] = 2; 
    status = SDwritedata (sds_id, start, NULL, edges, (VOIDP) row);  
            
    /*  
    * Terminate access to the data set. 
    */ 
    status = SDendaccess (sds_id); 
    /* 
    * Terminate access to the SD interface and close the file. 
    */ 
    status = SDend (sd_id); 
    /* 
    * Reopen the file and access the first data set. 
    */ 
    sd_id = SDstart (FILE_NAME, DFACC_READ); 
    sds_index = 0; 
    sds_id = SDselect (sd_id, sds_index); 
    /* 
    * Get information about the SDS. Only chunk lengths and compression 
    * flag can be returned. Compression information is not available if 
    * NBIT, Skipping Huffman, or GZIP compression is used. 
    */ 
    status = SDgetchunkinfo (sds_id, &c_def_out, &c_flags); 
    if (c_flags == HDF_CHUNK ) 
       printf(" SDS is chunked\nChunk's dimensions %dx%d\n", 
              c_def_out.chunk_lengths[0], 
              c_def_out.chunk_lengths[1]); 
    else if (c_flags == (HDF_CHUNK | HDF_COMP)) 
         printf("SDS is chunked and compressed\nChunk's dimensions %dx%d\n", 
                  c_def_out.comp.chunk_lengths[0], 
                  c_def_out.comp.chunk_lengths[1]); 
    else if (c_flags == (HDF_CHUNK | HDF_NBIT)) 
         printf ("SDS is chunked (NBIT)\nChunk's dimensions %dx%d\n", 
                  c_def_out.nbit.chunk_lengths[0], 
                  c_def_out.nbit.chunk_lengths[1]); 
    /* 
    * Read the entire data set using SDreaddata function. 
    */ 
    start[0] = 0; 
    start[1] = 0; 
    edges[0] = 9; 
    edges[1] = 4; 
    status = SDreaddata (sds_id, start, NULL, edges, (VOIDP)all_data); 
    /*  
    * Print out what we have read. 
    * The following information should be displayed: 
    * 
    * SDS is chunked  
    * Chunk's dimensions 3x2 
    *          1 1 2  
    *          1 1 2 2 
    *          1 1 2 2 
    *          3 3 0 4 
    *          3 3 0 4 
    *          3 3 0 4 
    *          0 0 6 6 
    *          5 5 6 6 
    *          0 0 6 6 
    */ 
    for (j=0; j<9; j++)  
    { 
         for (i=0; i<4; i++) printf (" %d", all_data[j][i]); 
         printf ("\n"); 
    } 
    /*  
    * Read chunk with the coordinates (2,0) and display it. 
    */ 
    origin[0] = 2; 
    origin[1] = 0;    	 
    status = SDreadchunk (sds_id, origin, chunk_out); 
    printf (" Chunk (2,0) \n"); 
    for (j=0; j<3; j++)  
    { 
         for (i=0; i<2; i++) printf (" %d", chunk_out[j][i]); 
         printf ("\n"); 
    } 
    /*  
    * Read chunk with the coordinates (1,1) and display it. 
    */ 
    origin[0] = 1; 
    origin[1] = 1;    	 
    status = SDreadchunk (sds_id, origin, chunk_out); 
    printf (" Chunk (1,1) \n"); 
    for (j=0; j<3; j++)  
    { 
         for (i=0; i<2; i++) printf (" %d", chunk_out[j][i]); 
         printf ("\n"); 
    } 
    /*  The following information is displayed: 
    * 
    *   Chunk (2,0)  
    *   0 0 
    *   5 5 
    *   0 0 
    *   Chunk (1,1)  
    *   0 4 
    *   0 4 
    *   0 4 
    */ 
    /*  
    * Terminate access to the data set. 
    */ 
    status = SDendaccess (sds_id); 
    /* 
    * Terminate access to the SD interface and close the file. 
    */ 
    status = SDend (sd_id); 
}             
chunking_example.f
      program  chunk_examples 
      implicit none 
C 
C     Parameter declaration. 
C 
      character*14 FILE_NAME 
      character*11 SDS_NAME 
      integer      RANK 
      parameter   (FILE_NAME = 'SDSchunked.hdf', 
     +             SDS_NAME  = 'ChunkedData', 
     +             RANK      = 2) 
      integer      DFACC_CREATE, DFACC_READ, DFNT_INT16 
      parameter   (DFACC_CREATE = 4, 
     +             DFACC_READ   = 1, 
     +             DFNT_INT16   = 22) 
      integer      COMP_CODE_NONE 
      parameter   (COMP_CODE_NONE = 0) 
C 
C     This example does not use compression. 
C 
C     To use RLE compression, declare: 
C 
C     integer      COMP_CODE_RLE 
C     parameter   (COMP_CODE_RLE = 1) 
C 
C     To use NBIT compression, declare: 
C 
C     integer      COMP_CODE_NBIT 
C     parameter   (COMP_CODE_NBIT = 2) 
C 
C     To use Skipping Huffman compression, declare: 
C 
C     integer      COMP_CODE_SKPHUFF 
C     parameter   (COMP_CODE_SKPHUFF = 3) 
C 
C     To use GZIP compression, declare: 
C 
C     integer      COMP_CODE_DEFLATE 
C     parameter   (COMP_CODE_DEFLATE = 4) 
C 
C 
C     Function declaration. 
C 
      integer sfstart, sfcreate, sfendacc, sfend, 
     +        sfselect, sfsfill, sfschnk, sfwchnk, 
     +        sfrchnk, sfgichnk, sfwdata, sfrdata, 
     +        sfscchnk 
C 
C**** Variable declaration ******************************************* 
C 
      integer   sd_id, sds_id, sds_index, status           
      integer   dim_sizes(2), origin(2) 
      integer   fill_value, maxcache, new_maxcache, flag 
      integer   start(2), edges(2), stride(2) 
      integer*2 all_data(4,9) 
      integer*2 row(3), column(2) 
      integer*2 chunk_out(2,3) 
      integer*2 chunk1(2,3), 
     +          chunk2(2,3), 
     +          chunk3(2,3), 
     +          chunk6(2,3) 
      integer   i, j 
C 
C     Compression flag and parameters. 
C 
      integer comp_type, comp_flag, comp_prm(4) 
C 
C     Chunk's dimensions. 
C 
      integer dim_length(2), dim_length_out(2) 
C 
C     Initialize four chunks 
C 
      data chunk1 /6*1/ 
      data chunk2 /6*2/ 
      data chunk3 /6*3/ 
      data chunk6 /6*6/ 
C 
C     Initialize row and column arrays. 
C 
      data row /3*4/ 
      data column /2*5/ 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Define chunk's dimensions. 
C 
      dim_length(1) = 2  
      dim_length(2) = 3  
C  
C     Create the file and initialize SD interface. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_CREATE) 
C 
C     Create 4x9 SDS 
C 
      dim_sizes(1) = 4  
      dim_sizes(2) = 9  
      sds_id = sfcreate(sd_id, SDS_NAME, DFNT_INT16, 
     +                  RANK, dim_sizes) 
C 
C     Fill SDS array with the fill value. 
C 
      fill_value = 0 
      status = sfsfill( sds_id, fill_value) 
C 
C     Create chunked SDS. 
C 
C     In this example we do not use compression. 
C 
C     To use RLE compression, initialize comp_type parameter 
C     before the call to sfschnk function. 
C              comp_type = COMP_CODE_RLE 
C 
C     To use NBIT, Skipping Huffman, or GZIP compression, 
C     initialize comp_prm array and comp type parameter 
C     before call to sfschnk function 
C 
C     NBIT: 
C              comp_prm(1) = value_of(sign_ext) 
C              comp_prm(2) = value_of(fill_one) 
C              comp_prm(3) = value_of(start_bit) 
C              comp_prm(4) = value_of(bit_len) 
C              comp_type   = COMP_CODE_NBIT 
C 
C     Skipping Huffman: 
C              comp_prm(1) = value_of(skp_size) 
C              comp_type   = COMP_CODE_SKPHUFF 
C 
C     GZIP: 
C              comp_prm(1) = value_of(deflate_level)  
C              comp_type   = COMP_CODE_DEFLATE 
C        
C 
      comp_type = COMP_CODE_NONE 
      status = sfschnk(sds_id, dim_length, comp_type, comp_prm) 
C 
C     Set chunk cache to hold maximum 2 chunks. 
C 
      flag = 0 
      maxcache = 2 
      new_maxcache = sfscchnk(sds_id, maxcache, flag)  
C 
C     Write chunks using SDwritechunk function. 
C     Chunks can be written in any order. 
C 
C     Write chunk with the coordinates (1,1). 
C 
      origin(1) = 1 
      origin(2) = 1 
      status = sfwchnk(sds_id, origin, chunk1)  
C 
C     Write chunk with the coordinates (1,2). 
C 
      origin(1) = 1  
      origin(2) = 2  
      status = sfwchnk(sds_id, origin, chunk3)  
C 
C     Write chunk with the coordinates (2,1). 
C 
      origin(1) = 2  
      origin(2) = 1  
      status = sfwchnk(sds_id, origin, chunk2)  
C 
C     Write chunk with the coordinates (2,3). 
C 
      origin(1) = 2  
      origin(2) = 3  
      status = sfwchnk(sds_id, origin, chunk6)  
C 
C     Fill second row in the chunk with the coordinates (2,2). 
C 
      start(1) = 3 
      start(2) = 3 
      edges(1) = 1  
      edges(2) = 3  
      stride(1) = 1 
      stride(2) = 1 
      status = sfwdata(sds_id, start, stride, edges, row) 
C 
C     Fill second column in the chunk with the coordinates (1,3). 
C 
      start(1) = 0  
      start(2) = 7  
      edges(1) = 2  
      edges(2) = 1  
      stride(1) = 1 
      stride(2) = 1 
      status = sfwdata(sds_id, start, stride, edges, column) 
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file.   
C 
      status = sfend(sd_id) 
C 
C     Reopen the file and access the first data set. 
C 
      sd_id = sfstart(FILE_NAME, DFACC_READ) 
      sds_index = 0 
      sds_id = sfselect(sd_id, sds_index) 
C 
C     Get information about the SDS. 
C 
      status = sfgichnk(sds_id, dim_length_out, comp_flag) 
      if (comp_flag .eq. 0) then 
         write(*,*) 'SDS is chunked' 
      endif 
      if (comp_flag .eq. 1) then 
         write(*,*) 'SDS is chunked and compressed' 
      endif 
      if (comp_flag .eq. 2) then 
         write(*,*) 'SDS is chunked and NBIT compressed' 
      endif 
      write(*,*) 'Chunks dimensions are ', dim_length_out(1), 
     + '  x' ,dim_length_out(2) 
C 
C     Read the whole SDS using sfrdata function and display 
C     what we have read. The following information will be displayed: 
C 
C 
C             SDS is chunked 
C             Chunks dimensions are   2  x  3 
C  
C             1  1  1  3  3  3  0  5  0 
C             1  1  1  3  3  3  0  5  0 
C             2  2  2  0  0  0  6  6  6 
C             2  2  2  4  4  4  6  6  6 
C 
      start(1) = 0 
      start(2) = 0 
      edges(1) = 4 
      edges(2) = 9 
      stride(1) = 1 
      stride(2) = 1 
      status = sfrdata(sds_id, start, stride, edges, all_data) 
C 
C     Display the SDS. 
C 
      write(*,*) 
      do 10 i = 1,4 
         write(*,*) (all_data(i,j), j=1,9) 
10    continue      
C 
C     Read chunks with the coordinates (2,2) and (1,3) and display. 
C     The following information will be shown: 
C 
C             Chunk (2,2) 
C 
C               0  0  0 
C               4  4  4 
C  
C             Chunk (1,3) 
C 
C               0  5  0 
C               0  5  0 
C 
      origin(1) = 2 
      origin(2) = 2 
      status = sfrchnk(sds_id, origin, chunk_out) 
      write(*,*)  
      write(*,*) 'Chunk (2,2)' 
      write(*,*)  
      do 20 i = 1,2 
         write(*,*) (chunk_out(i,j), j=1,3) 
20    continue 
C 
      origin(1) = 1  
      origin(2) = 3  
      status = sfrchnk(sds_id, origin, chunk_out) 
      write(*,*)  
      write(*,*) 'Chunk (1,3)' 
      write(*,*)  
      do 30 i = 1,2 
         write(*,*) (chunk_out(i,j), j=1,3) 
30    continue 
C 
C     Terminate access to the data set. 
C 
      status = sfendacc(sds_id) 
C 
C     Terminate access to the SD interface and close the file.    
C 
      status = sfend(sd_id) 
      end  

HDF4.2r4 - February 2009
Copyright
The HDF Group
www.hdfgroup.org
The HDF Group