diff options
Diffstat (limited to 'vendor/half/src/vec.rs')
| -rw-r--r-- | vendor/half/src/vec.rs | 274 |
1 files changed, 0 insertions, 274 deletions
diff --git a/vendor/half/src/vec.rs b/vendor/half/src/vec.rs deleted file mode 100644 index 27ad3e7..0000000 --- a/vendor/half/src/vec.rs +++ /dev/null @@ -1,274 +0,0 @@ -//! Contains utility functions and traits to convert between vectors of [`u16`] bits and [`f16`] or -//! [`bf16`] vectors. -//! -//! The utility [`HalfBitsVecExt`] sealed extension trait is implemented for [`Vec<u16>`] vectors, -//! while the utility [`HalfFloatVecExt`] sealed extension trait is implemented for both -//! [`Vec<f16>`] and [`Vec<bf16>`] vectors. These traits provide efficient conversions and -//! reinterpret casting of larger buffers of floating point values, and are automatically included -//! in the [`prelude`][crate::prelude] module. -//! -//! This module is only available with the `std` or `alloc` feature. - -use super::{bf16, f16, slice::HalfFloatSliceExt}; -#[cfg(feature = "alloc")] -use alloc::vec::Vec; -use core::mem; - -/// Extensions to [`Vec<f16>`] and [`Vec<bf16>`] to support reinterpret operations. -/// -/// This trait is sealed and cannot be implemented outside of this crate. -pub trait HalfFloatVecExt: private::SealedHalfFloatVec { - /// Reinterprets a vector of [`f16`]or [`bf16`] numbers as a vector of [`u16`] bits. - /// - /// This is a zero-copy operation. The reinterpreted vector has the same memory location as - /// `self`. - /// - /// # Examples - /// - /// ```rust - /// # use half::prelude::*; - /// let float_buffer = vec![f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)]; - /// let int_buffer = float_buffer.reinterpret_into(); - /// - /// assert_eq!(int_buffer, [f16::from_f32(1.).to_bits(), f16::from_f32(2.).to_bits(), f16::from_f32(3.).to_bits()]); - /// ``` - #[must_use] - fn reinterpret_into(self) -> Vec<u16>; - - /// Converts all of the elements of a `[f32]` slice into a new [`f16`] or [`bf16`] vector. - /// - /// The conversion operation is vectorized over the slice, meaning the conversion may be more - /// efficient than converting individual elements on some hardware that supports SIMD - /// conversions. See [crate documentation][crate] for more information on hardware conversion - /// support. - /// - /// # Examples - /// ```rust - /// # use half::prelude::*; - /// let float_values = [1., 2., 3., 4.]; - /// let vec: Vec<f16> = Vec::from_f32_slice(&float_values); - /// - /// assert_eq!(vec, vec![f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.), f16::from_f32(4.)]); - /// ``` - #[must_use] - fn from_f32_slice(slice: &[f32]) -> Self; - - /// Converts all of the elements of a `[f64]` slice into a new [`f16`] or [`bf16`] vector. - /// - /// The conversion operation is vectorized over the slice, meaning the conversion may be more - /// efficient than converting individual elements on some hardware that supports SIMD - /// conversions. See [crate documentation][crate] for more information on hardware conversion - /// support. - /// - /// # Examples - /// ```rust - /// # use half::prelude::*; - /// let float_values = [1., 2., 3., 4.]; - /// let vec: Vec<f16> = Vec::from_f64_slice(&float_values); - /// - /// assert_eq!(vec, vec![f16::from_f64(1.), f16::from_f64(2.), f16::from_f64(3.), f16::from_f64(4.)]); - /// ``` - #[must_use] - fn from_f64_slice(slice: &[f64]) -> Self; -} - -/// Extensions to [`Vec<u16>`] to support reinterpret operations. -/// -/// This trait is sealed and cannot be implemented outside of this crate. -pub trait HalfBitsVecExt: private::SealedHalfBitsVec { - /// Reinterprets a vector of [`u16`] bits as a vector of [`f16`] or [`bf16`] numbers. - /// - /// `H` is the type to cast to, and must be either the [`f16`] or [`bf16`] type. - /// - /// This is a zero-copy operation. The reinterpreted vector has the same memory location as - /// `self`. - /// - /// # Examples - /// - /// ```rust - /// # use half::prelude::*; - /// let int_buffer = vec![f16::from_f32(1.).to_bits(), f16::from_f32(2.).to_bits(), f16::from_f32(3.).to_bits()]; - /// let float_buffer = int_buffer.reinterpret_into::<f16>(); - /// - /// assert_eq!(float_buffer, [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)]); - /// ``` - #[must_use] - fn reinterpret_into<H>(self) -> Vec<H> - where - H: crate::private::SealedHalf; -} - -mod private { - use crate::{bf16, f16}; - #[cfg(feature = "alloc")] - use alloc::vec::Vec; - - pub trait SealedHalfFloatVec {} - impl SealedHalfFloatVec for Vec<f16> {} - impl SealedHalfFloatVec for Vec<bf16> {} - - pub trait SealedHalfBitsVec {} - impl SealedHalfBitsVec for Vec<u16> {} -} - -impl HalfFloatVecExt for Vec<f16> { - #[inline] - fn reinterpret_into(mut self) -> Vec<u16> { - // An f16 array has same length and capacity as u16 array - let length = self.len(); - let capacity = self.capacity(); - - // Actually reinterpret the contents of the Vec<f16> as u16, - // knowing that structs are represented as only their members in memory, - // which is the u16 part of `f16(u16)` - let pointer = self.as_mut_ptr() as *mut u16; - - // Prevent running a destructor on the old Vec<u16>, so the pointer won't be deleted - mem::forget(self); - - // Finally construct a new Vec<f16> from the raw pointer - // SAFETY: We are reconstructing full length and capacity of original vector, - // using its original pointer, and the size of elements are identical. - unsafe { Vec::from_raw_parts(pointer, length, capacity) } - } - - #[allow(clippy::uninit_vec)] - fn from_f32_slice(slice: &[f32]) -> Self { - let mut vec = Vec::with_capacity(slice.len()); - // SAFETY: convert will initialize every value in the vector without reading them, - // so this is safe to do instead of double initialize from resize, and we're setting it to - // same value as capacity. - unsafe { vec.set_len(slice.len()) }; - vec.convert_from_f32_slice(slice); - vec - } - - #[allow(clippy::uninit_vec)] - fn from_f64_slice(slice: &[f64]) -> Self { - let mut vec = Vec::with_capacity(slice.len()); - // SAFETY: convert will initialize every value in the vector without reading them, - // so this is safe to do instead of double initialize from resize, and we're setting it to - // same value as capacity. - unsafe { vec.set_len(slice.len()) }; - vec.convert_from_f64_slice(slice); - vec - } -} - -impl HalfFloatVecExt for Vec<bf16> { - #[inline] - fn reinterpret_into(mut self) -> Vec<u16> { - // An f16 array has same length and capacity as u16 array - let length = self.len(); - let capacity = self.capacity(); - - // Actually reinterpret the contents of the Vec<f16> as u16, - // knowing that structs are represented as only their members in memory, - // which is the u16 part of `f16(u16)` - let pointer = self.as_mut_ptr() as *mut u16; - - // Prevent running a destructor on the old Vec<u16>, so the pointer won't be deleted - mem::forget(self); - - // Finally construct a new Vec<f16> from the raw pointer - // SAFETY: We are reconstructing full length and capacity of original vector, - // using its original pointer, and the size of elements are identical. - unsafe { Vec::from_raw_parts(pointer, length, capacity) } - } - - #[allow(clippy::uninit_vec)] - fn from_f32_slice(slice: &[f32]) -> Self { - let mut vec = Vec::with_capacity(slice.len()); - // SAFETY: convert will initialize every value in the vector without reading them, - // so this is safe to do instead of double initialize from resize, and we're setting it to - // same value as capacity. - unsafe { vec.set_len(slice.len()) }; - vec.convert_from_f32_slice(slice); - vec - } - - #[allow(clippy::uninit_vec)] - fn from_f64_slice(slice: &[f64]) -> Self { - let mut vec = Vec::with_capacity(slice.len()); - // SAFETY: convert will initialize every value in the vector without reading them, - // so this is safe to do instead of double initialize from resize, and we're setting it to - // same value as capacity. - unsafe { vec.set_len(slice.len()) }; - vec.convert_from_f64_slice(slice); - vec - } -} - -impl HalfBitsVecExt for Vec<u16> { - // This is safe because all traits are sealed - #[inline] - fn reinterpret_into<H>(mut self) -> Vec<H> - where - H: crate::private::SealedHalf, - { - // An f16 array has same length and capacity as u16 array - let length = self.len(); - let capacity = self.capacity(); - - // Actually reinterpret the contents of the Vec<u16> as f16, - // knowing that structs are represented as only their members in memory, - // which is the u16 part of `f16(u16)` - let pointer = self.as_mut_ptr() as *mut H; - - // Prevent running a destructor on the old Vec<u16>, so the pointer won't be deleted - mem::forget(self); - - // Finally construct a new Vec<f16> from the raw pointer - // SAFETY: We are reconstructing full length and capacity of original vector, - // using its original pointer, and the size of elements are identical. - unsafe { Vec::from_raw_parts(pointer, length, capacity) } - } -} - -#[cfg(test)] -mod test { - use super::{HalfBitsVecExt, HalfFloatVecExt}; - use crate::{bf16, f16}; - #[cfg(all(feature = "alloc", not(feature = "std")))] - use alloc::vec; - - #[test] - fn test_vec_conversions_f16() { - let numbers = vec![f16::E, f16::PI, f16::EPSILON, f16::FRAC_1_SQRT_2]; - let bits = vec![ - f16::E.to_bits(), - f16::PI.to_bits(), - f16::EPSILON.to_bits(), - f16::FRAC_1_SQRT_2.to_bits(), - ]; - let bits_cloned = bits.clone(); - - // Convert from bits to numbers - let from_bits = bits.reinterpret_into::<f16>(); - assert_eq!(&from_bits[..], &numbers[..]); - - // Convert from numbers back to bits - let to_bits = from_bits.reinterpret_into(); - assert_eq!(&to_bits[..], &bits_cloned[..]); - } - - #[test] - fn test_vec_conversions_bf16() { - let numbers = vec![bf16::E, bf16::PI, bf16::EPSILON, bf16::FRAC_1_SQRT_2]; - let bits = vec![ - bf16::E.to_bits(), - bf16::PI.to_bits(), - bf16::EPSILON.to_bits(), - bf16::FRAC_1_SQRT_2.to_bits(), - ]; - let bits_cloned = bits.clone(); - - // Convert from bits to numbers - let from_bits = bits.reinterpret_into::<bf16>(); - assert_eq!(&from_bits[..], &numbers[..]); - - // Convert from numbers back to bits - let to_bits = from_bits.reinterpret_into(); - assert_eq!(&to_bits[..], &bits_cloned[..]); - } -} |