Revision control
Copy as Markdown
Other Tools
//! Contains utility functions and traits to convert between slices of [`u16`] bits and [`f16`] or
//! [`bf16`] numbers.
//!
//! The utility [`HalfBitsSliceExt`] sealed extension trait is implemented for `[u16]` slices,
//! while the utility [`HalfFloatSliceExt`] sealed extension trait is implemented for both `[f16]`
//! and `[bf16]` slices. 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.
use crate::{bf16, binary16::convert, f16};
#[cfg(feature = "alloc")]
use alloc::vec::Vec;
use core::slice;
/// Extensions to `[f16]` and `[bf16]` slices to support conversion and reinterpret operations.
///
/// This trait is sealed and cannot be implemented outside of this crate.
pub trait HalfFloatSliceExt: private::SealedHalfFloatSlice {
/// Reinterprets a slice of [`f16`] or [`bf16`] numbers as a slice of [`u16`] bits.
///
/// This is a zero-copy operation. The reinterpreted slice has the same lifetime and memory
/// location as `self`.
///
/// # Examples
///
/// ```rust
/// # use half::prelude::*;
/// let float_buffer = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)];
/// let int_buffer = float_buffer.reinterpret_cast();
///
/// assert_eq!(int_buffer, [float_buffer[0].to_bits(), float_buffer[1].to_bits(), float_buffer[2].to_bits()]);
/// ```
fn reinterpret_cast(&self) -> &[u16];
/// Reinterprets a mutable slice of [`f16`] or [`bf16`] numbers as a mutable slice of [`u16`].
/// bits
///
/// This is a zero-copy operation. The transmuted slice has the same lifetime as the original,
/// which prevents mutating `self` as long as the returned `&mut [u16]` is borrowed.
///
/// # Examples
///
/// ```rust
/// # use half::prelude::*;
/// let mut float_buffer = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)];
///
/// {
/// let int_buffer = float_buffer.reinterpret_cast_mut();
///
/// assert_eq!(int_buffer, [f16::from_f32(1.).to_bits(), f16::from_f32(2.).to_bits(), f16::from_f32(3.).to_bits()]);
///
/// // Mutating the u16 slice will mutating the original
/// int_buffer[0] = 0;
/// }
///
/// // Note that we need to drop int_buffer before using float_buffer again or we will get a borrow error.
/// assert_eq!(float_buffer, [f16::from_f32(0.), f16::from_f32(2.), f16::from_f32(3.)]);
/// ```
fn reinterpret_cast_mut(&mut self) -> &mut [u16];
/// Converts all of the elements of a `[f32]` slice into [`f16`] or [`bf16`] values in `self`.
///
/// The length of `src` must be the same as `self`.
///
/// 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.
///
/// # Panics
///
/// This function will panic if the two slices have different lengths.
///
/// # Examples
/// ```rust
/// # use half::prelude::*;
/// // Initialize an empty buffer
/// let mut buffer = [0u16; 4];
/// let buffer = buffer.reinterpret_cast_mut::<f16>();
///
/// let float_values = [1., 2., 3., 4.];
///
/// // Now convert
/// buffer.convert_from_f32_slice(&float_values);
///
/// assert_eq!(buffer, [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.), f16::from_f32(4.)]);
/// ```
fn convert_from_f32_slice(&mut self, src: &[f32]);
/// Converts all of the elements of a `[f64]` slice into [`f16`] or [`bf16`] values in `self`.
///
/// The length of `src` must be the same as `self`.
///
/// 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.
///
/// # Panics
///
/// This function will panic if the two slices have different lengths.
///
/// # Examples
/// ```rust
/// # use half::prelude::*;
/// // Initialize an empty buffer
/// let mut buffer = [0u16; 4];
/// let buffer = buffer.reinterpret_cast_mut::<f16>();
///
/// let float_values = [1., 2., 3., 4.];
///
/// // Now convert
/// buffer.convert_from_f64_slice(&float_values);
///
/// assert_eq!(buffer, [f16::from_f64(1.), f16::from_f64(2.), f16::from_f64(3.), f16::from_f64(4.)]);
/// ```
fn convert_from_f64_slice(&mut self, src: &[f64]);
/// Converts all of the [`f16`] or [`bf16`] elements of `self` into [`f32`] values in `dst`.
///
/// The length of `src` must be the same as `self`.
///
/// 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.
///
/// # Panics
///
/// This function will panic if the two slices have different lengths.
///
/// # Examples
/// ```rust
/// # use half::prelude::*;
/// // Initialize an empty buffer
/// let mut buffer = [0f32; 4];
///
/// let half_values = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.), f16::from_f32(4.)];
///
/// // Now convert
/// half_values.convert_to_f32_slice(&mut buffer);
///
/// assert_eq!(buffer, [1., 2., 3., 4.]);
/// ```
fn convert_to_f32_slice(&self, dst: &mut [f32]);
/// Converts all of the [`f16`] or [`bf16`] elements of `self` into [`f64`] values in `dst`.
///
/// The length of `src` must be the same as `self`.
///
/// 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.
///
/// # Panics
///
/// This function will panic if the two slices have different lengths.
///
/// # Examples
/// ```rust
/// # use half::prelude::*;
/// // Initialize an empty buffer
/// let mut buffer = [0f64; 4];
///
/// let half_values = [f16::from_f64(1.), f16::from_f64(2.), f16::from_f64(3.), f16::from_f64(4.)];
///
/// // Now convert
/// half_values.convert_to_f64_slice(&mut buffer);
///
/// assert_eq!(buffer, [1., 2., 3., 4.]);
/// ```
fn convert_to_f64_slice(&self, dst: &mut [f64]);
// Because trait is sealed, we can get away with different interfaces between features.
/// Converts all of the [`f16`] or [`bf16`] elements of `self` into [`f32`] values in a new
/// 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.
///
/// This method is only available with the `std` or `alloc` feature.
///
/// # Examples
/// ```rust
/// # use half::prelude::*;
/// let half_values = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.), f16::from_f32(4.)];
/// let vec = half_values.to_f32_vec();
///
/// assert_eq!(vec, vec![1., 2., 3., 4.]);
/// ```
#[cfg(any(feature = "alloc", feature = "std"))]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
fn to_f32_vec(&self) -> Vec<f32>;
/// Converts all of the [`f16`] or [`bf16`] elements of `self` into [`f64`] values in a new
/// 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.
///
/// This method is only available with the `std` or `alloc` feature.
///
/// # Examples
/// ```rust
/// # use half::prelude::*;
/// let half_values = [f16::from_f64(1.), f16::from_f64(2.), f16::from_f64(3.), f16::from_f64(4.)];
/// let vec = half_values.to_f64_vec();
///
/// assert_eq!(vec, vec![1., 2., 3., 4.]);
/// ```
#[cfg(feature = "alloc")]
#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
fn to_f64_vec(&self) -> Vec<f64>;
}
/// Extensions to `[u16]` slices to support reinterpret operations.
///
/// This trait is sealed and cannot be implemented outside of this crate.
pub trait HalfBitsSliceExt: private::SealedHalfBitsSlice {
/// Reinterprets a slice of [`u16`] bits as a slice 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 slice has the same lifetime and memory
/// location as `self`.
///
/// # Examples
///
/// ```rust
/// # use half::prelude::*;
/// let int_buffer = [f16::from_f32(1.).to_bits(), f16::from_f32(2.).to_bits(), f16::from_f32(3.).to_bits()];
/// let float_buffer: &[f16] = int_buffer.reinterpret_cast();
///
/// assert_eq!(float_buffer, [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)]);
///
/// // You may have to specify the cast type directly if the compiler can't infer the type.
/// // The following is also valid in Rust.
/// let typed_buffer = int_buffer.reinterpret_cast::<f16>();
/// ```
fn reinterpret_cast<H>(&self) -> &[H]
where
H: crate::private::SealedHalf;
/// Reinterprets a mutable slice of [`u16`] bits as a mutable slice 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 transmuted slice has the same lifetime as the original,
/// which prevents mutating `self` as long as the returned `&mut [f16]` is borrowed.
///
/// # Examples
///
/// ```rust
/// # use half::prelude::*;
/// let mut int_buffer = [f16::from_f32(1.).to_bits(), f16::from_f32(2.).to_bits(), f16::from_f32(3.).to_bits()];
///
/// {
/// let float_buffer: &mut [f16] = int_buffer.reinterpret_cast_mut();
///
/// assert_eq!(float_buffer, [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)]);
///
/// // Mutating the f16 slice will mutating the original
/// float_buffer[0] = f16::from_f32(0.);
/// }
///
/// // Note that we need to drop float_buffer before using int_buffer again or we will get a borrow error.
/// assert_eq!(int_buffer, [f16::from_f32(0.).to_bits(), f16::from_f32(2.).to_bits(), f16::from_f32(3.).to_bits()]);
///
/// // You may have to specify the cast type directly if the compiler can't infer the type.
/// // The following is also valid in Rust.
/// let typed_buffer = int_buffer.reinterpret_cast_mut::<f16>();
/// ```
fn reinterpret_cast_mut<H>(&mut self) -> &mut [H]
where
H: crate::private::SealedHalf;
}
mod private {
use crate::{bf16, f16};
pub trait SealedHalfFloatSlice {}
impl SealedHalfFloatSlice for [f16] {}
impl SealedHalfFloatSlice for [bf16] {}
pub trait SealedHalfBitsSlice {}
impl SealedHalfBitsSlice for [u16] {}
}
impl HalfFloatSliceExt for [f16] {
#[inline]
fn reinterpret_cast(&self) -> &[u16] {
let pointer = self.as_ptr() as *const u16;
let length = self.len();
// SAFETY: We are reconstructing full length of original slice, using its same lifetime,
// and the size of elements are identical
unsafe { slice::from_raw_parts(pointer, length) }
}
#[inline]
fn reinterpret_cast_mut(&mut self) -> &mut [u16] {
let pointer = self.as_ptr() as *mut u16;
let length = self.len();
// SAFETY: We are reconstructing full length of original slice, using its same lifetime,
// and the size of elements are identical
unsafe { slice::from_raw_parts_mut(pointer, length) }
}
fn convert_from_f32_slice(&mut self, src: &[f32]) {
assert_eq!(
self.len(),
src.len(),
"destination and source slices have different lengths"
);
let mut chunks = src.chunks_exact(4);
let mut chunk_count = 0usize; // Not using .enumerate() because we need this value for remainder
for chunk in &mut chunks {
let vec = convert::f32x4_to_f16x4(chunk);
let dst_idx = chunk_count * 4;
self[dst_idx..dst_idx + 4].copy_from_slice(vec.reinterpret_cast());
chunk_count += 1;
}
// Process remainder
if !chunks.remainder().is_empty() {
let mut buf = [0f32; 4];
buf[..chunks.remainder().len()].copy_from_slice(chunks.remainder());
let vec = convert::f32x4_to_f16x4(&buf);
let dst_idx = chunk_count * 4;
self[dst_idx..dst_idx + chunks.remainder().len()]
.copy_from_slice(vec[..chunks.remainder().len()].reinterpret_cast());
}
}
fn convert_from_f64_slice(&mut self, src: &[f64]) {
assert_eq!(
self.len(),
src.len(),
"destination and source slices have different lengths"
);
let mut chunks = src.chunks_exact(4);
let mut chunk_count = 0usize; // Not using .enumerate() because we need this value for remainder
for chunk in &mut chunks {
let vec = convert::f64x4_to_f16x4(chunk);
let dst_idx = chunk_count * 4;
self[dst_idx..dst_idx + 4].copy_from_slice(vec.reinterpret_cast());
chunk_count += 1;
}
// Process remainder
if !chunks.remainder().is_empty() {
let mut buf = [0f64; 4];
buf[..chunks.remainder().len()].copy_from_slice(chunks.remainder());
let vec = convert::f64x4_to_f16x4(&buf);
let dst_idx = chunk_count * 4;
self[dst_idx..dst_idx + chunks.remainder().len()]
.copy_from_slice(vec[..chunks.remainder().len()].reinterpret_cast());
}
}
fn convert_to_f32_slice(&self, dst: &mut [f32]) {
assert_eq!(
self.len(),
dst.len(),
"destination and source slices have different lengths"
);
let mut chunks = self.chunks_exact(4);
let mut chunk_count = 0usize; // Not using .enumerate() because we need this value for remainder
for chunk in &mut chunks {
let vec = convert::f16x4_to_f32x4(chunk.reinterpret_cast());
let dst_idx = chunk_count * 4;
dst[dst_idx..dst_idx + 4].copy_from_slice(&vec);
chunk_count += 1;
}
// Process remainder
if !chunks.remainder().is_empty() {
let mut buf = [0u16; 4];
buf[..chunks.remainder().len()].copy_from_slice(chunks.remainder().reinterpret_cast());
let vec = convert::f16x4_to_f32x4(&buf);
let dst_idx = chunk_count * 4;
dst[dst_idx..dst_idx + chunks.remainder().len()]
.copy_from_slice(&vec[..chunks.remainder().len()]);
}
}
fn convert_to_f64_slice(&self, dst: &mut [f64]) {
assert_eq!(
self.len(),
dst.len(),
"destination and source slices have different lengths"
);
let mut chunks = self.chunks_exact(4);
let mut chunk_count = 0usize; // Not using .enumerate() because we need this value for remainder
for chunk in &mut chunks {
let vec = convert::f16x4_to_f64x4(chunk.reinterpret_cast());
let dst_idx = chunk_count * 4;
dst[dst_idx..dst_idx + 4].copy_from_slice(&vec);
chunk_count += 1;
}
// Process remainder
if !chunks.remainder().is_empty() {
let mut buf = [0u16; 4];
buf[..chunks.remainder().len()].copy_from_slice(chunks.remainder().reinterpret_cast());
let vec = convert::f16x4_to_f64x4(&buf);
let dst_idx = chunk_count * 4;
dst[dst_idx..dst_idx + chunks.remainder().len()]
.copy_from_slice(&vec[..chunks.remainder().len()]);
}
}
#[cfg(any(feature = "alloc", feature = "std"))]
#[inline]
fn to_f32_vec(&self) -> Vec<f32> {
let mut vec = Vec::with_capacity(self.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(self.len()) };
self.convert_to_f32_slice(&mut vec);
vec
}
#[cfg(any(feature = "alloc", feature = "std"))]
#[inline]
fn to_f64_vec(&self) -> Vec<f64> {
let mut vec = Vec::with_capacity(self.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(self.len()) };
self.convert_to_f64_slice(&mut vec);
vec
}
}
impl HalfFloatSliceExt for [bf16] {
#[inline]
fn reinterpret_cast(&self) -> &[u16] {
let pointer = self.as_ptr() as *const u16;
let length = self.len();
// SAFETY: We are reconstructing full length of original slice, using its same lifetime,
// and the size of elements are identical
unsafe { slice::from_raw_parts(pointer, length) }
}
#[inline]
fn reinterpret_cast_mut(&mut self) -> &mut [u16] {
let pointer = self.as_ptr() as *mut u16;
let length = self.len();
// SAFETY: We are reconstructing full length of original slice, using its same lifetime,
// and the size of elements are identical
unsafe { slice::from_raw_parts_mut(pointer, length) }
}
fn convert_from_f32_slice(&mut self, src: &[f32]) {
assert_eq!(
self.len(),
src.len(),
"destination and source slices have different lengths"
);
// Just use regular loop here until there's any bf16 SIMD support.
for (i, f) in src.iter().enumerate() {
self[i] = bf16::from_f32(*f);
}
}
fn convert_from_f64_slice(&mut self, src: &[f64]) {
assert_eq!(
self.len(),
src.len(),
"destination and source slices have different lengths"
);
// Just use regular loop here until there's any bf16 SIMD support.
for (i, f) in src.iter().enumerate() {
self[i] = bf16::from_f64(*f);
}
}
fn convert_to_f32_slice(&self, dst: &mut [f32]) {
assert_eq!(
self.len(),
dst.len(),
"destination and source slices have different lengths"
);
// Just use regular loop here until there's any bf16 SIMD support.
for (i, f) in self.iter().enumerate() {
dst[i] = f.to_f32();
}
}
fn convert_to_f64_slice(&self, dst: &mut [f64]) {
assert_eq!(
self.len(),
dst.len(),
"destination and source slices have different lengths"
);
// Just use regular loop here until there's any bf16 SIMD support.
for (i, f) in self.iter().enumerate() {
dst[i] = f.to_f64();
}
}
#[cfg(any(feature = "alloc", feature = "std"))]
#[inline]
fn to_f32_vec(&self) -> Vec<f32> {
let mut vec = Vec::with_capacity(self.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(self.len()) };
self.convert_to_f32_slice(&mut vec);
vec
}
#[cfg(any(feature = "alloc", feature = "std"))]
#[inline]
fn to_f64_vec(&self) -> Vec<f64> {
let mut vec = Vec::with_capacity(self.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(self.len()) };
self.convert_to_f64_slice(&mut vec);
vec
}
}
impl HalfBitsSliceExt for [u16] {
// Since we sealed all the traits involved, these are safe.
#[inline]
fn reinterpret_cast<H>(&self) -> &[H]
where
H: crate::private::SealedHalf,
{
let pointer = self.as_ptr() as *const H;
let length = self.len();
// SAFETY: We are reconstructing full length of original slice, using its same lifetime,
// and the size of elements are identical
unsafe { slice::from_raw_parts(pointer, length) }
}
#[inline]
fn reinterpret_cast_mut<H>(&mut self) -> &mut [H]
where
H: crate::private::SealedHalf,
{
let pointer = self.as_mut_ptr() as *mut H;
let length = self.len();
// SAFETY: We are reconstructing full length of original slice, using its same lifetime,
// and the size of elements are identical
unsafe { slice::from_raw_parts_mut(pointer, length) }
}
}
#[doc(hidden)]
#[deprecated(
since = "1.4.0",
note = "use `HalfBitsSliceExt::reinterpret_cast_mut` instead"
)]
#[inline]
pub fn from_bits_mut(bits: &mut [u16]) -> &mut [f16] {
bits.reinterpret_cast_mut()
}
#[doc(hidden)]
#[deprecated(
since = "1.4.0",
note = "use `HalfFloatSliceExt::reinterpret_cast_mut` instead"
)]
#[inline]
pub fn to_bits_mut(bits: &mut [f16]) -> &mut [u16] {
bits.reinterpret_cast_mut()
}
#[doc(hidden)]
#[deprecated(
since = "1.4.0",
note = "use `HalfBitsSliceExt::reinterpret_cast` instead"
)]
#[inline]
pub fn from_bits(bits: &[u16]) -> &[f16] {
bits.reinterpret_cast()
}
#[doc(hidden)]
#[deprecated(
since = "1.4.0",
note = "use `HalfFloatSliceExt::reinterpret_cast` instead"
)]
#[inline]
pub fn to_bits(bits: &[f16]) -> &[u16] {
bits.reinterpret_cast()
}
#[allow(clippy::float_cmp)]
#[cfg(test)]
mod test {
use super::{HalfBitsSliceExt, HalfFloatSliceExt};
use crate::{bf16, f16};
#[test]
fn test_slice_conversions_f16() {
let bits = &[
f16::E.to_bits(),
f16::PI.to_bits(),
f16::EPSILON.to_bits(),
f16::FRAC_1_SQRT_2.to_bits(),
];
let numbers = &[f16::E, f16::PI, f16::EPSILON, f16::FRAC_1_SQRT_2];
// Convert from bits to numbers
let from_bits = bits.reinterpret_cast::<f16>();
assert_eq!(from_bits, numbers);
// Convert from numbers back to bits
let to_bits = from_bits.reinterpret_cast();
assert_eq!(to_bits, bits);
}
#[test]
fn test_mutablility_f16() {
let mut bits_array = [f16::PI.to_bits()];
let bits = &mut bits_array[..];
{
// would not compile without these braces
let numbers = bits.reinterpret_cast_mut();
numbers[0] = f16::E;
}
assert_eq!(bits, &[f16::E.to_bits()]);
bits[0] = f16::LN_2.to_bits();
assert_eq!(bits, &[f16::LN_2.to_bits()]);
}
#[test]
fn test_slice_conversions_bf16() {
let bits = &[
bf16::E.to_bits(),
bf16::PI.to_bits(),
bf16::EPSILON.to_bits(),
bf16::FRAC_1_SQRT_2.to_bits(),
];
let numbers = &[bf16::E, bf16::PI, bf16::EPSILON, bf16::FRAC_1_SQRT_2];
// Convert from bits to numbers
let from_bits = bits.reinterpret_cast::<bf16>();
assert_eq!(from_bits, numbers);
// Convert from numbers back to bits
let to_bits = from_bits.reinterpret_cast();
assert_eq!(to_bits, bits);
}
#[test]
fn test_mutablility_bf16() {
let mut bits_array = [bf16::PI.to_bits()];
let bits = &mut bits_array[..];
{
// would not compile without these braces
let numbers = bits.reinterpret_cast_mut();
numbers[0] = bf16::E;
}
assert_eq!(bits, &[bf16::E.to_bits()]);
bits[0] = bf16::LN_2.to_bits();
assert_eq!(bits, &[bf16::LN_2.to_bits()]);
}
#[test]
fn slice_convert_f16_f32() {
// Exact chunks
let vf32 = [1., 2., 3., 4., 5., 6., 7., 8.];
let vf16 = [
f16::from_f32(1.),
f16::from_f32(2.),
f16::from_f32(3.),
f16::from_f32(4.),
f16::from_f32(5.),
f16::from_f32(6.),
f16::from_f32(7.),
f16::from_f32(8.),
];
let mut buf32 = vf32;
let mut buf16 = vf16;
vf16.convert_to_f32_slice(&mut buf32);
assert_eq!(&vf32, &buf32);
buf16.convert_from_f32_slice(&vf32);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf32 = [1., 2., 3., 4., 5., 6., 7., 8., 9.];
let vf16 = [
f16::from_f32(1.),
f16::from_f32(2.),
f16::from_f32(3.),
f16::from_f32(4.),
f16::from_f32(5.),
f16::from_f32(6.),
f16::from_f32(7.),
f16::from_f32(8.),
f16::from_f32(9.),
];
let mut buf32 = vf32;
let mut buf16 = vf16;
vf16.convert_to_f32_slice(&mut buf32);
assert_eq!(&vf32, &buf32);
buf16.convert_from_f32_slice(&vf32);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf32 = [1., 2.];
let vf16 = [f16::from_f32(1.), f16::from_f32(2.)];
let mut buf32 = vf32;
let mut buf16 = vf16;
vf16.convert_to_f32_slice(&mut buf32);
assert_eq!(&vf32, &buf32);
buf16.convert_from_f32_slice(&vf32);
assert_eq!(&vf16, &buf16);
}
#[test]
fn slice_convert_bf16_f32() {
// Exact chunks
let vf32 = [1., 2., 3., 4., 5., 6., 7., 8.];
let vf16 = [
bf16::from_f32(1.),
bf16::from_f32(2.),
bf16::from_f32(3.),
bf16::from_f32(4.),
bf16::from_f32(5.),
bf16::from_f32(6.),
bf16::from_f32(7.),
bf16::from_f32(8.),
];
let mut buf32 = vf32;
let mut buf16 = vf16;
vf16.convert_to_f32_slice(&mut buf32);
assert_eq!(&vf32, &buf32);
buf16.convert_from_f32_slice(&vf32);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf32 = [1., 2., 3., 4., 5., 6., 7., 8., 9.];
let vf16 = [
bf16::from_f32(1.),
bf16::from_f32(2.),
bf16::from_f32(3.),
bf16::from_f32(4.),
bf16::from_f32(5.),
bf16::from_f32(6.),
bf16::from_f32(7.),
bf16::from_f32(8.),
bf16::from_f32(9.),
];
let mut buf32 = vf32;
let mut buf16 = vf16;
vf16.convert_to_f32_slice(&mut buf32);
assert_eq!(&vf32, &buf32);
buf16.convert_from_f32_slice(&vf32);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf32 = [1., 2.];
let vf16 = [bf16::from_f32(1.), bf16::from_f32(2.)];
let mut buf32 = vf32;
let mut buf16 = vf16;
vf16.convert_to_f32_slice(&mut buf32);
assert_eq!(&vf32, &buf32);
buf16.convert_from_f32_slice(&vf32);
assert_eq!(&vf16, &buf16);
}
#[test]
fn slice_convert_f16_f64() {
// Exact chunks
let vf64 = [1., 2., 3., 4., 5., 6., 7., 8.];
let vf16 = [
f16::from_f64(1.),
f16::from_f64(2.),
f16::from_f64(3.),
f16::from_f64(4.),
f16::from_f64(5.),
f16::from_f64(6.),
f16::from_f64(7.),
f16::from_f64(8.),
];
let mut buf64 = vf64;
let mut buf16 = vf16;
vf16.convert_to_f64_slice(&mut buf64);
assert_eq!(&vf64, &buf64);
buf16.convert_from_f64_slice(&vf64);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf64 = [1., 2., 3., 4., 5., 6., 7., 8., 9.];
let vf16 = [
f16::from_f64(1.),
f16::from_f64(2.),
f16::from_f64(3.),
f16::from_f64(4.),
f16::from_f64(5.),
f16::from_f64(6.),
f16::from_f64(7.),
f16::from_f64(8.),
f16::from_f64(9.),
];
let mut buf64 = vf64;
let mut buf16 = vf16;
vf16.convert_to_f64_slice(&mut buf64);
assert_eq!(&vf64, &buf64);
buf16.convert_from_f64_slice(&vf64);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf64 = [1., 2.];
let vf16 = [f16::from_f64(1.), f16::from_f64(2.)];
let mut buf64 = vf64;
let mut buf16 = vf16;
vf16.convert_to_f64_slice(&mut buf64);
assert_eq!(&vf64, &buf64);
buf16.convert_from_f64_slice(&vf64);
assert_eq!(&vf16, &buf16);
}
#[test]
fn slice_convert_bf16_f64() {
// Exact chunks
let vf64 = [1., 2., 3., 4., 5., 6., 7., 8.];
let vf16 = [
bf16::from_f64(1.),
bf16::from_f64(2.),
bf16::from_f64(3.),
bf16::from_f64(4.),
bf16::from_f64(5.),
bf16::from_f64(6.),
bf16::from_f64(7.),
bf16::from_f64(8.),
];
let mut buf64 = vf64;
let mut buf16 = vf16;
vf16.convert_to_f64_slice(&mut buf64);
assert_eq!(&vf64, &buf64);
buf16.convert_from_f64_slice(&vf64);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf64 = [1., 2., 3., 4., 5., 6., 7., 8., 9.];
let vf16 = [
bf16::from_f64(1.),
bf16::from_f64(2.),
bf16::from_f64(3.),
bf16::from_f64(4.),
bf16::from_f64(5.),
bf16::from_f64(6.),
bf16::from_f64(7.),
bf16::from_f64(8.),
bf16::from_f64(9.),
];
let mut buf64 = vf64;
let mut buf16 = vf16;
vf16.convert_to_f64_slice(&mut buf64);
assert_eq!(&vf64, &buf64);
buf16.convert_from_f64_slice(&vf64);
assert_eq!(&vf16, &buf16);
// Partial with chunks
let vf64 = [1., 2.];
let vf16 = [bf16::from_f64(1.), bf16::from_f64(2.)];
let mut buf64 = vf64;
let mut buf16 = vf16;
vf16.convert_to_f64_slice(&mut buf64);
assert_eq!(&vf64, &buf64);
buf16.convert_from_f64_slice(&vf64);
assert_eq!(&vf16, &buf16);
}
#[test]
#[should_panic]
fn convert_from_f32_slice_len_mismatch_panics() {
let mut slice1 = [f16::ZERO; 3];
let slice2 = [0f32; 4];
slice1.convert_from_f32_slice(&slice2);
}
#[test]
#[should_panic]
fn convert_from_f64_slice_len_mismatch_panics() {
let mut slice1 = [f16::ZERO; 3];
let slice2 = [0f64; 4];
slice1.convert_from_f64_slice(&slice2);
}
#[test]
#[should_panic]
fn convert_to_f32_slice_len_mismatch_panics() {
let slice1 = [f16::ZERO; 3];
let mut slice2 = [0f32; 4];
slice1.convert_to_f32_slice(&mut slice2);
}
#[test]
#[should_panic]
fn convert_to_f64_slice_len_mismatch_panics() {
let slice1 = [f16::ZERO; 3];
let mut slice2 = [0f64; 4];
slice1.convert_to_f64_slice(&mut slice2);
}
}