Deleted vendor folder

1 files changed, 0 insertions, 854 deletions

diff --git a/vendor/half/src/slice.rs b/vendor/half/src/slice.rs
deleted file mode 100644
index f1e9feb..0000000
--- a/vendor/half/src/slice.rs
+++ /dev/null
@@ -1,854 +0,0 @@
-//! 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()]);
-    /// ```
-    #[must_use]
-    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.)]);
-    /// ```
-    #[must_use]
-    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")))]
-    #[must_use]
-    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")))]
-    #[must_use]
-    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>();
-    /// ```
-    #[must_use]
-    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>();
-    /// ```
-    #[must_use]
-    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_mut_ptr().cast::<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"
-        );
-
-        convert::f32_to_f16_slice(src, self.reinterpret_cast_mut())
-    }
-
-    fn convert_from_f64_slice(&mut self, src: &[f64]) {
-        assert_eq!(
-            self.len(),
-            src.len(),
-            "destination and source slices have different lengths"
-        );
-
-        convert::f64_to_f16_slice(src, self.reinterpret_cast_mut())
-    }
-
-    fn convert_to_f32_slice(&self, dst: &mut [f32]) {
-        assert_eq!(
-            self.len(),
-            dst.len(),
-            "destination and source slices have different lengths"
-        );
-
-        convert::f16_to_f32_slice(self.reinterpret_cast(), dst)
-    }
-
-    fn convert_to_f64_slice(&self, dst: &mut [f64]) {
-        assert_eq!(
-            self.len(),
-            dst.len(),
-            "destination and source slices have different lengths"
-        );
-
-        convert::f16_to_f64_slice(self.reinterpret_cast(), dst)
-    }
-
-    #[cfg(any(feature = "alloc", feature = "std"))]
-    #[inline]
-    #[allow(clippy::uninit_vec)]
-    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]
-    #[allow(clippy::uninit_vec)]
-    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_mut_ptr().cast::<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]
-    #[allow(clippy::uninit_vec)]
-    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]
-    #[allow(clippy::uninit_vec)]
-    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) }
-    }
-}
-
-#[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);
-    }
-}