HDF5 documents and links Introduction to HDF5 HDF5 User Guide | And in this document, the HDF5 Reference Manual H5 H5A H5D H5E H5F H5G H5I H5P H5R H5S H5T H5Z Tools Datatypes

# H5S: Dataspace Interface

## Dataspace Object API Functions

These functions create and manipulate the dataspace in which to store the elements of a dataset.

The C Interfaces:

- H5Screate
- H5Scopy
- H5Sclose
- H5Screate_simple
- H5Sis_simple
- H5Soffset_simple
- H5Sget_simple_extent_dims
- H5Sget_simple_extent_ndims

- H5Sget_simple_extent_npoints
- H5Sget_simple_extent_type
- H5Sextent_copy
- H5Sset_extent_simple
- H5Sset_extent_none
- H5Sget_select_type
- H5Sget_select_npoints
- H5Sget_select_hyper_nblocks
- H5Sget_select_hyper_blocklist

- H5Sget_select_elem_npoints
- H5Sget_select_elem_pointlist
- H5Sget_select_bounds
- H5Sselect_elements
- H5Sselect_all
- H5Sselect_none
- H5Sselect_valid
- H5Sselect_hyperslab

Alphabetical Listing

- H5Sclose
- H5Scopy
- H5Screate
- H5Screate_simple
- H5Sextent_copy
- H5Sget_select_bounds
- H5Sget_select_elem_npoints
- H5Sget_select_elem_pointlist
- H5Sget_select_hyper_blocklist

- H5Sget_select_hyper_nblocks
- H5Sget_select_npoints
- H5Sget_select_type
- H5Sget_simple_extent_dims
- H5Sget_simple_extent_ndims
- H5Sget_simple_extent_npoints
- H5Sget_simple_extent_type
- H5Sis_simple
- H5Soffset_simple

- H5Sselect_all
- H5Sselect_elements
- H5Sselect_hyperslab
- H5Sselect_none
- H5Sselect_valid
- H5Sset_extent_none
- H5Sset_extent_simple

The FORTRAN90 Interfaces:
In general, each FORTRAN90 subroutine performs exactly the same task as the corresponding C function.

- h5screate_f
- h5scopy_f
- h5sclose_f
- h5screate_simple_f
- h5sis_simple_f
- h5soffset_simple_f
- h5sget_simple_extent_dims_f
- h5sget_simple_extent_ndims_f

- h5sget_simple_extent_npoints_f
- h5sget_simple_extent_type_f
- h5sextent_copy_f
- h5sset_extent_simple_f
- h5sset_extent_none_f
- h5sget_select_type_f
- h5sget_select_npoints_f
- h5sget_select_hyper_nblocks_f
- h5sget_select_hyper_blocklist_f

- h5sget_select_elem_npoints_f
- h5sget_select_elem_pointlist_f
- h5sselect_elements_f
- h5sselect_all_f
- h5sselect_none_f
- h5sselect_valid_f
- h5sselect_hyperslab_f

Name: H5Sclose
Signature:
  herr_t `H5Sclose`(hid_t `space_id` )
Purpose:
  Releases and terminates access to a dataspace.
Description:
  `H5Sclose` releases a dataspace. Further access through the dataspace identifier is illegal. Failure to release a dataspace with this call will result in resource leaks.
Parameters:

hid_t `space_id`
  Identifier of dataspace to release.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sclose_f

      SUBROUTINE h5sclose_f(space_id, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id  ! Dataspace identifier
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
      END SUBROUTINE h5sclose_f

Name: H5Scopy
Signature:
  hid_t `H5Scopy`(hid_t `space_id` )
Purpose:
  Creates an exact copy of a dataspace.
Description:
  `H5Scopy` creates a new dataspace which is an exact copy of the dataspace identified by `space_id`. The dataspace identifier returned from this function should be released with `H5Sclose` or resource leaks will occur.
Parameters:

hid_t `space_id`
  Identifier of dataspace to copy.

Returns:
  Returns a dataspace identifier if successful; otherwise returns a negative value.
Fortran90 Interface: h5scopy_f

      SUBROUTINE h5scopy_f(space_id, new_space_id, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id      ! Dataspace identifier
        INTEGER(HID_T), INTENT(OUT) :: new_space_id ! Identifier of dataspace's copy
        INTEGER, INTENT(OUT) :: hdferr              ! Error code
                                                    ! 0 on success and -1 on failure
      END SUBROUTINE h5scopy_f

Name: H5Screate
Signature:
  hid_t `H5Screate`(H5S_class_t `type`)
Purpose:
  Creates a new dataspace of a specified type.
Description:
  `H5Screate` creates a new dataspace of a particular `type`. The types currently supported are `H5S_SCALAR` and `H5S_SIMPLE`; others are planned to be added later.
Parameters:

H5S_class_t `type`
  The type of dataspace to be created.

Returns:
  Returns a dataspace identifier if successful; otherwise returns a negative value.
Fortran90 Interface: h5screate_f

      SUBROUTINE h5screate_f(classtype, space_id, hdferr)
        IMPLICIT NONE
        INTEGER, INTENT(IN) :: classtype        ! The type of the dataspace
                                                ! to be created. Possible values
                                                ! are:
                                                !    H5S_SCALAR_F
                                                !    H5S_SIMPLE_F
        INTEGER(HID_T), INTENT(OUT) :: space_id ! Dataspace identifier
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
      END SUBROUTINE h5screate_f

Name: H5Screate_simple
Signature:
  hid_t `H5Screate_simple`(int `rank`, const hsize_t * `dims`, const hsize_t * `maxdims` )
Purpose:
  Creates a new simple dataspace and opens it for access.
Description:
  `H5Screate_simple` creates a new simple dataspace and opens it for access.

  `rank` is the number of dimensions used in the dataspace.

  `dims` is an array specifying the size of each dimension of the dataset while `maxdims` is an array specifying the upper limit on the size of each dimension. `maxdims` may be the null pointer, in which case the upper limit is the same as `dims`.

  If an element of `maxdims` is `H5S_UNLIMITED`, (`-1`), the maximum size of the corresponding dimension is unlimited. Otherwise, no element of `maxdims` should be smaller than the corresponding element of `dims`.

  The dataspace identifier returned from this function must be released with `H5Sclose` or resource leaks will occur.

Parameters:

int `rank`
  Number of dimensions of dataspace.
const hsize_t * `dims`
  An array of the size of each dimension.
const hsize_t * `maxdims`
  An array of the maximum size of each dimension.

Returns:
  Returns a dataspace identifier if successful; otherwise returns a negative value.
Fortran90 Interface: h5screate_simple_f

      SUBROUTINE h5screate_simple_f(rank, dims, space_id, hdferr, maxdims)
        IMPLICIT NONE
        INTEGER, INTENT(IN) :: rank             ! Number of dataspace dimensions
        INTEGER(HSIZE_T), INTENT(IN) :: dims(*) ! Array with the dimension sizes
        INTEGER(HID_T), INTENT(OUT) :: space_id ! Dataspace identifier
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
        INTEGER(HSIZE_T), OPTIONAL, INTENT(IN) :: maxdims(*)
                                                ! Array with the maximum
                                                ! dimension sizes
      END SUBROUTINE h5screate_simple_f

Name: H5Sextent_copy
Signature:
  herr_t `H5Sextent_copy`(hid_t `dest_space_id`, hid_t `source_space_id` )
Purpose:
  Copies the extent of a dataspace.
Description:
  `H5Sextent_copy` copies the extent from `source_space_id` to `dest_space_id`. This action may change the type of the dataspace.
Parameters:

hid_t `dest_space_id`
  IN: The identifier for the dataspace to which the extent is copied.
hid_t `source_space_id`
  IN: The identifier for the dataspace from which the extent is copied.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sextent_copy_f

      SUBROUTINE h5sextent_copy_f(dest_space_id, source_space_id, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: dest_space_id   ! Identifier of destination
                                                      ! dataspace
        INTEGER(HID_T), INTENT(IN) :: source_space_id ! Identifier of source
                                                      ! dataspace
        INTEGER, INTENT(OUT) :: hdferr                ! Error code
                                                      ! 0 on success and -1 on failure
      END SUBROUTINE h5sextent_copy_f

Name: H5Sget_select_bounds
Signature:
  herr_t `H5Sget_select_bounds`(hid_t `space_id`, hssize_t *`start`, hssize_t *`end` )
Purpose:
  Gets the bounding box containing the current selection.
Description:
  `H5Sget_select_bounds` retrieves the coordinates of the bounding box containing the current selection and places them into user-supplied buffers.

  The `start` and `end` buffers must be large enough to hold the dataspace rank number of coordinates.

  The bounding box exactly contains the selection. I.e., if a 2-dimensional element selection is currently defined as containing the points (4,5), (6,8), and (10,7), then the bounding box will be (4, 5), (10, 8).

  The bounding box calculation includes the current offset of the selection within the dataspace extent.

  Calling this function on a `none` selection will return `FAIL`.

Parameters:

hid_t `space_id`
  IN: Identifier of dataspace to query.
hssize_t *`start`
  OUT: Starting coordinates of the bounding box.
hssize_t *`end`
  OUT: Ending coordinates of the bounding box, i.e., the coordinates of the diagonally opposite corner.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface:
  None.

Name: H5Sget_select_elem_npoints
Signature:
  hssize_t `H5Sget_select_elem_npoints`(hid_t `space_id` )
Purpose:
  Gets the number of element points in the current selection.
Description:
  `H5Sget_select_elem_npoints` returns the number of element points in the current dataspace selection.
Parameters:

hid_t `space_id`
  IN: Identifier of dataspace to query.

Returns:
  Returns the number of element points in the current dataspace selection if successful. Otherwise returns a negative value.
Fortran90 Interface: h5sget_select_elem_npoints_f

      SUBROUTINE h5sget_select_elem_npoints_f(space_id, num_points, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id ! Dataspace identifier
        INTEGER, INTENT(OUT) :: num_points     ! Number of points in
                                               ! the current elements selection
        INTEGER, INTENT(OUT) :: hdferr         ! Error code
      END SUBROUTINE h5sget_select_elem_npoints_f

Name: H5Sget_select_elem_pointlist
Signature:
  herr_t `H5Sget_select_elem_pointlist`(hid_t `space_id`, hsize_t `startpoint`, hsize_t `numpoints`, hsize_t *`buf` )
Purpose:
  Gets the list of element points currently selected.
Description:
  `H5Sget_select_elem_pointlist` returns the list of element points in the current dataspace selection. Starting with the `startpoint`-th point in the list of points, `numpoints` points are put into the user's buffer. If the user's buffer fills up before `numpoints` points are inserted, the buffer will contain only as many points as fit.

  The element point coordinates have the same dimensionality (rank) as the dataspace they are located within. The list of element points is formatted as follows:
  <coordinate>, followed by
  the next coordinate,
  etc.
  until all of the selected element points have been listed.

  The points are returned in the order they will be iterated through when the selection is read/written from/to disk.

Parameters:

hid_t `space_id`
  IN: Dataspace identifier of selection to query.
hsize_t `startpoint`
  IN: Element point to start with.
hsize_t `numpoints`
  IN: Number of element points to get.
hsize_t *`buf`
  OUT: List of element points selected.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sget_select_elem_pointlist_f

      SUBROUTINE h5sget_select_elem_pointlist_f(space_id, startpoint, num_points, &
                                                buf, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN)   :: space_id   ! Dataspace identifier
        INTEGER(HSIZE_T), INTENT(IN) :: startpoint ! Element point to start with
        INTEGER, INTENT(OUT) :: num_points         ! Number of points to get in
                                                   ! the current element selection
        INTEGER(HSIZE_T), DIMENSION(*), INTENT(OUT) :: buf
                                                   ! List of points selected
        INTEGER, INTENT(OUT) :: hdferr             ! Error code
      END SUBROUTINE h5sget_select_elem_pointlist_f

Name: H5Sget_select_hyper_blocklist
Signature:
  herr_t `H5Sget_select_hyper_blocklist`(hid_t `space_id`, hsize_t `startblock`, hsize_t `numblocks`, hsize_t *`buf` )
Purpose:
  Gets the list of hyperslab blocks currently selected.
Description:
  `H5Sget_select_hyper_blocklist` returns a list of the hyperslab blocks currently selected. Starting with the `startblock`-th block in the list of blocks, `numblocks` blocks are put into the user's buffer. If the user's buffer fills up before `numblocks` blocks are inserted, the buffer will contain only as many blocks as fit.

  The block coordinates have the same dimensionality (rank) as the dataspace they are located within. The list of blocks is formatted as follows:
  <"start" coordinate>, immediately followed by
  <"opposite" corner coordinate>, followed by
  the next "start" and "opposite" coordinates,
  etc.
  until all of the selected blocks have been listed.

  No guarantee is implied as the order in which blocks are listed.

Parameters:

hid_t `space_id`
  IN: Dataspace identifier of selection to query.
hsize_t `startblock`
  IN: Hyperslab block to start with.
hsize_t `numblocks`
  IN: Number of hyperslab blocks to get.
hsize_t *`buf`
  OUT: List of hyperslab blocks selected.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sget_select_hyper_blocklist_f

      SUBROUTINE h5sget_select_hyper_blocklist_f(space_id, startblock, num_blocks, &
                                                 buf, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN)   :: space_id   ! Dataspace identifier
        INTEGER(HSIZE_T), INTENT(IN) :: startblock ! Hyperslab block to start with
        INTEGER, INTENT(OUT) :: num_blocks         ! Number of hyperslab blocks to
                                                   ! get in the current hyperslab
                                                   ! selection
        INTEGER(HSIZE_T), DIMENSION(*), INTENT(OUT) :: buf
                                                   ! List of hyperslab blocks selected
        INTEGER, INTENT(OUT) :: hdferr             ! Error code
      END SUBROUTINE h5sget_select_hyper_blocklist_f

Name: H5Sget_select_hyper_nblocks
Signature:
  hssize_t `H5Sget_select_hyper_nblocks`(hid_t `space_id` )
Purpose:
  Get number of hyperslab blocks.
Description:
  `H5Sget_select_hyper_nblocks` returns the number of hyperslab blocks in the current dataspace selection.
Parameters:

hid_t `space_id`
  IN: Identifier of dataspace to query.

Returns:
  Returns the number of hyperslab blocks in the current dataspace selection if successful. Otherwise returns a negative value.
Fortran90 Interface: h5sget_select_hyper_nblocks_f

      SUBROUTINE h5sget_select_hyper_nblocks_f(space_id, num_blocks, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id ! Dataspace identifier
        INTEGER, INTENT(OUT) :: num_blocks     ! Number of hyperslab blocks in
                                               ! the current hyperslab selection
        INTEGER, INTENT(OUT) :: hdferr         ! Error code
      END SUBROUTINE h5sget_select_hyper_nblocks_f

Name: H5Sget_select_npoints
Signature:
  hssize_t `H5Sget_select_npoints`(hid_t `space_id`)
Purpose:
  Determines the number of elements in a dataspace selection.
Description:
  `H5Sget_select_npoints` determines the number of elements in the current selection of a dataspace.
Parameters:

hid_t `space_id`
  Dataspace identifier.

Returns:
  Returns the number of elements in the selection if successful; otherwise returns a negative value.
Fortran90 Interface: h5sget_select_npoints_f

      SUBROUTINE h5sget_select_npoints_f(space_id, npoints, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id     ! Dataspace identifier
        INTEGER(HSSIZE_T), INTENT(OUT) :: npoints  ! Number of elements in the
                                                   ! selection
        INTEGER, INTENT(OUT) :: hdferr             ! Error code
                                                   ! 0 on success and -1 on failure
      END SUBROUTINE h5sget_select_npoints_f

Name: H5Sget_select_type
Signature:
  H5S_sel_type `H5Sget_select_type`(hid_t `space_id`)
Purpose:
  Determines the type of the dataspace selection.
Description:
  `H5Sget_select_type` retrieves the type of selection currently defined for the dataspace `space_id`.
Parameters:

hid_t `space_id`
  Dataspace identifier.

Returns:
  Returns the dataspace selection type, a value of the enumerated datatype `H5S_sel_type`, if successful. Valid return values are as follows:

  `H5S_SEL_NONE` | No selection is defined.
  `H5S_SEL_POINTS` | A sequence of points is selected.
  `H5S_SEL_HYPERSLABS` | A hyperslab or compound hyperslab is selected.
  `H5S_SEL_ALL` | The entire dataset is selected.

  Otherwise returns a negative value.
Fortran90 Interface: h5sget_select_type_f

      SUBROUTINE h5sget_select_type_f(space_id, type, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id ! Dataspace identifier
        INTEGER, INTENT(OUT) :: type           ! Selection type
                                               ! Valid values are:
                                               !    H5S_SEL_ERROR_F
                                               !    H5S_SEL_NONE_F
                                               !    H5S_SEL_POINTS_F
                                               !    H5S_SEL_HYPERSLABS_F
                                               !    H5S_SEL_ALL_F
        INTEGER, INTENT(OUT) :: hdferr         ! Error code
      END SUBROUTINE h5sget_select_type_f

Name: H5Sget_simple_extent_dims
Signature:
  int `H5Sget_simple_extent_dims`(hid_t `space_id`, hsize_t *`dims`, hsize_t *`maxdims` )
Purpose:
  Retrieves dataspace dimension size and maximum size.
Description:
  `H5Sget_simple_extent_dims` returns the size and maximum sizes of each dimension of a dataspace through the `dims` and `maxdims` parameters.

  Either or both of `dims` and `maxdims` may be NULL.

  If a value in the returned array `maxdims` is `H5S_UNLIMITED` (-1), the maximum size of that dimension is unlimited.

Parameters:

hid_t `space_id`
  IN: Identifier of the dataspace object to query
hsize_t *`dims`
  OUT: Pointer to array to store the size of each dimension.
hsize_t *`maxdims`
  OUT: Pointer to array to store the maximum size of each dimension.

Returns:
  Returns the number of dimensions in the dataspace if successful; otherwise returns a negative value.
Fortran90 Interface: h5sget_simple_extent_dims_f

      SUBROUTINE h5sget_simple_extent_dims_f(space_id, dims, maxdims, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id   ! Dataspace identifier
        INTEGER(HSIZE_T), DIMENSION(*), INTENT(OUT) :: dims
                                                 ! Array to store dimension sizes
        INTEGER(HSIZE_T), DIMENSION(*), INTENT(OUT) :: maxdims
                                                 ! Array to store max dimension sizes
        INTEGER, INTENT(OUT) :: hdferr           ! Error code
                                                 ! Dataspace rank on success
                                                 ! and -1 on failure
      END SUBROUTINE h5sget_simple_extent_dims_f

Name: H5Sget_simple_extent_ndims
Signature:
  int `H5Sget_simple_extent_ndims`(hid_t `space_id`)
Purpose:
  Determines the dimensionality of a dataspace.
Description:
  `H5Sget_simple_extent_ndims` determines the dimensionality (or rank) of a dataspace.
Parameters:

hid_t `space_id`
  Identifier of the dataspace

Returns:
  Returns the number of dimensions in the dataspace if successful; otherwise returns a negative value.
Fortran90 Interface: h5sget_simple_extent_ndims_f

      SUBROUTINE h5sget_simple_extent_ndims_f(space_id, rank, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id   ! Dataspace identifier
        INTEGER, INTENT(OUT) :: rank             ! Number of dimensions
        INTEGER, INTENT(OUT) :: hdferr           ! Error code
                                                 ! 0 on success and -1 on failure
      END SUBROUTINE h5sget_simple_extent_ndims_f

Name: H5Sget_simple_extent_npoints
Signature:
  hssize_t `H5Sget_simple_extent_npoints`(hid_t `space_id`)
Purpose:
  Determines the number of elements in a dataspace.
Description:
  `H5Sget_simple_extent_npoints` determines the number of elements in a dataspace. For example, a simple 3-dimensional dataspace with dimensions 2, 3, and 4 would have 24 elements.
Parameters:

hid_t `space_id`
  ID of the dataspace object to query

Returns:
  Returns the number of elements in the dataspace if successful; otherwise returns 0.
Fortran90 Interface: h5sget_simple_extent_npoints_f

      SUBROUTINE h5sget_simple_extent_npoints_f(space_id, npoints, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id    ! Dataspace identifier
        INTEGER(HSIZE_T), INTENT(OUT) :: npoints  ! Number of elements in dataspace
        INTEGER, INTENT(OUT) :: hdferr            ! Error code
                                                  ! 0 on success and -1 on failure
      END SUBROUTINE h5sget_simple_extent_npoints_f

Name: H5Sget_simple_extent_type
Signature:
  H5S_class_t `H5Sget_simple_extent_type`(hid_t `space_id`)
Purpose:
  Determine the current class of a dataspace.
Description:
  `H5Sget_simple_extent_type` queries a dataspace to determine the current class of a dataspace.

  The function returns a class name, one of the following: `H5S_SCALAR`, `H5S_SIMPLE`, or `H5S_NONE`.

Parameters:

hid_t `space_id`
  Dataspace identifier.

Returns:
  Returns a dataspace class name if successful; otherwise H5S_NO_CLASS (-1).
Fortran90 Interface: h5sget_simple_extent_type_f

      SUBROUTINE h5sget_simple_extent_type_f(space_id, classtype, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id ! Dataspace identifier
        INTEGER, INTENT(OUT) :: classtype      ! Class type
                                               ! Valid values are:
                                               !    H5S_NO_CLASS_F
                                               !    H5S_SCALAR_F
                                               !    H5S_SIMPLE_F
        INTEGER, INTENT(OUT) :: hdferr         ! Error code
                                               ! 0 on success and -1 on failure
      END SUBROUTINE h5sget_simple_extent_type_f

Name: H5Sis_simple
Signature:
  htri_t `H5Sis_simple`(hid_t `space_id`)
Purpose:
  Determines whether a dataspace is a simple dataspace.
Description:
  `H5Sis_simple` determines whether a dataspace is a simple dataspace. [Currently, all dataspace objects are simple dataspaces, complex dataspace support will be added in the future]
Parameters:

hid_t `space_id`
  Identifier of the dataspace to query

Returns:
  When successful, returns a positive value, for `TRUE`, or `0` (zero), for `FALSE`. Otherwise returns a negative value.
Fortran90 Interface: h5sis_simple_f

      SUBROUTINE h5sis_simple_f(space_id, flag, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id    ! Dataspace identifier
        LOGICAL, INTENT(OUT) :: flag              ! Flag, idicates if dataspace
                                                  ! is simple or not:
                                                  ! TRUE or FALSE
        INTEGER, INTENT(OUT) :: hdferr            ! Error code
                                                  ! 0 on success and -1 on failure
      END SUBROUTINE h5sis_simple_f

Name: H5Soffset_simple
Signature:
  herr_t `H5Soffset_simple`(hid_t `space_id`, const hssize_t *`offset` )
Purpose:
  Sets the offset of a simple dataspace.
Description:
  `H5Soffset_simple` sets the offset of a simple dataspace `space_id`. The `offset` array must be the same number of elements as the number of dimensions for the dataspace. If the `offset` array is set to `NULL`, the offset for the dataspace is reset to 0.

  This function allows the same shaped selection to be moved to different locations within a dataspace without requiring it to be redefined.

Parameters:

hid_t `space_id`
  IN: The identifier for the dataspace object to reset.
const hssize_t *`offset`
  IN: The offset at which to position the selection.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5soffset_simple_f

      SUBROUTINE h5soffset_simple_f(space_id, offset, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id    ! Dataspace identifier
        INTEGER(HSSIZE_T), DIMENSION(*), INTENT(IN) ::  offset
                                                  ! The offset at which to position
                                                  ! the selection
        INTEGER, INTENT(OUT) :: hdferr            ! Error code
                                                  ! 0 on success and -1 on failure
      END SUBROUTINE h5soffset_simple_f

Name: H5Sselect_all
Signature:
  herr_t `H5Sselect_all`(hid_t `space_id`)
Purpose:
  Selects the entire dataspace.
Description:
  `H5Sselect_all` selects the entire extent of the dataspace `space_id`.

  More specifically, `H5Sselect_all` selects the special `5S_SELECT_ALL` region for the dataspace `space_id`. `H5S_SELECT_ALL` selects the entire dataspace for any dataspace it is applied to.

Parameters:

hid_t `space_id`
  IN: The identifier for the dataspace in which the selection is being made.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sselect_all_f

      SUBROUTINE h5sselect_all_f(space_id, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id  ! Dataspace identifier
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
      END SUBROUTINE h5sselect_all_f

Name: H5Sselect_elements
Signature:
  herr_t `H5Sselect_elements`(hid_t `space_id`, H5S_seloper_t `op`, const size_t `num_elements`, const hssize_t *`coord`[ ] )
Purpose:
  Selects array elements to be included in the selection for a dataspace.
Description:
  `H5Sselect_elements` selects array elements to be included in the selection for the `space_id` dataspace.

  The number of elements selected is set in the `num_elements` parameter.

  The `coord` array is a two-dimensional array of size `dataspace_rank` by `num_elements` containing a list of of zero-based values specifying the coordinates in the dataset of the selected elements. The order of the element coordinates in the `coord` array specifies the order in which the array elements are iterated through when I/O is performed. Duplicate coordinate locations are not checked for.

  The selection operator `op` determines how the new selection is to be combined with the previously existing selection for the dataspace. The following operators are supported:

  `H5S_SELECT_SET` | Replaces the existing selection with the parameters from this call. Overlapping blocks are not supported with this operator. Adds the new selection to the existing selection.
  `H5S_SELECT_APPEND` | Adds the new selection following the last element of the existing selection.
  `H5S_SELECT_PREPEND` | Adds the new selection preceding the first element of the existing selection.

Parameters:

hid_t `space_id`
  Identifier of the dataspace.
H5S_seloper_t `op`
  Operator specifying how the new selection is to be combined with the existing selection for the dataspace.
const size_t `num_elements`
  Number of elements to be selected.
const hssize_t *`coord`[ ]
  A 2-dimensional array of 0-based values specifying the coordinates of the elements being selected.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sselect_elements_f

      SUBROUTINE h5sselect_elements_f(space_id, operator, num_elements, &
                                      coord, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id  ! Dataspace identifier
        INTEGER, INTENT(IN) :: op               ! Flag, valid values are:
                                                !    H5S_SELECT_SET_F
                                                !    H5S_SELECT_OR_F
        INTEGER, INTENT(IN) :: num_elements     ! Number of elements to be selected
        INTEGER(HSSIZE_T), DIMENSION(*,*), INTENT(IN) :: coord
                                                ! Array with the coordinates
                                                ! of the selected elements:
                                                ! coord(num_elements, rank)
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
      END SUBROUTINE h5sselect_elements_f

Name: H5Sselect_hyperslab
Signature:
  herr_t `H5Sselect_hyperslab`(hid_t `space_id`, H5S_seloper_t `op`, const hssize_t *`start`, const hsize_t *`stride`, const hsize_t *`count`, const hsize_t *`block` )
Purpose:
  Selects a hyperslab region to add to the current selected region.
Description:
  `H5Sselect_hyperslab` selects a hyperslab region to add to the current selected region for the dataspace specified by `space_id`.

  The `start`, `stride`, `count`, and `block` arrays must be the same size as the rank of the dataspace.

  The selection operator `op` determines how the new selection is to be combined with the already existing selection for the dataspace. The following operators are supported:

  `H5S_SELECT_SET` | Replaces the existing selection with the parameters from this call. Overlapping blocks are not supported with this operator.
  `H5S_SELECT_OR` | Adds the new selection to the existing selection. (Binary OR)
  `H5S_SELECT_AND` | Retains only the overlapping portions of the new selection and the existing selection. (Binary AND)
  `H5S_SELECT_XOR` | Retains only the elements that are members of the new selection or the existing selection, excluding elements that are members of both selections. (Binary exclusive-OR, XOR)
  `H5S_SELECT_NOTB` | Retains only elements of the existing selection that are not in the new selection.
  `H5S_SELECT_NOTA` | Retains only elements of the new selection that are not in the existing selection.

  The `start` array determines the starting coordinates of the hyperslab to select.

  The `stride` array chooses array locations from the dataspace with each value in the `stride` array determining how many elements to move in each dimension. Setting a value in the `stride` array to 1 moves to each element in that dimension of the dataspace; setting a value of `2` in alocation in the `stride` array moves to every other element in that dimension of the dataspace. In other words, the `stride` determines the number of elements to move from the `start` location in each dimension. Stride values of `0` are not allowed. If the `stride` parameter is `NULL`, a contiguous hyperslab is selected (as if each value in the `stride` array were set to all 1's).

  The `count` array determines how many blocks to select from the dataspace, in each dimension.

  The `block` array determines the size of the element block selected from the dataspace. If the `block` parameter is set to `NULL`, the block size defaults to a single element in each dimension (as if the `block` array were set to all `1`'s).

  For example, in a 2-dimensional dataspace, setting `start` to [1,1], `stride` to [4,4], `count` to [3,7], and `block` to [2,2] selects 21 2x2 blocks of array elements starting with location (1,1) and selecting blocks at locations (1,1), (5,1), (9,1), (1,5), (5,5), etc.

  Regions selected with this function call default to C order iteration when I/O is performed.

Parameters:

hid_t `space_id`
  IN: Identifier of dataspace selection to modify
H5S_seloper_t `op`
  IN: Operation to perform on current selection.
const hssize_t *`start`
  IN: Offset of start of hyperslab
const hsize_t *`count`
  IN: Number of blocks included in hyperslab.
const hsize_t *`stride`
  IN: Hyperslab stride.
const hsize_t *`block`
  IN: Size of block in hyperslab.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sselect_hyperslab_f

      SUBROUTINE h5sselect_hyperslab_f(space_id, operator, start, count, &
                                       hdferr, stride, block)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id  ! Dataspace identifier
        INTEGER, INTENT(IN) :: op               ! Flag, valid values are:
                                                !    H5S_SELECT_SET_F
                                                !    H5S_SELECT_OR_F
        INTEGER(HSSIZE_T), DIMENSION(*), INTENT(IN) :: start
                                                ! Starting coordinates of hyperslab
        INTEGER(HSIZE_T), DIMENSION(*), INTENT(IN) :: count
                                                ! Number of blocks to select
                                                ! from dataspace
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
        INTEGER(HSIZE_T), DIMENSION(*), OPTIONAL, INTENT(IN) :: stride
                                                ! Array of how many elements to
                                                ! move in each direction
        INTEGER(HSIZE_T), DIMENSION(*), OPTIONAL, INTENT(IN) :: block
                                                ! Size of the element block
      END SUBROUTINE h5sselect_hyperslab_f

Name: H5Sselect_none
Signature:
  herr_t `H5Sselect_none`(hid_t `space_id`)
Purpose:
  Resets the selection region to include no elements.
Description:
  `H5Sselect_none` resets the selection region for the dataspace `space_id` to include no elements.
Parameters:

hid_t `space_id`
  IN: The identifier for the dataspace in which the selection is being reset.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sselect_none_f

      SUBROUTINE h5sselect_none_f(space_id, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id  ! Dataspace identifier
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
      END SUBROUTINE h5sselect_none_f

Name: H5Sselect_valid
Signature:
  htri_t `H5Sselect_valid`(hid_t `space_id`)
Purpose:
  Verifies that the selection is within the extent of the dataspace.
Description:
  `H5Sselect_valid` verifies that the selection for the dataspace `space_id` is within the extent of the dataspace if the current offset for the dataspace is used.
Parameters:

hid_t `space_id`
  The identifier for the dataspace being queried.

Returns:
  Returns a positive value, for `TRUE`, if the selection is contained within the extent or `0` (zero), for `FALSE`, if it is not. Returns a negative value on error conditions such as the selection or extent not being defined.
Fortran90 Interface: h5sselect_valid_f

      SUBROUTINE h5sselect_valid_f(space_id, flag, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id  ! Dataspace identifier
        LOGICAL, INTENT(OUT) :: flag            ! TRUE if the selection is
                                                ! contained within the extent,
                                                ! FALSE otherwise.
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
      END SUBROUTINE h5sselect_valid_f

Name: H5Sset_extent_none
Signature:
  herr_t `H5Sset_extent_none`(hid_t `space_id`)
Purpose:
  Removes the extent from a dataspace.
Description:
  `H5Sset_extent_none` removes the extent from a dataspace and sets the type to `H5S_NO_CLASS`.
Parameters:

hid_t `space_id`
  The identifier for the dataspace from which the extent is to be removed.

Returns:
  Returns a non-negative value if successful; otherwise returns a negative value.
Fortran90 Interface: h5sset_extent_none_f

      SUBROUTINE h5sset_extent_none_f(space_id, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id  ! Dataspace identifier
        INTEGER, INTENT(OUT) :: hdferr          ! Error code
                                                ! 0 on success and -1 on failure
      END SUBROUTINE h5sset_extent_none_f

Name: H5Sset_extent_simple
Signature:
  herr_t `H5Sset_extent_simple`(hid_t `space_id`, int `rank`, const hsize_t *`current_size`, const hsize_t *`maximum_size` )
Purpose:
  Sets or resets the size of an existing dataspace.
Description:
  `H5Sset_extent_simple` sets or resets the size of an existing dataspace.

  `rank` is the dimensionality, or number of dimensions, of the dataspace.

  `current_size` is an array of size `rank` which contains the new size of each dimension in the dataspace. `maximum_size` is an array of size `rank` which contains the maximum size of each dimension in the dataspace.

  Any previous extent is removed from the dataspace, the dataspace type is set to `H5S_SIMPLE`, and the extent is set as specified.

Parameters:

hid_t `space_id`
  Dataspace identifier.
int `rank`
  Rank, or dimensionality, of the dataspace.
const hsize_t *`current_size`
  Array containing current size of dataspace.
const hsize_t *`maximum_size`
  Array containing maximum size of dataspace.

Returns:
  Returns a dataspace identifier if successful; otherwise returns a negative value.
Fortran90 Interface: h5sset_extent_simple_f

      SUBROUTINE h5sset_extent_simple_f(space_id, rank, current_size, &
                                        maximum_size, hdferr)
        IMPLICIT NONE
        INTEGER(HID_T), INTENT(IN) :: space_id     ! Dataspace identifier
        INTEGER, INTENT(IN) :: rank                ! Dataspace rank
        INTEGER(HSIZE_T), DIMENSION(rank), INTENT(IN) :: current_size
                                                   ! Array with the new sizes
                                                   ! of dimensions
        INTEGER(HSIZE_T), DIMENSION(rank), INTENT(IN) ::
                                                   ! Array with the new maximum
                                                   ! sizes of dimensions
        INTEGER, INTENT(OUT) :: hdferr             ! Error code
                                                   ! 0 on success and -1 on failure
      END SUBROUTINE h5sset_extent_simple_f

HDF5 documents and links Introduction to HDF5 HDF5 User Guide | And in this document, the HDF5 Reference Manual H5 H5A H5D H5E H5F H5G H5I H5P H5R H5S H5T H5Z Tools Datatypes