Viewing file:  test_h5t.py (6.43 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
# This file is part of h5py, a Python interface to the HDF5 library.
#
# http://www.h5py.org
#
# Copyright 2008-2013 Andrew Collette and contributors
#
# License: Standard 3-clause BSD; see "license.txt" for full license terms
# and contributor agreement.
import numpy as np
import h5py
from h5py import h5t
from .common import TestCase, ut
class TestCompound(ut.TestCase):
"""
Feature: Compound types can be created from Python dtypes
"""
def test_ref(self):
""" Reference types are correctly stored in compound types (issue 144)
"""
dt = np.dtype([('a', h5py.ref_dtype), ('b', '<f4')])
tid = h5t.py_create(dt, logical=True)
t1, t2 = tid.get_member_type(0), tid.get_member_type(1)
self.assertEqual(t1, h5t.STD_REF_OBJ)
self.assertEqual(t2, h5t.IEEE_F32LE)
self.assertEqual(tid.get_member_offset(0), 0)
self.assertEqual(tid.get_member_offset(1), h5t.STD_REF_OBJ.get_size())
def test_out_of_order_offsets(self):
size = 20
type_dict = {
'names': ['f1', 'f2', 'f3'],
'formats': ['<f4', '<i4', '<f8'],
'offsets': [0, 16, 8]
}
expected_dtype = np.dtype(type_dict)
tid = h5t.create(h5t.COMPOUND, size)
for name, offset, dt in zip(
type_dict["names"], type_dict["offsets"], type_dict["formats"]
):
tid.insert(
name.encode("utf8") if isinstance(name, str) else name,
offset,
h5t.py_create(dt)
)
self.assertEqual(tid.dtype, expected_dtype)
self.assertEqual(tid.dtype.itemsize, size)
class TestTypeFloatID(TestCase):
"""Test TypeFloatID."""
def test_custom_float_promotion(self):
"""Custom floats are correctly promoted to standard floats on read."""
# This test uses the low-level API, so we need names as byte strings
test_filename = self.mktemp().encode()
dataset = b'DS1'
dataset2 = b'DS2'
dataset3 = b'DS3'
dataset4 = b'DS4'
dataset5 = b'DS5'
dims = (4, 7)
wdata = np.array([[-1.50066626e-09, 1.40062184e-09, 1.81216819e-10,
4.01087163e-10, 4.27917257e-10, -7.04858394e-11,
5.74800652e-10],
[-1.50066626e-09, 4.86579665e-10, 3.42879503e-10,
5.12045517e-10, 5.10226528e-10, 2.24190444e-10,
3.93356459e-10],
[-1.50066626e-09, 5.24778443e-10, 8.19454726e-10,
1.28966349e-09, 1.68483894e-10, 5.71276360e-11,
-1.08684617e-10],
[-1.50066626e-09, -1.08343556e-10, -1.58934199e-10,
8.52196536e-10, 6.18456397e-10, 6.16637408e-10,
1.31694833e-09]], dtype=np.float32)
wdata2 = np.array([[-1.50066626e-09, 5.63886715e-10, -8.74251782e-11,
1.32558853e-10, 1.59161573e-10, 2.29420039e-10,
-7.24185156e-11],
[-1.50066626e-09, 1.87810656e-10, 7.74889486e-10,
3.95630195e-10, 9.42236511e-10, 8.38554115e-10,
-8.71978045e-11],
[-1.50066626e-09, 6.20275387e-10, 7.34871719e-10,
6.64840627e-10, 2.64662958e-10, 1.05319486e-09,
1.68256520e-10],
[-1.50066626e-09, 1.67347025e-10, 5.12045517e-10,
3.36513040e-10, 1.02545528e-10, 1.28784450e-09,
4.06089384e-10]], dtype=np.float32)
# Create a new file using the default properties.
fid = h5py.h5f.create(test_filename)
# Create the dataspace. No maximum size parameter needed.
space = h5py.h5s.create_simple(dims)
# create a custom type with larger bias
mytype = h5t.IEEE_F16LE.copy()
mytype.set_fields(14, 9, 5, 0, 9)
mytype.set_size(2)
mytype.set_ebias(53)
mytype.lock()
dset = h5py.h5d.create(fid, dataset, mytype, space)
dset.write(h5py.h5s.ALL, h5py.h5s.ALL, wdata)
del dset
# create a custom type with larger exponent
mytype2 = h5t.IEEE_F16LE.copy()
mytype2.set_fields(15, 9, 6, 0, 9)
mytype2.set_size(2)
mytype2.set_ebias(53)
mytype2.lock()
dset = h5py.h5d.create(fid, dataset2, mytype2, space)
dset.write(h5py.h5s.ALL, h5py.h5s.ALL, wdata2)
del dset
# create a custom type which reimplements 16-bit floats
mytype3 = h5t.IEEE_F16LE.copy()
mytype3.set_fields(15, 10, 5, 0, 10)
mytype3.set_size(2)
mytype3.set_ebias(15)
mytype3.lock()
dset = h5py.h5d.create(fid, dataset3, mytype3, space)
dset.write(h5py.h5s.ALL, h5py.h5s.ALL, wdata2)
del dset
# create a custom type with larger bias
mytype4 = h5t.IEEE_F16LE.copy()
mytype4.set_fields(15, 10, 5, 0, 10)
mytype4.set_size(2)
mytype4.set_ebias(258)
mytype4.lock()
dset = h5py.h5d.create(fid, dataset4, mytype4, space)
dset.write(h5py.h5s.ALL, h5py.h5s.ALL, wdata2)
del dset
# create a dataset with long doubles
dset = h5py.h5d.create(fid, dataset5, h5t.NATIVE_LDOUBLE, space)
dset.write(h5py.h5s.ALL, h5py.h5s.ALL, wdata2)
# Explicitly close and release resources.
del space
del dset
del fid
f = h5py.File(test_filename, 'r')
# ebias promotion to float32
values = f[dataset][:]
np.testing.assert_array_equal(values, wdata)
self.assertEqual(values.dtype, np.dtype('<f4'))
# esize promotion to float32
values = f[dataset2][:]
np.testing.assert_array_equal(values, wdata2)
self.assertEqual(values.dtype, np.dtype('<f4'))
# regular half floats
dset = f[dataset3]
try:
self.assertEqual(dset.dtype, np.dtype('<f2'))
except AttributeError:
self.assertEqual(dset.dtype, np.dtype('<f4'))
# ebias promotion to float64
dset = f[dataset4]
self.assertEqual(dset.dtype, np.dtype('<f8'))
# long double floats
dset = f[dataset5]
self.assertEqual(dset.dtype, np.longdouble)
|