Add support for float16 (half::f16) in hdf5-types

Author: aldanor

hdf5-types/Cargo.toml

@@ -16,13 +16,15 @@ edition.workspace = true
 [features]
 h5-alloc = []
 complex = ["num-complex"]
+f16 = ["half"]
 
 [dependencies]
 ascii = "1.1"
 cfg-if = { workspace = true }
 hdf5-sys = { workspace = true }
 libc = { workspace = true }
 num-complex = { version = "0.4", optional = true, default-features = false }
+half = { version = "2.2", optional = true, default-features = false }
 
 [dev-dependencies]
 quickcheck = { version = "1.0", default-features = false }

hdf5-types/src/dyn_value.rs

@@ -117,6 +117,8 @@ impl From<DynInteger> for DynValue<'_> {
 #[derive(Copy, Clone, PartialEq)]
 pub enum DynScalar {
     Integer(DynInteger),
+    #[cfg(feature = "f16")]
+    Float16(::half::f16),
     Float32(f32),
     Float64(f64),
     Boolean(bool),
@@ -126,6 +128,8 @@ unsafe impl DynClone for DynScalar {
     fn dyn_clone(&mut self, out: &mut [u8]) {
         match self {
             Self::Integer(x) => x.dyn_clone(out),
+            #[cfg(feature = "f16")]
+            Self::Float16(x) => write_raw(out, *x),
             Self::Float32(x) => write_raw(out, *x),
             Self::Float64(x) => write_raw(out, *x),
             Self::Boolean(x) => write_raw(out, *x),
@@ -137,6 +141,8 @@ impl Debug for DynScalar {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Self::Integer(x) => Debug::fmt(&x, f),
+            #[cfg(feature = "f16")]
+            Self::Float16(x) => Debug::fmt(&x, f),
             Self::Float32(x) => Debug::fmt(&x, f),
             Self::Float64(x) => Debug::fmt(&x, f),
             Self::Boolean(x) => Debug::fmt(&x, f),
@@ -637,6 +643,8 @@ impl<'a> DynValue<'a> {
 
         match tp {
             Integer(size) | Unsigned(size) => DynInteger::read(buf, true, *size).into(),
+            #[cfg(feature = "f16")]
+            Float(FloatSize::U2) => DynScalar::Float16(read_raw(buf)).into(),
             Float(FloatSize::U4) => DynScalar::Float32(read_raw(buf)).into(),
             Float(FloatSize::U8) => DynScalar::Float64(read_raw(buf)).into(),
             Boolean => DynScalar::Boolean(read_raw(buf)).into(),

hdf5-types/src/h5type.rs

@@ -40,18 +40,24 @@ impl IntSize {
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum FloatSize {
+    #[cfg(feature = "f16")]
+    U2 = 2,
     U4 = 4,
     U8 = 8,
 }
 
 impl FloatSize {
     pub const fn from_int(size: usize) -> Option<Self> {
-        if size == 4 {
-            Some(Self::U4)
-        } else if size == 8 {
-            Some(Self::U8)
-        } else {
-            None
+        #[cfg(feature = "f16")]
+        {
+            if size == 2 {
+                return Some(Self::U2);
+            }
+        }
+        match size {
+            4 => Some(Self::U4),
+            8 => Some(Self::U8),
+            _ => None,
         }
     }
 }
@@ -167,6 +173,8 @@ impl Display for TypeDescriptor {
             TypeDescriptor::Unsigned(IntSize::U2) => write!(f, "uint16"),
             TypeDescriptor::Unsigned(IntSize::U4) => write!(f, "uint32"),
             TypeDescriptor::Unsigned(IntSize::U8) => write!(f, "uint64"),
+            #[cfg(feature = "f16")]
+            TypeDescriptor::Float(FloatSize::U2) => write!(f, "float16"),
             TypeDescriptor::Float(FloatSize::U4) => write!(f, "float32"),
             TypeDescriptor::Float(FloatSize::U8) => write!(f, "float64"),
             TypeDescriptor::Boolean => write!(f, "bool"),
@@ -251,6 +259,8 @@ impl_h5type!(u8, Unsigned, IntSize::U1);
 impl_h5type!(u16, Unsigned, IntSize::U2);
 impl_h5type!(u32, Unsigned, IntSize::U4);
 impl_h5type!(u64, Unsigned, IntSize::U8);
+#[cfg(feature = "f16")]
+impl_h5type!(::half::f16, Float, FloatSize::U2);
 impl_h5type!(f32, Float, FloatSize::U4);
 impl_h5type!(f64, Float, FloatSize::U8);