Deleted vendor folder

9 files changed, 0 insertions, 7559 deletions

diff --git a/vendor/half/src/bfloat.rs b/vendor/half/src/bfloat.rs
deleted file mode 100644
index 8b23863..0000000
--- a/vendor/half/src/bfloat.rs
+++ /dev/null
@@ -1,1841 +0,0 @@
-#[cfg(feature = "bytemuck")]
-use bytemuck::{Pod, Zeroable};
-use core::{
-    cmp::Ordering,
-    iter::{Product, Sum},
-    num::FpCategory,
-    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign},
-};
-#[cfg(not(target_arch = "spirv"))]
-use core::{
-    fmt::{
-        Binary, Debug, Display, Error, Formatter, LowerExp, LowerHex, Octal, UpperExp, UpperHex,
-    },
-    num::ParseFloatError,
-    str::FromStr,
-};
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-#[cfg(feature = "zerocopy")]
-use zerocopy::{AsBytes, FromBytes};
-
-pub(crate) mod convert;
-
-/// A 16-bit floating point type implementing the [`bfloat16`] format.
-///
-/// The [`bfloat16`] floating point format is a truncated 16-bit version of the IEEE 754 standard
-/// `binary32`, a.k.a [`f32`]. [`bf16`] has approximately the same dynamic range as [`f32`] by
-/// having a lower precision than [`f16`][crate::f16]. While [`f16`][crate::f16] has a precision of
-/// 11 bits, [`bf16`] has a precision of only 8 bits.
-///
-/// Like [`f16`][crate::f16], [`bf16`] does not offer arithmetic operations as it is intended for
-/// compact storage rather than calculations. Operations should be performed with [`f32`] or
-/// higher-precision types and converted to/from [`bf16`] as necessary.
-///
-/// [`bfloat16`]: https://en.wikipedia.org/wiki/Bfloat16_floating-point_format
-#[allow(non_camel_case_types)]
-#[derive(Clone, Copy, Default)]
-#[repr(transparent)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "bytemuck", derive(Zeroable, Pod))]
-#[cfg_attr(feature = "zerocopy", derive(AsBytes, FromBytes))]
-pub struct bf16(u16);
-
-impl bf16 {
-    /// Constructs a [`bf16`] value from the raw bits.
-    #[inline]
-    #[must_use]
-    pub const fn from_bits(bits: u16) -> bf16 {
-        bf16(bits)
-    }
-
-    /// Constructs a [`bf16`] value from a 32-bit floating point value.
-    ///
-    /// If the 32-bit value is too large to fit, ±∞ will result. NaN values are preserved.
-    /// Subnormal values that are too tiny to be represented will result in ±0. All other values
-    /// are truncated and rounded to the nearest representable value.
-    #[inline]
-    #[must_use]
-    pub fn from_f32(value: f32) -> bf16 {
-        Self::from_f32_const(value)
-    }
-
-    /// Constructs a [`bf16`] value from a 32-bit floating point value.
-    ///
-    /// This function is identical to [`from_f32`][Self::from_f32] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`from_f32`][Self::from_f32] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// If the 32-bit value is too large to fit, ±∞ will result. NaN values are preserved.
-    /// Subnormal values that are too tiny to be represented will result in ±0. All other values
-    /// are truncated and rounded to the nearest representable value.
-    #[inline]
-    #[must_use]
-    pub const fn from_f32_const(value: f32) -> bf16 {
-        bf16(convert::f32_to_bf16(value))
-    }
-
-    /// Constructs a [`bf16`] value from a 64-bit floating point value.
-    ///
-    /// If the 64-bit value is to large to fit, ±∞ will result. NaN values are preserved.
-    /// 64-bit subnormal values are too tiny to be represented and result in ±0. Exponents that
-    /// underflow the minimum exponent will result in subnormals or ±0. All other values are
-    /// truncated and rounded to the nearest representable value.
-    #[inline]
-    #[must_use]
-    pub fn from_f64(value: f64) -> bf16 {
-        Self::from_f64_const(value)
-    }
-
-    /// Constructs a [`bf16`] value from a 64-bit floating point value.
-    ///
-    /// This function is identical to [`from_f64`][Self::from_f64] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`from_f64`][Self::from_f64] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// If the 64-bit value is to large to fit, ±∞ will result. NaN values are preserved.
-    /// 64-bit subnormal values are too tiny to be represented and result in ±0. Exponents that
-    /// underflow the minimum exponent will result in subnormals or ±0. All other values are
-    /// truncated and rounded to the nearest representable value.
-    #[inline]
-    #[must_use]
-    pub const fn from_f64_const(value: f64) -> bf16 {
-        bf16(convert::f64_to_bf16(value))
-    }
-
-    /// Converts a [`bf16`] into the underlying bit representation.
-    #[inline]
-    #[must_use]
-    pub const fn to_bits(self) -> u16 {
-        self.0
-    }
-
-    /// Returns the memory representation of the underlying bit representation as a byte array in
-    /// little-endian byte order.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let bytes = bf16::from_f32(12.5).to_le_bytes();
-    /// assert_eq!(bytes, [0x48, 0x41]);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn to_le_bytes(self) -> [u8; 2] {
-        self.0.to_le_bytes()
-    }
-
-    /// Returns the memory representation of the underlying bit representation as a byte array in
-    /// big-endian (network) byte order.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let bytes = bf16::from_f32(12.5).to_be_bytes();
-    /// assert_eq!(bytes, [0x41, 0x48]);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn to_be_bytes(self) -> [u8; 2] {
-        self.0.to_be_bytes()
-    }
-
-    /// Returns the memory representation of the underlying bit representation as a byte array in
-    /// native byte order.
-    ///
-    /// As the target platform's native endianness is used, portable code should use
-    /// [`to_be_bytes`][bf16::to_be_bytes] or [`to_le_bytes`][bf16::to_le_bytes], as appropriate,
-    /// instead.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let bytes = bf16::from_f32(12.5).to_ne_bytes();
-    /// assert_eq!(bytes, if cfg!(target_endian = "big") {
-    ///     [0x41, 0x48]
-    /// } else {
-    ///     [0x48, 0x41]
-    /// });
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn to_ne_bytes(self) -> [u8; 2] {
-        self.0.to_ne_bytes()
-    }
-
-    /// Creates a floating point value from its representation as a byte array in little endian.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let value = bf16::from_le_bytes([0x48, 0x41]);
-    /// assert_eq!(value, bf16::from_f32(12.5));
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn from_le_bytes(bytes: [u8; 2]) -> bf16 {
-        bf16::from_bits(u16::from_le_bytes(bytes))
-    }
-
-    /// Creates a floating point value from its representation as a byte array in big endian.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let value = bf16::from_be_bytes([0x41, 0x48]);
-    /// assert_eq!(value, bf16::from_f32(12.5));
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn from_be_bytes(bytes: [u8; 2]) -> bf16 {
-        bf16::from_bits(u16::from_be_bytes(bytes))
-    }
-
-    /// Creates a floating point value from its representation as a byte array in native endian.
-    ///
-    /// As the target platform's native endianness is used, portable code likely wants to use
-    /// [`from_be_bytes`][bf16::from_be_bytes] or [`from_le_bytes`][bf16::from_le_bytes], as
-    /// appropriate instead.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let value = bf16::from_ne_bytes(if cfg!(target_endian = "big") {
-    ///     [0x41, 0x48]
-    /// } else {
-    ///     [0x48, 0x41]
-    /// });
-    /// assert_eq!(value, bf16::from_f32(12.5));
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn from_ne_bytes(bytes: [u8; 2]) -> bf16 {
-        bf16::from_bits(u16::from_ne_bytes(bytes))
-    }
-
-    /// Converts a [`bf16`] value into an [`f32`] value.
-    ///
-    /// This conversion is lossless as all values can be represented exactly in [`f32`].
-    #[inline]
-    #[must_use]
-    pub fn to_f32(self) -> f32 {
-        self.to_f32_const()
-    }
-
-    /// Converts a [`bf16`] value into an [`f32`] value.
-    ///
-    /// This function is identical to [`to_f32`][Self::to_f32] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`to_f32`][Self::to_f32] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// This conversion is lossless as all values can be represented exactly in [`f32`].
-    #[inline]
-    #[must_use]
-    pub const fn to_f32_const(self) -> f32 {
-        convert::bf16_to_f32(self.0)
-    }
-
-    /// Converts a [`bf16`] value into an [`f64`] value.
-    ///
-    /// This conversion is lossless as all values can be represented exactly in [`f64`].
-    #[inline]
-    #[must_use]
-    pub fn to_f64(self) -> f64 {
-        self.to_f64_const()
-    }
-
-    /// Converts a [`bf16`] value into an [`f64`] value.
-    ///
-    /// This function is identical to [`to_f64`][Self::to_f64] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`to_f64`][Self::to_f64] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// This conversion is lossless as all values can be represented exactly in [`f64`].
-    #[inline]
-    #[must_use]
-    pub const fn to_f64_const(self) -> f64 {
-        convert::bf16_to_f64(self.0)
-    }
-
-    /// Returns `true` if this value is NaN and `false` otherwise.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let nan = bf16::NAN;
-    /// let f = bf16::from_f32(7.0_f32);
-    ///
-    /// assert!(nan.is_nan());
-    /// assert!(!f.is_nan());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_nan(self) -> bool {
-        self.0 & 0x7FFFu16 > 0x7F80u16
-    }
-
-    /// Returns `true` if this value is ±∞ and `false` otherwise.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let f = bf16::from_f32(7.0f32);
-    /// let inf = bf16::INFINITY;
-    /// let neg_inf = bf16::NEG_INFINITY;
-    /// let nan = bf16::NAN;
-    ///
-    /// assert!(!f.is_infinite());
-    /// assert!(!nan.is_infinite());
-    ///
-    /// assert!(inf.is_infinite());
-    /// assert!(neg_inf.is_infinite());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_infinite(self) -> bool {
-        self.0 & 0x7FFFu16 == 0x7F80u16
-    }
-
-    /// Returns `true` if this number is neither infinite nor NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let f = bf16::from_f32(7.0f32);
-    /// let inf = bf16::INFINITY;
-    /// let neg_inf = bf16::NEG_INFINITY;
-    /// let nan = bf16::NAN;
-    ///
-    /// assert!(f.is_finite());
-    ///
-    /// assert!(!nan.is_finite());
-    /// assert!(!inf.is_finite());
-    /// assert!(!neg_inf.is_finite());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_finite(self) -> bool {
-        self.0 & 0x7F80u16 != 0x7F80u16
-    }
-
-    /// Returns `true` if the number is neither zero, infinite, subnormal, or NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let min = bf16::MIN_POSITIVE;
-    /// let max = bf16::MAX;
-    /// let lower_than_min = bf16::from_f32(1.0e-39_f32);
-    /// let zero = bf16::from_f32(0.0_f32);
-    ///
-    /// assert!(min.is_normal());
-    /// assert!(max.is_normal());
-    ///
-    /// assert!(!zero.is_normal());
-    /// assert!(!bf16::NAN.is_normal());
-    /// assert!(!bf16::INFINITY.is_normal());
-    /// // Values between 0 and `min` are subnormal.
-    /// assert!(!lower_than_min.is_normal());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_normal(self) -> bool {
-        let exp = self.0 & 0x7F80u16;
-        exp != 0x7F80u16 && exp != 0
-    }
-
-    /// Returns the floating point category of the number.
-    ///
-    /// If only one property is going to be tested, it is generally faster to use the specific
-    /// predicate instead.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use std::num::FpCategory;
-    /// # use half::prelude::*;
-    ///
-    /// let num = bf16::from_f32(12.4_f32);
-    /// let inf = bf16::INFINITY;
-    ///
-    /// assert_eq!(num.classify(), FpCategory::Normal);
-    /// assert_eq!(inf.classify(), FpCategory::Infinite);
-    /// ```
-    #[must_use]
-    pub const fn classify(self) -> FpCategory {
-        let exp = self.0 & 0x7F80u16;
-        let man = self.0 & 0x007Fu16;
-        match (exp, man) {
-            (0, 0) => FpCategory::Zero,
-            (0, _) => FpCategory::Subnormal,
-            (0x7F80u16, 0) => FpCategory::Infinite,
-            (0x7F80u16, _) => FpCategory::Nan,
-            _ => FpCategory::Normal,
-        }
-    }
-
-    /// Returns a number that represents the sign of `self`.
-    ///
-    /// * 1.0 if the number is positive, +0.0 or [`INFINITY`][bf16::INFINITY]
-    /// * −1.0 if the number is negative, −0.0` or [`NEG_INFINITY`][bf16::NEG_INFINITY]
-    /// * [`NAN`][bf16::NAN] if the number is NaN
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let f = bf16::from_f32(3.5_f32);
-    ///
-    /// assert_eq!(f.signum(), bf16::from_f32(1.0));
-    /// assert_eq!(bf16::NEG_INFINITY.signum(), bf16::from_f32(-1.0));
-    ///
-    /// assert!(bf16::NAN.signum().is_nan());
-    /// ```
-    #[must_use]
-    pub const fn signum(self) -> bf16 {
-        if self.is_nan() {
-            self
-        } else if self.0 & 0x8000u16 != 0 {
-            Self::NEG_ONE
-        } else {
-            Self::ONE
-        }
-    }
-
-    /// Returns `true` if and only if `self` has a positive sign, including +0.0, NaNs with a
-    /// positive sign bit and +∞.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let nan = bf16::NAN;
-    /// let f = bf16::from_f32(7.0_f32);
-    /// let g = bf16::from_f32(-7.0_f32);
-    ///
-    /// assert!(f.is_sign_positive());
-    /// assert!(!g.is_sign_positive());
-    /// // NaN can be either positive or negative
-    /// assert!(nan.is_sign_positive() != nan.is_sign_negative());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_sign_positive(self) -> bool {
-        self.0 & 0x8000u16 == 0
-    }
-
-    /// Returns `true` if and only if `self` has a negative sign, including −0.0, NaNs with a
-    /// negative sign bit and −∞.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let nan = bf16::NAN;
-    /// let f = bf16::from_f32(7.0f32);
-    /// let g = bf16::from_f32(-7.0f32);
-    ///
-    /// assert!(!f.is_sign_negative());
-    /// assert!(g.is_sign_negative());
-    /// // NaN can be either positive or negative
-    /// assert!(nan.is_sign_positive() != nan.is_sign_negative());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_sign_negative(self) -> bool {
-        self.0 & 0x8000u16 != 0
-    }
-
-    /// Returns a number composed of the magnitude of `self` and the sign of `sign`.
-    ///
-    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
-    /// If `self` is NaN, then NaN with the sign of `sign` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// let f = bf16::from_f32(3.5);
-    ///
-    /// assert_eq!(f.copysign(bf16::from_f32(0.42)), bf16::from_f32(3.5));
-    /// assert_eq!(f.copysign(bf16::from_f32(-0.42)), bf16::from_f32(-3.5));
-    /// assert_eq!((-f).copysign(bf16::from_f32(0.42)), bf16::from_f32(3.5));
-    /// assert_eq!((-f).copysign(bf16::from_f32(-0.42)), bf16::from_f32(-3.5));
-    ///
-    /// assert!(bf16::NAN.copysign(bf16::from_f32(1.0)).is_nan());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn copysign(self, sign: bf16) -> bf16 {
-        bf16((sign.0 & 0x8000u16) | (self.0 & 0x7FFFu16))
-    }
-
-    /// Returns the maximum of the two numbers.
-    ///
-    /// If one of the arguments is NaN, then the other argument is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// let x = bf16::from_f32(1.0);
-    /// let y = bf16::from_f32(2.0);
-    ///
-    /// assert_eq!(x.max(y), y);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub fn max(self, other: bf16) -> bf16 {
-        if other > self && !other.is_nan() {
-            other
-        } else {
-            self
-        }
-    }
-
-    /// Returns the minimum of the two numbers.
-    ///
-    /// If one of the arguments is NaN, then the other argument is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// let x = bf16::from_f32(1.0);
-    /// let y = bf16::from_f32(2.0);
-    ///
-    /// assert_eq!(x.min(y), x);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub fn min(self, other: bf16) -> bf16 {
-        if other < self && !other.is_nan() {
-            other
-        } else {
-            self
-        }
-    }
-
-    /// Restrict a value to a certain interval unless it is NaN.
-    ///
-    /// Returns `max` if `self` is greater than `max`, and `min` if `self` is less than `min`.
-    /// Otherwise this returns `self`.
-    ///
-    /// Note that this function returns NaN if the initial value was NaN as well.
-    ///
-    /// # Panics
-    /// Panics if `min > max`, `min` is NaN, or `max` is NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// assert!(bf16::from_f32(-3.0).clamp(bf16::from_f32(-2.0), bf16::from_f32(1.0)) == bf16::from_f32(-2.0));
-    /// assert!(bf16::from_f32(0.0).clamp(bf16::from_f32(-2.0), bf16::from_f32(1.0)) == bf16::from_f32(0.0));
-    /// assert!(bf16::from_f32(2.0).clamp(bf16::from_f32(-2.0), bf16::from_f32(1.0)) == bf16::from_f32(1.0));
-    /// assert!(bf16::NAN.clamp(bf16::from_f32(-2.0), bf16::from_f32(1.0)).is_nan());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub fn clamp(self, min: bf16, max: bf16) -> bf16 {
-        assert!(min <= max);
-        let mut x = self;
-        if x < min {
-            x = min;
-        }
-        if x > max {
-            x = max;
-        }
-        x
-    }
-
-    /// Returns the ordering between `self` and `other`.
-    ///
-    /// Unlike the standard partial comparison between floating point numbers,
-    /// this comparison always produces an ordering in accordance to
-    /// the `totalOrder` predicate as defined in the IEEE 754 (2008 revision)
-    /// floating point standard. The values are ordered in the following sequence:
-    ///
-    /// - negative quiet NaN
-    /// - negative signaling NaN
-    /// - negative infinity
-    /// - negative numbers
-    /// - negative subnormal numbers
-    /// - negative zero
-    /// - positive zero
-    /// - positive subnormal numbers
-    /// - positive numbers
-    /// - positive infinity
-    /// - positive signaling NaN
-    /// - positive quiet NaN.
-    ///
-    /// The ordering established by this function does not always agree with the
-    /// [`PartialOrd`] and [`PartialEq`] implementations of `bf16`. For example,
-    /// they consider negative and positive zero equal, while `total_cmp`
-    /// doesn't.
-    ///
-    /// The interpretation of the signaling NaN bit follows the definition in
-    /// the IEEE 754 standard, which may not match the interpretation by some of
-    /// the older, non-conformant (e.g. MIPS) hardware implementations.
-    ///
-    /// # Examples
-    /// ```
-    /// # use half::bf16;
-    /// let mut v: Vec<bf16> = vec![];
-    /// v.push(bf16::ONE);
-    /// v.push(bf16::INFINITY);
-    /// v.push(bf16::NEG_INFINITY);
-    /// v.push(bf16::NAN);
-    /// v.push(bf16::MAX_SUBNORMAL);
-    /// v.push(-bf16::MAX_SUBNORMAL);
-    /// v.push(bf16::ZERO);
-    /// v.push(bf16::NEG_ZERO);
-    /// v.push(bf16::NEG_ONE);
-    /// v.push(bf16::MIN_POSITIVE);
-    ///
-    /// v.sort_by(|a, b| a.total_cmp(&b));
-    ///
-    /// assert!(v
-    ///     .into_iter()
-    ///     .zip(
-    ///         [
-    ///             bf16::NEG_INFINITY,
-    ///             bf16::NEG_ONE,
-    ///             -bf16::MAX_SUBNORMAL,
-    ///             bf16::NEG_ZERO,
-    ///             bf16::ZERO,
-    ///             bf16::MAX_SUBNORMAL,
-    ///             bf16::MIN_POSITIVE,
-    ///             bf16::ONE,
-    ///             bf16::INFINITY,
-    ///             bf16::NAN
-    ///         ]
-    ///         .iter()
-    ///     )
-    ///     .all(|(a, b)| a.to_bits() == b.to_bits()));
-    /// ```
-    // Implementation based on: https://doc.rust-lang.org/std/primitive.f32.html#method.total_cmp
-    #[inline]
-    #[must_use]
-    pub fn total_cmp(&self, other: &Self) -> Ordering {
-        let mut left = self.to_bits() as i16;
-        let mut right = other.to_bits() as i16;
-        left ^= (((left >> 15) as u16) >> 1) as i16;
-        right ^= (((right >> 15) as u16) >> 1) as i16;
-        left.cmp(&right)
-    }
-
-    /// Alternate serialize adapter for serializing as a float.
-    ///
-    /// By default, [`bf16`] serializes as a newtype of [`u16`]. This is an alternate serialize
-    /// implementation that serializes as an [`f32`] value. It is designed for use with
-    /// `serialize_with` serde attributes. Deserialization from `f32` values is already supported by
-    /// the default deserialize implementation.
-    ///
-    /// # Examples
-    ///
-    /// A demonstration on how to use this adapater:
-    ///
-    /// ```
-    /// use serde::{Serialize, Deserialize};
-    /// use half::bf16;
-    ///
-    /// #[derive(Serialize, Deserialize)]
-    /// struct MyStruct {
-    ///     #[serde(serialize_with = "bf16::serialize_as_f32")]
-    ///     value: bf16 // Will be serialized as f32 instead of u16
-    /// }
-    /// ```
-    #[cfg(feature = "serde")]
-    pub fn serialize_as_f32<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        serializer.serialize_f32(self.to_f32())
-    }
-
-    /// Alternate serialize adapter for serializing as a string.
-    ///
-    /// By default, [`bf16`] serializes as a newtype of [`u16`]. This is an alternate serialize
-    /// implementation that serializes as a string value. It is designed for use with
-    /// `serialize_with` serde attributes. Deserialization from string values is already supported
-    /// by the default deserialize implementation.
-    ///
-    /// # Examples
-    ///
-    /// A demonstration on how to use this adapater:
-    ///
-    /// ```
-    /// use serde::{Serialize, Deserialize};
-    /// use half::bf16;
-    ///
-    /// #[derive(Serialize, Deserialize)]
-    /// struct MyStruct {
-    ///     #[serde(serialize_with = "bf16::serialize_as_string")]
-    ///     value: bf16 // Will be serialized as a string instead of u16
-    /// }
-    /// ```
-    #[cfg(feature = "serde")]
-    pub fn serialize_as_string<S: serde::Serializer>(
-        &self,
-        serializer: S,
-    ) -> Result<S::Ok, S::Error> {
-        serializer.serialize_str(&self.to_string())
-    }
-
-    /// Approximate number of [`bf16`] significant digits in base 10
-    pub const DIGITS: u32 = 2;
-    /// [`bf16`]
-    /// [machine epsilon](https://en.wikipedia.org/wiki/Machine_epsilon) value
-    ///
-    /// This is the difference between 1.0 and the next largest representable number.
-    pub const EPSILON: bf16 = bf16(0x3C00u16);
-    /// [`bf16`] positive Infinity (+∞)
-    pub const INFINITY: bf16 = bf16(0x7F80u16);
-    /// Number of [`bf16`] significant digits in base 2
-    pub const MANTISSA_DIGITS: u32 = 8;
-    /// Largest finite [`bf16`] value
-    pub const MAX: bf16 = bf16(0x7F7F);
-    /// Maximum possible [`bf16`] power of 10 exponent
-    pub const MAX_10_EXP: i32 = 38;
-    /// Maximum possible [`bf16`] power of 2 exponent
-    pub const MAX_EXP: i32 = 128;
-    /// Smallest finite [`bf16`] value
-    pub const MIN: bf16 = bf16(0xFF7F);
-    /// Minimum possible normal [`bf16`] power of 10 exponent
-    pub const MIN_10_EXP: i32 = -37;
-    /// One greater than the minimum possible normal [`bf16`] power of 2 exponent
-    pub const MIN_EXP: i32 = -125;
-    /// Smallest positive normal [`bf16`] value
-    pub const MIN_POSITIVE: bf16 = bf16(0x0080u16);
-    /// [`bf16`] Not a Number (NaN)
-    pub const NAN: bf16 = bf16(0x7FC0u16);
-    /// [`bf16`] negative infinity (-∞).
-    pub const NEG_INFINITY: bf16 = bf16(0xFF80u16);
-    /// The radix or base of the internal representation of [`bf16`]
-    pub const RADIX: u32 = 2;
-
-    /// Minimum positive subnormal [`bf16`] value
-    pub const MIN_POSITIVE_SUBNORMAL: bf16 = bf16(0x0001u16);
-    /// Maximum subnormal [`bf16`] value
-    pub const MAX_SUBNORMAL: bf16 = bf16(0x007Fu16);
-
-    /// [`bf16`] 1
-    pub const ONE: bf16 = bf16(0x3F80u16);
-    /// [`bf16`] 0
-    pub const ZERO: bf16 = bf16(0x0000u16);
-    /// [`bf16`] -0
-    pub const NEG_ZERO: bf16 = bf16(0x8000u16);
-    /// [`bf16`] -1
-    pub const NEG_ONE: bf16 = bf16(0xBF80u16);
-
-    /// [`bf16`] Euler's number (ℯ)
-    pub const E: bf16 = bf16(0x402Eu16);
-    /// [`bf16`] Archimedes' constant (π)
-    pub const PI: bf16 = bf16(0x4049u16);
-    /// [`bf16`] 1/π
-    pub const FRAC_1_PI: bf16 = bf16(0x3EA3u16);
-    /// [`bf16`] 1/√2
-    pub const FRAC_1_SQRT_2: bf16 = bf16(0x3F35u16);
-    /// [`bf16`] 2/π
-    pub const FRAC_2_PI: bf16 = bf16(0x3F23u16);
-    /// [`bf16`] 2/√π
-    pub const FRAC_2_SQRT_PI: bf16 = bf16(0x3F90u16);
-    /// [`bf16`] π/2
-    pub const FRAC_PI_2: bf16 = bf16(0x3FC9u16);
-    /// [`bf16`] π/3
-    pub const FRAC_PI_3: bf16 = bf16(0x3F86u16);
-    /// [`bf16`] π/4
-    pub const FRAC_PI_4: bf16 = bf16(0x3F49u16);
-    /// [`bf16`] π/6
-    pub const FRAC_PI_6: bf16 = bf16(0x3F06u16);
-    /// [`bf16`] π/8
-    pub const FRAC_PI_8: bf16 = bf16(0x3EC9u16);
-    /// [`bf16`] 𝗅𝗇 10
-    pub const LN_10: bf16 = bf16(0x4013u16);
-    /// [`bf16`] 𝗅𝗇 2
-    pub const LN_2: bf16 = bf16(0x3F31u16);
-    /// [`bf16`] 𝗅𝗈𝗀₁₀ℯ
-    pub const LOG10_E: bf16 = bf16(0x3EDEu16);
-    /// [`bf16`] 𝗅𝗈𝗀₁₀2
-    pub const LOG10_2: bf16 = bf16(0x3E9Au16);
-    /// [`bf16`] 𝗅𝗈𝗀₂ℯ
-    pub const LOG2_E: bf16 = bf16(0x3FB9u16);
-    /// [`bf16`] 𝗅𝗈𝗀₂10
-    pub const LOG2_10: bf16 = bf16(0x4055u16);
-    /// [`bf16`] √2
-    pub const SQRT_2: bf16 = bf16(0x3FB5u16);
-}
-
-impl From<bf16> for f32 {
-    #[inline]
-    fn from(x: bf16) -> f32 {
-        x.to_f32()
-    }
-}
-
-impl From<bf16> for f64 {
-    #[inline]
-    fn from(x: bf16) -> f64 {
-        x.to_f64()
-    }
-}
-
-impl From<i8> for bf16 {
-    #[inline]
-    fn from(x: i8) -> bf16 {
-        // Convert to f32, then to bf16
-        bf16::from_f32(f32::from(x))
-    }
-}
-
-impl From<u8> for bf16 {
-    #[inline]
-    fn from(x: u8) -> bf16 {
-        // Convert to f32, then to f16
-        bf16::from_f32(f32::from(x))
-    }
-}
-
-impl PartialEq for bf16 {
-    fn eq(&self, other: &bf16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            (self.0 == other.0) || ((self.0 | other.0) & 0x7FFFu16 == 0)
-        }
-    }
-}
-
-impl PartialOrd for bf16 {
-    fn partial_cmp(&self, other: &bf16) -> Option<Ordering> {
-        if self.is_nan() || other.is_nan() {
-            None
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => Some(self.0.cmp(&other.0)),
-                (false, true) => {
-                    if (self.0 | other.0) & 0x7FFFu16 == 0 {
-                        Some(Ordering::Equal)
-                    } else {
-                        Some(Ordering::Greater)
-                    }
-                }
-                (true, false) => {
-                    if (self.0 | other.0) & 0x7FFFu16 == 0 {
-                        Some(Ordering::Equal)
-                    } else {
-                        Some(Ordering::Less)
-                    }
-                }
-                (true, true) => Some(other.0.cmp(&self.0)),
-            }
-        }
-    }
-
-    fn lt(&self, other: &bf16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 < other.0,
-                (false, true) => false,
-                (true, false) => (self.0 | other.0) & 0x7FFFu16 != 0,
-                (true, true) => self.0 > other.0,
-            }
-        }
-    }
-
-    fn le(&self, other: &bf16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 <= other.0,
-                (false, true) => (self.0 | other.0) & 0x7FFFu16 == 0,
-                (true, false) => true,
-                (true, true) => self.0 >= other.0,
-            }
-        }
-    }
-
-    fn gt(&self, other: &bf16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 > other.0,
-                (false, true) => (self.0 | other.0) & 0x7FFFu16 != 0,
-                (true, false) => false,
-                (true, true) => self.0 < other.0,
-            }
-        }
-    }
-
-    fn ge(&self, other: &bf16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 >= other.0,
-                (false, true) => true,
-                (true, false) => (self.0 | other.0) & 0x7FFFu16 == 0,
-                (true, true) => self.0 <= other.0,
-            }
-        }
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl FromStr for bf16 {
-    type Err = ParseFloatError;
-    fn from_str(src: &str) -> Result<bf16, ParseFloatError> {
-        f32::from_str(src).map(bf16::from_f32)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Debug for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:?}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Display for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl LowerExp for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:e}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl UpperExp for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:E}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Binary for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:b}", self.0)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Octal for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:o}", self.0)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl LowerHex for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:x}", self.0)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl UpperHex for bf16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:X}", self.0)
-    }
-}
-
-impl Neg for bf16 {
-    type Output = Self;
-
-    fn neg(self) -> Self::Output {
-        Self(self.0 ^ 0x8000)
-    }
-}
-
-impl Neg for &bf16 {
-    type Output = <bf16 as Neg>::Output;
-
-    #[inline]
-    fn neg(self) -> Self::Output {
-        Neg::neg(*self)
-    }
-}
-
-impl Add for bf16 {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) + Self::to_f32(rhs))
-    }
-}
-
-impl Add<&bf16> for bf16 {
-    type Output = <bf16 as Add<bf16>>::Output;
-
-    #[inline]
-    fn add(self, rhs: &bf16) -> Self::Output {
-        self.add(*rhs)
-    }
-}
-
-impl Add<&bf16> for &bf16 {
-    type Output = <bf16 as Add<bf16>>::Output;
-
-    #[inline]
-    fn add(self, rhs: &bf16) -> Self::Output {
-        (*self).add(*rhs)
-    }
-}
-
-impl Add<bf16> for &bf16 {
-    type Output = <bf16 as Add<bf16>>::Output;
-
-    #[inline]
-    fn add(self, rhs: bf16) -> Self::Output {
-        (*self).add(rhs)
-    }
-}
-
-impl AddAssign for bf16 {
-    #[inline]
-    fn add_assign(&mut self, rhs: Self) {
-        *self = (*self).add(rhs);
-    }
-}
-
-impl AddAssign<&bf16> for bf16 {
-    #[inline]
-    fn add_assign(&mut self, rhs: &bf16) {
-        *self = (*self).add(rhs);
-    }
-}
-
-impl Sub for bf16 {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) - Self::to_f32(rhs))
-    }
-}
-
-impl Sub<&bf16> for bf16 {
-    type Output = <bf16 as Sub<bf16>>::Output;
-
-    #[inline]
-    fn sub(self, rhs: &bf16) -> Self::Output {
-        self.sub(*rhs)
-    }
-}
-
-impl Sub<&bf16> for &bf16 {
-    type Output = <bf16 as Sub<bf16>>::Output;
-
-    #[inline]
-    fn sub(self, rhs: &bf16) -> Self::Output {
-        (*self).sub(*rhs)
-    }
-}
-
-impl Sub<bf16> for &bf16 {
-    type Output = <bf16 as Sub<bf16>>::Output;
-
-    #[inline]
-    fn sub(self, rhs: bf16) -> Self::Output {
-        (*self).sub(rhs)
-    }
-}
-
-impl SubAssign for bf16 {
-    #[inline]
-    fn sub_assign(&mut self, rhs: Self) {
-        *self = (*self).sub(rhs);
-    }
-}
-
-impl SubAssign<&bf16> for bf16 {
-    #[inline]
-    fn sub_assign(&mut self, rhs: &bf16) {
-        *self = (*self).sub(rhs);
-    }
-}
-
-impl Mul for bf16 {
-    type Output = Self;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) * Self::to_f32(rhs))
-    }
-}
-
-impl Mul<&bf16> for bf16 {
-    type Output = <bf16 as Mul<bf16>>::Output;
-
-    #[inline]
-    fn mul(self, rhs: &bf16) -> Self::Output {
-        self.mul(*rhs)
-    }
-}
-
-impl Mul<&bf16> for &bf16 {
-    type Output = <bf16 as Mul<bf16>>::Output;
-
-    #[inline]
-    fn mul(self, rhs: &bf16) -> Self::Output {
-        (*self).mul(*rhs)
-    }
-}
-
-impl Mul<bf16> for &bf16 {
-    type Output = <bf16 as Mul<bf16>>::Output;
-
-    #[inline]
-    fn mul(self, rhs: bf16) -> Self::Output {
-        (*self).mul(rhs)
-    }
-}
-
-impl MulAssign for bf16 {
-    #[inline]
-    fn mul_assign(&mut self, rhs: Self) {
-        *self = (*self).mul(rhs);
-    }
-}
-
-impl MulAssign<&bf16> for bf16 {
-    #[inline]
-    fn mul_assign(&mut self, rhs: &bf16) {
-        *self = (*self).mul(rhs);
-    }
-}
-
-impl Div for bf16 {
-    type Output = Self;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) / Self::to_f32(rhs))
-    }
-}
-
-impl Div<&bf16> for bf16 {
-    type Output = <bf16 as Div<bf16>>::Output;
-
-    #[inline]
-    fn div(self, rhs: &bf16) -> Self::Output {
-        self.div(*rhs)
-    }
-}
-
-impl Div<&bf16> for &bf16 {
-    type Output = <bf16 as Div<bf16>>::Output;
-
-    #[inline]
-    fn div(self, rhs: &bf16) -> Self::Output {
-        (*self).div(*rhs)
-    }
-}
-
-impl Div<bf16> for &bf16 {
-    type Output = <bf16 as Div<bf16>>::Output;
-
-    #[inline]
-    fn div(self, rhs: bf16) -> Self::Output {
-        (*self).div(rhs)
-    }
-}
-
-impl DivAssign for bf16 {
-    #[inline]
-    fn div_assign(&mut self, rhs: Self) {
-        *self = (*self).div(rhs);
-    }
-}
-
-impl DivAssign<&bf16> for bf16 {
-    #[inline]
-    fn div_assign(&mut self, rhs: &bf16) {
-        *self = (*self).div(rhs);
-    }
-}
-
-impl Rem for bf16 {
-    type Output = Self;
-
-    fn rem(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) % Self::to_f32(rhs))
-    }
-}
-
-impl Rem<&bf16> for bf16 {
-    type Output = <bf16 as Rem<bf16>>::Output;
-
-    #[inline]
-    fn rem(self, rhs: &bf16) -> Self::Output {
-        self.rem(*rhs)
-    }
-}
-
-impl Rem<&bf16> for &bf16 {
-    type Output = <bf16 as Rem<bf16>>::Output;
-
-    #[inline]
-    fn rem(self, rhs: &bf16) -> Self::Output {
-        (*self).rem(*rhs)
-    }
-}
-
-impl Rem<bf16> for &bf16 {
-    type Output = <bf16 as Rem<bf16>>::Output;
-
-    #[inline]
-    fn rem(self, rhs: bf16) -> Self::Output {
-        (*self).rem(rhs)
-    }
-}
-
-impl RemAssign for bf16 {
-    #[inline]
-    fn rem_assign(&mut self, rhs: Self) {
-        *self = (*self).rem(rhs);
-    }
-}
-
-impl RemAssign<&bf16> for bf16 {
-    #[inline]
-    fn rem_assign(&mut self, rhs: &bf16) {
-        *self = (*self).rem(rhs);
-    }
-}
-
-impl Product for bf16 {
-    #[inline]
-    fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
-        bf16::from_f32(iter.map(|f| f.to_f32()).product())
-    }
-}
-
-impl<'a> Product<&'a bf16> for bf16 {
-    #[inline]
-    fn product<I: Iterator<Item = &'a bf16>>(iter: I) -> Self {
-        bf16::from_f32(iter.map(|f| f.to_f32()).product())
-    }
-}
-
-impl Sum for bf16 {
-    #[inline]
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        bf16::from_f32(iter.map(|f| f.to_f32()).sum())
-    }
-}
-
-impl<'a> Sum<&'a bf16> for bf16 {
-    #[inline]
-    fn sum<I: Iterator<Item = &'a bf16>>(iter: I) -> Self {
-        bf16::from_f32(iter.map(|f| f.to_f32()).product())
-    }
-}
-
-#[cfg(feature = "serde")]
-struct Visitor;
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for bf16 {
-    fn deserialize<D>(deserializer: D) -> Result<bf16, D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        deserializer.deserialize_newtype_struct("bf16", Visitor)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::de::Visitor<'de> for Visitor {
-    type Value = bf16;
-
-    fn expecting(&self, formatter: &mut alloc::fmt::Formatter) -> alloc::fmt::Result {
-        write!(formatter, "tuple struct bf16")
-    }
-
-    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        Ok(bf16(<u16 as Deserialize>::deserialize(deserializer)?))
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        v.parse().map_err(|_| {
-            serde::de::Error::invalid_value(serde::de::Unexpected::Str(v), &"a float string")
-        })
-    }
-
-    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Ok(bf16::from_f32(v))
-    }
-
-    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Ok(bf16::from_f64(v))
-    }
-}
-
-#[allow(
-    clippy::cognitive_complexity,
-    clippy::float_cmp,
-    clippy::neg_cmp_op_on_partial_ord
-)]
-#[cfg(test)]
-mod test {
-    use super::*;
-    use core::cmp::Ordering;
-    #[cfg(feature = "num-traits")]
-    use num_traits::{AsPrimitive, FromPrimitive, ToPrimitive};
-    use quickcheck_macros::quickcheck;
-
-    #[cfg(feature = "num-traits")]
-    #[test]
-    fn as_primitive() {
-        let two = bf16::from_f32(2.0);
-        assert_eq!(<i32 as AsPrimitive<bf16>>::as_(2), two);
-        assert_eq!(<bf16 as AsPrimitive<i32>>::as_(two), 2);
-
-        assert_eq!(<f32 as AsPrimitive<bf16>>::as_(2.0), two);
-        assert_eq!(<bf16 as AsPrimitive<f32>>::as_(two), 2.0);
-
-        assert_eq!(<f64 as AsPrimitive<bf16>>::as_(2.0), two);
-        assert_eq!(<bf16 as AsPrimitive<f64>>::as_(two), 2.0);
-    }
-
-    #[cfg(feature = "num-traits")]
-    #[test]
-    fn to_primitive() {
-        let two = bf16::from_f32(2.0);
-        assert_eq!(ToPrimitive::to_i32(&two).unwrap(), 2i32);
-        assert_eq!(ToPrimitive::to_f32(&two).unwrap(), 2.0f32);
-        assert_eq!(ToPrimitive::to_f64(&two).unwrap(), 2.0f64);
-    }
-
-    #[cfg(feature = "num-traits")]
-    #[test]
-    fn from_primitive() {
-        let two = bf16::from_f32(2.0);
-        assert_eq!(<bf16 as FromPrimitive>::from_i32(2).unwrap(), two);
-        assert_eq!(<bf16 as FromPrimitive>::from_f32(2.0).unwrap(), two);
-        assert_eq!(<bf16 as FromPrimitive>::from_f64(2.0).unwrap(), two);
-    }
-
-    #[test]
-    fn test_bf16_consts_from_f32() {
-        let one = bf16::from_f32(1.0);
-        let zero = bf16::from_f32(0.0);
-        let neg_zero = bf16::from_f32(-0.0);
-        let neg_one = bf16::from_f32(-1.0);
-        let inf = bf16::from_f32(core::f32::INFINITY);
-        let neg_inf = bf16::from_f32(core::f32::NEG_INFINITY);
-        let nan = bf16::from_f32(core::f32::NAN);
-
-        assert_eq!(bf16::ONE, one);
-        assert_eq!(bf16::ZERO, zero);
-        assert!(zero.is_sign_positive());
-        assert_eq!(bf16::NEG_ZERO, neg_zero);
-        assert!(neg_zero.is_sign_negative());
-        assert_eq!(bf16::NEG_ONE, neg_one);
-        assert!(neg_one.is_sign_negative());
-        assert_eq!(bf16::INFINITY, inf);
-        assert_eq!(bf16::NEG_INFINITY, neg_inf);
-        assert!(nan.is_nan());
-        assert!(bf16::NAN.is_nan());
-
-        let e = bf16::from_f32(core::f32::consts::E);
-        let pi = bf16::from_f32(core::f32::consts::PI);
-        let frac_1_pi = bf16::from_f32(core::f32::consts::FRAC_1_PI);
-        let frac_1_sqrt_2 = bf16::from_f32(core::f32::consts::FRAC_1_SQRT_2);
-        let frac_2_pi = bf16::from_f32(core::f32::consts::FRAC_2_PI);
-        let frac_2_sqrt_pi = bf16::from_f32(core::f32::consts::FRAC_2_SQRT_PI);
-        let frac_pi_2 = bf16::from_f32(core::f32::consts::FRAC_PI_2);
-        let frac_pi_3 = bf16::from_f32(core::f32::consts::FRAC_PI_3);
-        let frac_pi_4 = bf16::from_f32(core::f32::consts::FRAC_PI_4);
-        let frac_pi_6 = bf16::from_f32(core::f32::consts::FRAC_PI_6);
-        let frac_pi_8 = bf16::from_f32(core::f32::consts::FRAC_PI_8);
-        let ln_10 = bf16::from_f32(core::f32::consts::LN_10);
-        let ln_2 = bf16::from_f32(core::f32::consts::LN_2);
-        let log10_e = bf16::from_f32(core::f32::consts::LOG10_E);
-        // core::f32::consts::LOG10_2 requires rustc 1.43.0
-        let log10_2 = bf16::from_f32(2f32.log10());
-        let log2_e = bf16::from_f32(core::f32::consts::LOG2_E);
-        // core::f32::consts::LOG2_10 requires rustc 1.43.0
-        let log2_10 = bf16::from_f32(10f32.log2());
-        let sqrt_2 = bf16::from_f32(core::f32::consts::SQRT_2);
-
-        assert_eq!(bf16::E, e);
-        assert_eq!(bf16::PI, pi);
-        assert_eq!(bf16::FRAC_1_PI, frac_1_pi);
-        assert_eq!(bf16::FRAC_1_SQRT_2, frac_1_sqrt_2);
-        assert_eq!(bf16::FRAC_2_PI, frac_2_pi);
-        assert_eq!(bf16::FRAC_2_SQRT_PI, frac_2_sqrt_pi);
-        assert_eq!(bf16::FRAC_PI_2, frac_pi_2);
-        assert_eq!(bf16::FRAC_PI_3, frac_pi_3);
-        assert_eq!(bf16::FRAC_PI_4, frac_pi_4);
-        assert_eq!(bf16::FRAC_PI_6, frac_pi_6);
-        assert_eq!(bf16::FRAC_PI_8, frac_pi_8);
-        assert_eq!(bf16::LN_10, ln_10);
-        assert_eq!(bf16::LN_2, ln_2);
-        assert_eq!(bf16::LOG10_E, log10_e);
-        assert_eq!(bf16::LOG10_2, log10_2);
-        assert_eq!(bf16::LOG2_E, log2_e);
-        assert_eq!(bf16::LOG2_10, log2_10);
-        assert_eq!(bf16::SQRT_2, sqrt_2);
-    }
-
-    #[test]
-    fn test_bf16_consts_from_f64() {
-        let one = bf16::from_f64(1.0);
-        let zero = bf16::from_f64(0.0);
-        let neg_zero = bf16::from_f64(-0.0);
-        let inf = bf16::from_f64(core::f64::INFINITY);
-        let neg_inf = bf16::from_f64(core::f64::NEG_INFINITY);
-        let nan = bf16::from_f64(core::f64::NAN);
-
-        assert_eq!(bf16::ONE, one);
-        assert_eq!(bf16::ZERO, zero);
-        assert_eq!(bf16::NEG_ZERO, neg_zero);
-        assert_eq!(bf16::INFINITY, inf);
-        assert_eq!(bf16::NEG_INFINITY, neg_inf);
-        assert!(nan.is_nan());
-        assert!(bf16::NAN.is_nan());
-
-        let e = bf16::from_f64(core::f64::consts::E);
-        let pi = bf16::from_f64(core::f64::consts::PI);
-        let frac_1_pi = bf16::from_f64(core::f64::consts::FRAC_1_PI);
-        let frac_1_sqrt_2 = bf16::from_f64(core::f64::consts::FRAC_1_SQRT_2);
-        let frac_2_pi = bf16::from_f64(core::f64::consts::FRAC_2_PI);
-        let frac_2_sqrt_pi = bf16::from_f64(core::f64::consts::FRAC_2_SQRT_PI);
-        let frac_pi_2 = bf16::from_f64(core::f64::consts::FRAC_PI_2);
-        let frac_pi_3 = bf16::from_f64(core::f64::consts::FRAC_PI_3);
-        let frac_pi_4 = bf16::from_f64(core::f64::consts::FRAC_PI_4);
-        let frac_pi_6 = bf16::from_f64(core::f64::consts::FRAC_PI_6);
-        let frac_pi_8 = bf16::from_f64(core::f64::consts::FRAC_PI_8);
-        let ln_10 = bf16::from_f64(core::f64::consts::LN_10);
-        let ln_2 = bf16::from_f64(core::f64::consts::LN_2);
-        let log10_e = bf16::from_f64(core::f64::consts::LOG10_E);
-        // core::f64::consts::LOG10_2 requires rustc 1.43.0
-        let log10_2 = bf16::from_f64(2f64.log10());
-        let log2_e = bf16::from_f64(core::f64::consts::LOG2_E);
-        // core::f64::consts::LOG2_10 requires rustc 1.43.0
-        let log2_10 = bf16::from_f64(10f64.log2());
-        let sqrt_2 = bf16::from_f64(core::f64::consts::SQRT_2);
-
-        assert_eq!(bf16::E, e);
-        assert_eq!(bf16::PI, pi);
-        assert_eq!(bf16::FRAC_1_PI, frac_1_pi);
-        assert_eq!(bf16::FRAC_1_SQRT_2, frac_1_sqrt_2);
-        assert_eq!(bf16::FRAC_2_PI, frac_2_pi);
-        assert_eq!(bf16::FRAC_2_SQRT_PI, frac_2_sqrt_pi);
-        assert_eq!(bf16::FRAC_PI_2, frac_pi_2);
-        assert_eq!(bf16::FRAC_PI_3, frac_pi_3);
-        assert_eq!(bf16::FRAC_PI_4, frac_pi_4);
-        assert_eq!(bf16::FRAC_PI_6, frac_pi_6);
-        assert_eq!(bf16::FRAC_PI_8, frac_pi_8);
-        assert_eq!(bf16::LN_10, ln_10);
-        assert_eq!(bf16::LN_2, ln_2);
-        assert_eq!(bf16::LOG10_E, log10_e);
-        assert_eq!(bf16::LOG10_2, log10_2);
-        assert_eq!(bf16::LOG2_E, log2_e);
-        assert_eq!(bf16::LOG2_10, log2_10);
-        assert_eq!(bf16::SQRT_2, sqrt_2);
-    }
-
-    #[test]
-    fn test_nan_conversion_to_smaller() {
-        let nan64 = f64::from_bits(0x7FF0_0000_0000_0001u64);
-        let neg_nan64 = f64::from_bits(0xFFF0_0000_0000_0001u64);
-        let nan32 = f32::from_bits(0x7F80_0001u32);
-        let neg_nan32 = f32::from_bits(0xFF80_0001u32);
-        let nan32_from_64 = nan64 as f32;
-        let neg_nan32_from_64 = neg_nan64 as f32;
-        let nan16_from_64 = bf16::from_f64(nan64);
-        let neg_nan16_from_64 = bf16::from_f64(neg_nan64);
-        let nan16_from_32 = bf16::from_f32(nan32);
-        let neg_nan16_from_32 = bf16::from_f32(neg_nan32);
-
-        assert!(nan64.is_nan() && nan64.is_sign_positive());
-        assert!(neg_nan64.is_nan() && neg_nan64.is_sign_negative());
-        assert!(nan32.is_nan() && nan32.is_sign_positive());
-        assert!(neg_nan32.is_nan() && neg_nan32.is_sign_negative());
-        assert!(nan32_from_64.is_nan() && nan32_from_64.is_sign_positive());
-        assert!(neg_nan32_from_64.is_nan() && neg_nan32_from_64.is_sign_negative());
-        assert!(nan16_from_64.is_nan() && nan16_from_64.is_sign_positive());
-        assert!(neg_nan16_from_64.is_nan() && neg_nan16_from_64.is_sign_negative());
-        assert!(nan16_from_32.is_nan() && nan16_from_32.is_sign_positive());
-        assert!(neg_nan16_from_32.is_nan() && neg_nan16_from_32.is_sign_negative());
-    }
-
-    #[test]
-    fn test_nan_conversion_to_larger() {
-        let nan16 = bf16::from_bits(0x7F81u16);
-        let neg_nan16 = bf16::from_bits(0xFF81u16);
-        let nan32 = f32::from_bits(0x7F80_0001u32);
-        let neg_nan32 = f32::from_bits(0xFF80_0001u32);
-        let nan32_from_16 = f32::from(nan16);
-        let neg_nan32_from_16 = f32::from(neg_nan16);
-        let nan64_from_16 = f64::from(nan16);
-        let neg_nan64_from_16 = f64::from(neg_nan16);
-        let nan64_from_32 = f64::from(nan32);
-        let neg_nan64_from_32 = f64::from(neg_nan32);
-
-        assert!(nan16.is_nan() && nan16.is_sign_positive());
-        assert!(neg_nan16.is_nan() && neg_nan16.is_sign_negative());
-        assert!(nan32.is_nan() && nan32.is_sign_positive());
-        assert!(neg_nan32.is_nan() && neg_nan32.is_sign_negative());
-        assert!(nan32_from_16.is_nan() && nan32_from_16.is_sign_positive());
-        assert!(neg_nan32_from_16.is_nan() && neg_nan32_from_16.is_sign_negative());
-        assert!(nan64_from_16.is_nan() && nan64_from_16.is_sign_positive());
-        assert!(neg_nan64_from_16.is_nan() && neg_nan64_from_16.is_sign_negative());
-        assert!(nan64_from_32.is_nan() && nan64_from_32.is_sign_positive());
-        assert!(neg_nan64_from_32.is_nan() && neg_nan64_from_32.is_sign_negative());
-    }
-
-    #[test]
-    fn test_bf16_to_f32() {
-        let f = bf16::from_f32(7.0);
-        assert_eq!(f.to_f32(), 7.0f32);
-
-        // 7.1 is NOT exactly representable in 16-bit, it's rounded
-        let f = bf16::from_f32(7.1);
-        let diff = (f.to_f32() - 7.1f32).abs();
-        // diff must be <= 4 * EPSILON, as 7 has two more significant bits than 1
-        assert!(diff <= 4.0 * bf16::EPSILON.to_f32());
-
-        let tiny32 = f32::from_bits(0x0001_0000u32);
-        assert_eq!(bf16::from_bits(0x0001).to_f32(), tiny32);
-        assert_eq!(bf16::from_bits(0x0005).to_f32(), 5.0 * tiny32);
-
-        assert_eq!(bf16::from_bits(0x0001), bf16::from_f32(tiny32));
-        assert_eq!(bf16::from_bits(0x0005), bf16::from_f32(5.0 * tiny32));
-    }
-
-    #[test]
-    fn test_bf16_to_f64() {
-        let f = bf16::from_f64(7.0);
-        assert_eq!(f.to_f64(), 7.0f64);
-
-        // 7.1 is NOT exactly representable in 16-bit, it's rounded
-        let f = bf16::from_f64(7.1);
-        let diff = (f.to_f64() - 7.1f64).abs();
-        // diff must be <= 4 * EPSILON, as 7 has two more significant bits than 1
-        assert!(diff <= 4.0 * bf16::EPSILON.to_f64());
-
-        let tiny64 = 2.0f64.powi(-133);
-        assert_eq!(bf16::from_bits(0x0001).to_f64(), tiny64);
-        assert_eq!(bf16::from_bits(0x0005).to_f64(), 5.0 * tiny64);
-
-        assert_eq!(bf16::from_bits(0x0001), bf16::from_f64(tiny64));
-        assert_eq!(bf16::from_bits(0x0005), bf16::from_f64(5.0 * tiny64));
-    }
-
-    #[test]
-    fn test_comparisons() {
-        let zero = bf16::from_f64(0.0);
-        let one = bf16::from_f64(1.0);
-        let neg_zero = bf16::from_f64(-0.0);
-        let neg_one = bf16::from_f64(-1.0);
-
-        assert_eq!(zero.partial_cmp(&neg_zero), Some(Ordering::Equal));
-        assert_eq!(neg_zero.partial_cmp(&zero), Some(Ordering::Equal));
-        assert!(zero == neg_zero);
-        assert!(neg_zero == zero);
-        assert!(!(zero != neg_zero));
-        assert!(!(neg_zero != zero));
-        assert!(!(zero < neg_zero));
-        assert!(!(neg_zero < zero));
-        assert!(zero <= neg_zero);
-        assert!(neg_zero <= zero);
-        assert!(!(zero > neg_zero));
-        assert!(!(neg_zero > zero));
-        assert!(zero >= neg_zero);
-        assert!(neg_zero >= zero);
-
-        assert_eq!(one.partial_cmp(&neg_zero), Some(Ordering::Greater));
-        assert_eq!(neg_zero.partial_cmp(&one), Some(Ordering::Less));
-        assert!(!(one == neg_zero));
-        assert!(!(neg_zero == one));
-        assert!(one != neg_zero);
-        assert!(neg_zero != one);
-        assert!(!(one < neg_zero));
-        assert!(neg_zero < one);
-        assert!(!(one <= neg_zero));
-        assert!(neg_zero <= one);
-        assert!(one > neg_zero);
-        assert!(!(neg_zero > one));
-        assert!(one >= neg_zero);
-        assert!(!(neg_zero >= one));
-
-        assert_eq!(one.partial_cmp(&neg_one), Some(Ordering::Greater));
-        assert_eq!(neg_one.partial_cmp(&one), Some(Ordering::Less));
-        assert!(!(one == neg_one));
-        assert!(!(neg_one == one));
-        assert!(one != neg_one);
-        assert!(neg_one != one);
-        assert!(!(one < neg_one));
-        assert!(neg_one < one);
-        assert!(!(one <= neg_one));
-        assert!(neg_one <= one);
-        assert!(one > neg_one);
-        assert!(!(neg_one > one));
-        assert!(one >= neg_one);
-        assert!(!(neg_one >= one));
-    }
-
-    #[test]
-    #[allow(clippy::erasing_op, clippy::identity_op)]
-    fn round_to_even_f32() {
-        // smallest positive subnormal = 0b0.0000_001 * 2^-126 = 2^-133
-        let min_sub = bf16::from_bits(1);
-        let min_sub_f = (-133f32).exp2();
-        assert_eq!(bf16::from_f32(min_sub_f).to_bits(), min_sub.to_bits());
-        assert_eq!(f32::from(min_sub).to_bits(), min_sub_f.to_bits());
-
-        // 0.0000000_011111 rounded to 0.0000000 (< tie, no rounding)
-        // 0.0000000_100000 rounded to 0.0000000 (tie and even, remains at even)
-        // 0.0000000_100001 rounded to 0.0000001 (> tie, rounds up)
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 0.49).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 0.50).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 0.51).to_bits(),
-            min_sub.to_bits() * 1
-        );
-
-        // 0.0000001_011111 rounded to 0.0000001 (< tie, no rounding)
-        // 0.0000001_100000 rounded to 0.0000010 (tie and odd, rounds up to even)
-        // 0.0000001_100001 rounded to 0.0000010 (> tie, rounds up)
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 1.49).to_bits(),
-            min_sub.to_bits() * 1
-        );
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 1.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 1.51).to_bits(),
-            min_sub.to_bits() * 2
-        );
-
-        // 0.0000010_011111 rounded to 0.0000010 (< tie, no rounding)
-        // 0.0000010_100000 rounded to 0.0000010 (tie and even, remains at even)
-        // 0.0000010_100001 rounded to 0.0000011 (> tie, rounds up)
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 2.49).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 2.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            bf16::from_f32(min_sub_f * 2.51).to_bits(),
-            min_sub.to_bits() * 3
-        );
-
-        assert_eq!(
-            bf16::from_f32(250.49f32).to_bits(),
-            bf16::from_f32(250.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(250.50f32).to_bits(),
-            bf16::from_f32(250.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(250.51f32).to_bits(),
-            bf16::from_f32(251.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(251.49f32).to_bits(),
-            bf16::from_f32(251.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(251.50f32).to_bits(),
-            bf16::from_f32(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(251.51f32).to_bits(),
-            bf16::from_f32(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(252.49f32).to_bits(),
-            bf16::from_f32(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(252.50f32).to_bits(),
-            bf16::from_f32(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f32(252.51f32).to_bits(),
-            bf16::from_f32(253.0).to_bits()
-        );
-    }
-
-    #[test]
-    #[allow(clippy::erasing_op, clippy::identity_op)]
-    fn round_to_even_f64() {
-        // smallest positive subnormal = 0b0.0000_001 * 2^-126 = 2^-133
-        let min_sub = bf16::from_bits(1);
-        let min_sub_f = (-133f64).exp2();
-        assert_eq!(bf16::from_f64(min_sub_f).to_bits(), min_sub.to_bits());
-        assert_eq!(f64::from(min_sub).to_bits(), min_sub_f.to_bits());
-
-        // 0.0000000_011111 rounded to 0.0000000 (< tie, no rounding)
-        // 0.0000000_100000 rounded to 0.0000000 (tie and even, remains at even)
-        // 0.0000000_100001 rounded to 0.0000001 (> tie, rounds up)
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 0.49).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 0.50).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 0.51).to_bits(),
-            min_sub.to_bits() * 1
-        );
-
-        // 0.0000001_011111 rounded to 0.0000001 (< tie, no rounding)
-        // 0.0000001_100000 rounded to 0.0000010 (tie and odd, rounds up to even)
-        // 0.0000001_100001 rounded to 0.0000010 (> tie, rounds up)
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 1.49).to_bits(),
-            min_sub.to_bits() * 1
-        );
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 1.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 1.51).to_bits(),
-            min_sub.to_bits() * 2
-        );
-
-        // 0.0000010_011111 rounded to 0.0000010 (< tie, no rounding)
-        // 0.0000010_100000 rounded to 0.0000010 (tie and even, remains at even)
-        // 0.0000010_100001 rounded to 0.0000011 (> tie, rounds up)
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 2.49).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 2.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            bf16::from_f64(min_sub_f * 2.51).to_bits(),
-            min_sub.to_bits() * 3
-        );
-
-        assert_eq!(
-            bf16::from_f64(250.49f64).to_bits(),
-            bf16::from_f64(250.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(250.50f64).to_bits(),
-            bf16::from_f64(250.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(250.51f64).to_bits(),
-            bf16::from_f64(251.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(251.49f64).to_bits(),
-            bf16::from_f64(251.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(251.50f64).to_bits(),
-            bf16::from_f64(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(251.51f64).to_bits(),
-            bf16::from_f64(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(252.49f64).to_bits(),
-            bf16::from_f64(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(252.50f64).to_bits(),
-            bf16::from_f64(252.0).to_bits()
-        );
-        assert_eq!(
-            bf16::from_f64(252.51f64).to_bits(),
-            bf16::from_f64(253.0).to_bits()
-        );
-    }
-
-    impl quickcheck::Arbitrary for bf16 {
-        fn arbitrary(g: &mut quickcheck::Gen) -> Self {
-            bf16(u16::arbitrary(g))
-        }
-    }
-
-    #[quickcheck]
-    fn qc_roundtrip_bf16_f32_is_identity(f: bf16) -> bool {
-        let roundtrip = bf16::from_f32(f.to_f32());
-        if f.is_nan() {
-            roundtrip.is_nan() && f.is_sign_negative() == roundtrip.is_sign_negative()
-        } else {
-            f.0 == roundtrip.0
-        }
-    }
-
-    #[quickcheck]
-    fn qc_roundtrip_bf16_f64_is_identity(f: bf16) -> bool {
-        let roundtrip = bf16::from_f64(f.to_f64());
-        if f.is_nan() {
-            roundtrip.is_nan() && f.is_sign_negative() == roundtrip.is_sign_negative()
-        } else {
-            f.0 == roundtrip.0
-        }
-    }
-}
diff --git a/vendor/half/src/bfloat/convert.rs b/vendor/half/src/bfloat/convert.rs
deleted file mode 100644
index 8f258f5..0000000
--- a/vendor/half/src/bfloat/convert.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-use crate::leading_zeros::leading_zeros_u16;
-use core::mem;
-
-#[inline]
-pub(crate) const fn f32_to_bf16(value: f32) -> u16 {
-    // TODO: Replace mem::transmute with to_bits() once to_bits is const-stabilized
-    // Convert to raw bytes
-    let x: u32 = unsafe { mem::transmute(value) };
-
-    // check for NaN
-    if x & 0x7FFF_FFFFu32 > 0x7F80_0000u32 {
-        // Keep high part of current mantissa but also set most significiant mantissa bit
-        return ((x >> 16) | 0x0040u32) as u16;
-    }
-
-    // round and shift
-    let round_bit = 0x0000_8000u32;
-    if (x & round_bit) != 0 && (x & (3 * round_bit - 1)) != 0 {
-        (x >> 16) as u16 + 1
-    } else {
-        (x >> 16) as u16
-    }
-}
-
-#[inline]
-pub(crate) const fn f64_to_bf16(value: f64) -> u16 {
-    // TODO: Replace mem::transmute with to_bits() once to_bits is const-stabilized
-    // Convert to raw bytes, truncating the last 32-bits of mantissa; that precision will always
-    // be lost on half-precision.
-    let val: u64 = unsafe { mem::transmute(value) };
-    let x = (val >> 32) as u32;
-
-    // Extract IEEE754 components
-    let sign = x & 0x8000_0000u32;
-    let exp = x & 0x7FF0_0000u32;
-    let man = x & 0x000F_FFFFu32;
-
-    // Check for all exponent bits being set, which is Infinity or NaN
-    if exp == 0x7FF0_0000u32 {
-        // Set mantissa MSB for NaN (and also keep shifted mantissa bits).
-        // We also have to check the last 32 bits.
-        let nan_bit = if man == 0 && (val as u32 == 0) {
-            0
-        } else {
-            0x0040u32
-        };
-        return ((sign >> 16) | 0x7F80u32 | nan_bit | (man >> 13)) as u16;
-    }
-
-    // The number is normalized, start assembling half precision version
-    let half_sign = sign >> 16;
-    // Unbias the exponent, then bias for bfloat16 precision
-    let unbiased_exp = ((exp >> 20) as i64) - 1023;
-    let half_exp = unbiased_exp + 127;
-
-    // Check for exponent overflow, return +infinity
-    if half_exp >= 0xFF {
-        return (half_sign | 0x7F80u32) as u16;
-    }
-
-    // Check for underflow
-    if half_exp <= 0 {
-        // Check mantissa for what we can do
-        if 7 - half_exp > 21 {
-            // No rounding possibility, so this is a full underflow, return signed zero
-            return half_sign as u16;
-        }
-        // Don't forget about hidden leading mantissa bit when assembling mantissa
-        let man = man | 0x0010_0000u32;
-        let mut half_man = man >> (14 - half_exp);
-        // Check for rounding
-        let round_bit = 1 << (13 - half_exp);
-        if (man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0 {
-            half_man += 1;
-        }
-        // No exponent for subnormals
-        return (half_sign | half_man) as u16;
-    }
-
-    // Rebias the exponent
-    let half_exp = (half_exp as u32) << 7;
-    let half_man = man >> 13;
-    // Check for rounding
-    let round_bit = 0x0000_1000u32;
-    if (man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0 {
-        // Round it
-        ((half_sign | half_exp | half_man) + 1) as u16
-    } else {
-        (half_sign | half_exp | half_man) as u16
-    }
-}
-
-#[inline]
-pub(crate) const fn bf16_to_f32(i: u16) -> f32 {
-    // TODO: Replace mem::transmute with from_bits() once from_bits is const-stabilized
-    // If NaN, keep current mantissa but also set most significiant mantissa bit
-    if i & 0x7FFFu16 > 0x7F80u16 {
-        unsafe { mem::transmute((i as u32 | 0x0040u32) << 16) }
-    } else {
-        unsafe { mem::transmute((i as u32) << 16) }
-    }
-}
-
-#[inline]
-pub(crate) const fn bf16_to_f64(i: u16) -> f64 {
-    // TODO: Replace mem::transmute with from_bits() once from_bits is const-stabilized
-    // Check for signed zero
-    if i & 0x7FFFu16 == 0 {
-        return unsafe { mem::transmute((i as u64) << 48) };
-    }
-
-    let half_sign = (i & 0x8000u16) as u64;
-    let half_exp = (i & 0x7F80u16) as u64;
-    let half_man = (i & 0x007Fu16) as u64;
-
-    // Check for an infinity or NaN when all exponent bits set
-    if half_exp == 0x7F80u64 {
-        // Check for signed infinity if mantissa is zero
-        if half_man == 0 {
-            return unsafe { mem::transmute((half_sign << 48) | 0x7FF0_0000_0000_0000u64) };
-        } else {
-            // NaN, keep current mantissa but also set most significiant mantissa bit
-            return unsafe {
-                mem::transmute((half_sign << 48) | 0x7FF8_0000_0000_0000u64 | (half_man << 45))
-            };
-        }
-    }
-
-    // Calculate double-precision components with adjusted exponent
-    let sign = half_sign << 48;
-    // Unbias exponent
-    let unbiased_exp = ((half_exp as i64) >> 7) - 127;
-
-    // Check for subnormals, which will be normalized by adjusting exponent
-    if half_exp == 0 {
-        // Calculate how much to adjust the exponent by
-        let e = leading_zeros_u16(half_man as u16) - 9;
-
-        // Rebias and adjust exponent
-        let exp = ((1023 - 127 - e) as u64) << 52;
-        let man = (half_man << (46 + e)) & 0xF_FFFF_FFFF_FFFFu64;
-        return unsafe { mem::transmute(sign | exp | man) };
-    }
-    // Rebias exponent for a normalized normal
-    let exp = ((unbiased_exp + 1023) as u64) << 52;
-    let man = (half_man & 0x007Fu64) << 45;
-    unsafe { mem::transmute(sign | exp | man) }
-}
diff --git a/vendor/half/src/binary16.rs b/vendor/half/src/binary16.rs
deleted file mode 100644
index b622f01..0000000
--- a/vendor/half/src/binary16.rs
+++ /dev/null
@@ -1,1912 +0,0 @@
-#[cfg(feature = "bytemuck")]
-use bytemuck::{Pod, Zeroable};
-use core::{
-    cmp::Ordering,
-    iter::{Product, Sum},
-    num::FpCategory,
-    ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Rem, RemAssign, Sub, SubAssign},
-};
-#[cfg(not(target_arch = "spirv"))]
-use core::{
-    fmt::{
-        Binary, Debug, Display, Error, Formatter, LowerExp, LowerHex, Octal, UpperExp, UpperHex,
-    },
-    num::ParseFloatError,
-    str::FromStr,
-};
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-#[cfg(feature = "zerocopy")]
-use zerocopy::{AsBytes, FromBytes};
-
-pub(crate) mod convert;
-
-/// A 16-bit floating point type implementing the IEEE 754-2008 standard [`binary16`] a.k.a `half`
-/// format.
-///
-/// This 16-bit floating point type is intended for efficient storage where the full range and
-/// precision of a larger floating point value is not required. Because [`f16`] is primarily for
-/// efficient storage, floating point operations such as addition, multiplication, etc. are not
-/// implemented. Operations should be performed with [`f32`] or higher-precision types and converted
-/// to/from [`f16`] as necessary.
-///
-/// [`binary16`]: https://en.wikipedia.org/wiki/Half-precision_floating-point_format
-#[allow(non_camel_case_types)]
-#[derive(Clone, Copy, Default)]
-#[repr(transparent)]
-#[cfg_attr(feature = "serde", derive(Serialize))]
-#[cfg_attr(feature = "bytemuck", derive(Zeroable, Pod))]
-#[cfg_attr(feature = "zerocopy", derive(AsBytes, FromBytes))]
-pub struct f16(u16);
-
-impl f16 {
-    /// Constructs a 16-bit floating point value from the raw bits.
-    #[inline]
-    #[must_use]
-    pub const fn from_bits(bits: u16) -> f16 {
-        f16(bits)
-    }
-
-    /// Constructs a 16-bit floating point value from a 32-bit floating point value.
-    ///
-    /// If the 32-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are
-    /// preserved. 32-bit subnormal values are too tiny to be represented in 16-bits and result in
-    /// ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals
-    /// or ±0. All other values are truncated and rounded to the nearest representable 16-bit
-    /// value.
-    #[inline]
-    #[must_use]
-    pub fn from_f32(value: f32) -> f16 {
-        f16(convert::f32_to_f16(value))
-    }
-
-    /// Constructs a 16-bit floating point value from a 32-bit floating point value.
-    ///
-    /// This function is identical to [`from_f32`][Self::from_f32] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`from_f32`][Self::from_f32] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// If the 32-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are
-    /// preserved. 32-bit subnormal values are too tiny to be represented in 16-bits and result in
-    /// ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals
-    /// or ±0. All other values are truncated and rounded to the nearest representable 16-bit
-    /// value.
-    #[inline]
-    #[must_use]
-    pub const fn from_f32_const(value: f32) -> f16 {
-        f16(convert::f32_to_f16_fallback(value))
-    }
-
-    /// Constructs a 16-bit floating point value from a 64-bit floating point value.
-    ///
-    /// If the 64-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are
-    /// preserved. 64-bit subnormal values are too tiny to be represented in 16-bits and result in
-    /// ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals
-    /// or ±0. All other values are truncated and rounded to the nearest representable 16-bit
-    /// value.
-    #[inline]
-    #[must_use]
-    pub fn from_f64(value: f64) -> f16 {
-        f16(convert::f64_to_f16(value))
-    }
-
-    /// Constructs a 16-bit floating point value from a 64-bit floating point value.
-    ///
-    /// This function is identical to [`from_f64`][Self::from_f64] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`from_f64`][Self::from_f64] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// If the 64-bit value is to large to fit in 16-bits, ±∞ will result. NaN values are
-    /// preserved. 64-bit subnormal values are too tiny to be represented in 16-bits and result in
-    /// ±0. Exponents that underflow the minimum 16-bit exponent will result in 16-bit subnormals
-    /// or ±0. All other values are truncated and rounded to the nearest representable 16-bit
-    /// value.
-    #[inline]
-    #[must_use]
-    pub const fn from_f64_const(value: f64) -> f16 {
-        f16(convert::f64_to_f16_fallback(value))
-    }
-
-    /// Converts a [`f16`] into the underlying bit representation.
-    #[inline]
-    #[must_use]
-    pub const fn to_bits(self) -> u16 {
-        self.0
-    }
-
-    /// Returns the memory representation of the underlying bit representation as a byte array in
-    /// little-endian byte order.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let bytes = f16::from_f32(12.5).to_le_bytes();
-    /// assert_eq!(bytes, [0x40, 0x4A]);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn to_le_bytes(self) -> [u8; 2] {
-        self.0.to_le_bytes()
-    }
-
-    /// Returns the memory representation of the underlying bit representation as a byte array in
-    /// big-endian (network) byte order.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let bytes = f16::from_f32(12.5).to_be_bytes();
-    /// assert_eq!(bytes, [0x4A, 0x40]);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn to_be_bytes(self) -> [u8; 2] {
-        self.0.to_be_bytes()
-    }
-
-    /// Returns the memory representation of the underlying bit representation as a byte array in
-    /// native byte order.
-    ///
-    /// As the target platform's native endianness is used, portable code should use
-    /// [`to_be_bytes`][Self::to_be_bytes] or [`to_le_bytes`][Self::to_le_bytes], as appropriate,
-    /// instead.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let bytes = f16::from_f32(12.5).to_ne_bytes();
-    /// assert_eq!(bytes, if cfg!(target_endian = "big") {
-    ///     [0x4A, 0x40]
-    /// } else {
-    ///     [0x40, 0x4A]
-    /// });
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn to_ne_bytes(self) -> [u8; 2] {
-        self.0.to_ne_bytes()
-    }
-
-    /// Creates a floating point value from its representation as a byte array in little endian.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let value = f16::from_le_bytes([0x40, 0x4A]);
-    /// assert_eq!(value, f16::from_f32(12.5));
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn from_le_bytes(bytes: [u8; 2]) -> f16 {
-        f16::from_bits(u16::from_le_bytes(bytes))
-    }
-
-    /// Creates a floating point value from its representation as a byte array in big endian.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let value = f16::from_be_bytes([0x4A, 0x40]);
-    /// assert_eq!(value, f16::from_f32(12.5));
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn from_be_bytes(bytes: [u8; 2]) -> f16 {
-        f16::from_bits(u16::from_be_bytes(bytes))
-    }
-
-    /// Creates a floating point value from its representation as a byte array in native endian.
-    ///
-    /// As the target platform's native endianness is used, portable code likely wants to use
-    /// [`from_be_bytes`][Self::from_be_bytes] or [`from_le_bytes`][Self::from_le_bytes], as
-    /// appropriate instead.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    /// let value = f16::from_ne_bytes(if cfg!(target_endian = "big") {
-    ///     [0x4A, 0x40]
-    /// } else {
-    ///     [0x40, 0x4A]
-    /// });
-    /// assert_eq!(value, f16::from_f32(12.5));
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn from_ne_bytes(bytes: [u8; 2]) -> f16 {
-        f16::from_bits(u16::from_ne_bytes(bytes))
-    }
-
-    /// Converts a [`f16`] value into a `f32` value.
-    ///
-    /// This conversion is lossless as all 16-bit floating point values can be represented exactly
-    /// in 32-bit floating point.
-    #[inline]
-    #[must_use]
-    pub fn to_f32(self) -> f32 {
-        convert::f16_to_f32(self.0)
-    }
-
-    /// Converts a [`f16`] value into a `f32` value.
-    ///
-    /// This function is identical to [`to_f32`][Self::to_f32] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`to_f32`][Self::to_f32] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// This conversion is lossless as all 16-bit floating point values can be represented exactly
-    /// in 32-bit floating point.
-    #[inline]
-    #[must_use]
-    pub const fn to_f32_const(self) -> f32 {
-        convert::f16_to_f32_fallback(self.0)
-    }
-
-    /// Converts a [`f16`] value into a `f64` value.
-    ///
-    /// This conversion is lossless as all 16-bit floating point values can be represented exactly
-    /// in 64-bit floating point.
-    #[inline]
-    #[must_use]
-    pub fn to_f64(self) -> f64 {
-        convert::f16_to_f64(self.0)
-    }
-
-    /// Converts a [`f16`] value into a `f64` value.
-    ///
-    /// This function is identical to [`to_f64`][Self::to_f64] except it never uses hardware
-    /// intrinsics, which allows it to be `const`. [`to_f64`][Self::to_f64] should be preferred
-    /// in any non-`const` context.
-    ///
-    /// This conversion is lossless as all 16-bit floating point values can be represented exactly
-    /// in 64-bit floating point.
-    #[inline]
-    #[must_use]
-    pub const fn to_f64_const(self) -> f64 {
-        convert::f16_to_f64_fallback(self.0)
-    }
-
-    /// Returns `true` if this value is `NaN` and `false` otherwise.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let nan = f16::NAN;
-    /// let f = f16::from_f32(7.0_f32);
-    ///
-    /// assert!(nan.is_nan());
-    /// assert!(!f.is_nan());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_nan(self) -> bool {
-        self.0 & 0x7FFFu16 > 0x7C00u16
-    }
-
-    /// Returns `true` if this value is ±∞ and `false`.
-    /// otherwise.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let f = f16::from_f32(7.0f32);
-    /// let inf = f16::INFINITY;
-    /// let neg_inf = f16::NEG_INFINITY;
-    /// let nan = f16::NAN;
-    ///
-    /// assert!(!f.is_infinite());
-    /// assert!(!nan.is_infinite());
-    ///
-    /// assert!(inf.is_infinite());
-    /// assert!(neg_inf.is_infinite());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_infinite(self) -> bool {
-        self.0 & 0x7FFFu16 == 0x7C00u16
-    }
-
-    /// Returns `true` if this number is neither infinite nor `NaN`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let f = f16::from_f32(7.0f32);
-    /// let inf = f16::INFINITY;
-    /// let neg_inf = f16::NEG_INFINITY;
-    /// let nan = f16::NAN;
-    ///
-    /// assert!(f.is_finite());
-    ///
-    /// assert!(!nan.is_finite());
-    /// assert!(!inf.is_finite());
-    /// assert!(!neg_inf.is_finite());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_finite(self) -> bool {
-        self.0 & 0x7C00u16 != 0x7C00u16
-    }
-
-    /// Returns `true` if the number is neither zero, infinite, subnormal, or `NaN`.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let min = f16::MIN_POSITIVE;
-    /// let max = f16::MAX;
-    /// let lower_than_min = f16::from_f32(1.0e-10_f32);
-    /// let zero = f16::from_f32(0.0_f32);
-    ///
-    /// assert!(min.is_normal());
-    /// assert!(max.is_normal());
-    ///
-    /// assert!(!zero.is_normal());
-    /// assert!(!f16::NAN.is_normal());
-    /// assert!(!f16::INFINITY.is_normal());
-    /// // Values between `0` and `min` are Subnormal.
-    /// assert!(!lower_than_min.is_normal());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_normal(self) -> bool {
-        let exp = self.0 & 0x7C00u16;
-        exp != 0x7C00u16 && exp != 0
-    }
-
-    /// Returns the floating point category of the number.
-    ///
-    /// If only one property is going to be tested, it is generally faster to use the specific
-    /// predicate instead.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// use std::num::FpCategory;
-    /// # use half::prelude::*;
-    ///
-    /// let num = f16::from_f32(12.4_f32);
-    /// let inf = f16::INFINITY;
-    ///
-    /// assert_eq!(num.classify(), FpCategory::Normal);
-    /// assert_eq!(inf.classify(), FpCategory::Infinite);
-    /// ```
-    #[must_use]
-    pub const fn classify(self) -> FpCategory {
-        let exp = self.0 & 0x7C00u16;
-        let man = self.0 & 0x03FFu16;
-        match (exp, man) {
-            (0, 0) => FpCategory::Zero,
-            (0, _) => FpCategory::Subnormal,
-            (0x7C00u16, 0) => FpCategory::Infinite,
-            (0x7C00u16, _) => FpCategory::Nan,
-            _ => FpCategory::Normal,
-        }
-    }
-
-    /// Returns a number that represents the sign of `self`.
-    ///
-    /// * `1.0` if the number is positive, `+0.0` or [`INFINITY`][f16::INFINITY]
-    /// * `-1.0` if the number is negative, `-0.0` or [`NEG_INFINITY`][f16::NEG_INFINITY]
-    /// * [`NAN`][f16::NAN] if the number is `NaN`
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let f = f16::from_f32(3.5_f32);
-    ///
-    /// assert_eq!(f.signum(), f16::from_f32(1.0));
-    /// assert_eq!(f16::NEG_INFINITY.signum(), f16::from_f32(-1.0));
-    ///
-    /// assert!(f16::NAN.signum().is_nan());
-    /// ```
-    #[must_use]
-    pub const fn signum(self) -> f16 {
-        if self.is_nan() {
-            self
-        } else if self.0 & 0x8000u16 != 0 {
-            Self::NEG_ONE
-        } else {
-            Self::ONE
-        }
-    }
-
-    /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaNs` with a
-    /// positive sign bit and +∞.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let nan = f16::NAN;
-    /// let f = f16::from_f32(7.0_f32);
-    /// let g = f16::from_f32(-7.0_f32);
-    ///
-    /// assert!(f.is_sign_positive());
-    /// assert!(!g.is_sign_positive());
-    /// // `NaN` can be either positive or negative
-    /// assert!(nan.is_sign_positive() != nan.is_sign_negative());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_sign_positive(self) -> bool {
-        self.0 & 0x8000u16 == 0
-    }
-
-    /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaNs` with a
-    /// negative sign bit and −∞.
-    ///
-    /// # Examples
-    ///
-    /// ```rust
-    /// # use half::prelude::*;
-    ///
-    /// let nan = f16::NAN;
-    /// let f = f16::from_f32(7.0f32);
-    /// let g = f16::from_f32(-7.0f32);
-    ///
-    /// assert!(!f.is_sign_negative());
-    /// assert!(g.is_sign_negative());
-    /// // `NaN` can be either positive or negative
-    /// assert!(nan.is_sign_positive() != nan.is_sign_negative());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn is_sign_negative(self) -> bool {
-        self.0 & 0x8000u16 != 0
-    }
-
-    /// Returns a number composed of the magnitude of `self` and the sign of `sign`.
-    ///
-    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
-    /// If `self` is NaN, then NaN with the sign of `sign` is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// let f = f16::from_f32(3.5);
-    ///
-    /// assert_eq!(f.copysign(f16::from_f32(0.42)), f16::from_f32(3.5));
-    /// assert_eq!(f.copysign(f16::from_f32(-0.42)), f16::from_f32(-3.5));
-    /// assert_eq!((-f).copysign(f16::from_f32(0.42)), f16::from_f32(3.5));
-    /// assert_eq!((-f).copysign(f16::from_f32(-0.42)), f16::from_f32(-3.5));
-    ///
-    /// assert!(f16::NAN.copysign(f16::from_f32(1.0)).is_nan());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub const fn copysign(self, sign: f16) -> f16 {
-        f16((sign.0 & 0x8000u16) | (self.0 & 0x7FFFu16))
-    }
-
-    /// Returns the maximum of the two numbers.
-    ///
-    /// If one of the arguments is NaN, then the other argument is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// let x = f16::from_f32(1.0);
-    /// let y = f16::from_f32(2.0);
-    ///
-    /// assert_eq!(x.max(y), y);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub fn max(self, other: f16) -> f16 {
-        if other > self && !other.is_nan() {
-            other
-        } else {
-            self
-        }
-    }
-
-    /// Returns the minimum of the two numbers.
-    ///
-    /// If one of the arguments is NaN, then the other argument is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// let x = f16::from_f32(1.0);
-    /// let y = f16::from_f32(2.0);
-    ///
-    /// assert_eq!(x.min(y), x);
-    /// ```
-    #[inline]
-    #[must_use]
-    pub fn min(self, other: f16) -> f16 {
-        if other < self && !other.is_nan() {
-            other
-        } else {
-            self
-        }
-    }
-
-    /// Restrict a value to a certain interval unless it is NaN.
-    ///
-    /// Returns `max` if `self` is greater than `max`, and `min` if `self` is less than `min`.
-    /// Otherwise this returns `self`.
-    ///
-    /// Note that this function returns NaN if the initial value was NaN as well.
-    ///
-    /// # Panics
-    /// Panics if `min > max`, `min` is NaN, or `max` is NaN.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use half::prelude::*;
-    /// assert!(f16::from_f32(-3.0).clamp(f16::from_f32(-2.0), f16::from_f32(1.0)) == f16::from_f32(-2.0));
-    /// assert!(f16::from_f32(0.0).clamp(f16::from_f32(-2.0), f16::from_f32(1.0)) == f16::from_f32(0.0));
-    /// assert!(f16::from_f32(2.0).clamp(f16::from_f32(-2.0), f16::from_f32(1.0)) == f16::from_f32(1.0));
-    /// assert!(f16::NAN.clamp(f16::from_f32(-2.0), f16::from_f32(1.0)).is_nan());
-    /// ```
-    #[inline]
-    #[must_use]
-    pub fn clamp(self, min: f16, max: f16) -> f16 {
-        assert!(min <= max);
-        let mut x = self;
-        if x < min {
-            x = min;
-        }
-        if x > max {
-            x = max;
-        }
-        x
-    }
-
-    /// Returns the ordering between `self` and `other`.
-    ///
-    /// Unlike the standard partial comparison between floating point numbers,
-    /// this comparison always produces an ordering in accordance to
-    /// the `totalOrder` predicate as defined in the IEEE 754 (2008 revision)
-    /// floating point standard. The values are ordered in the following sequence:
-    ///
-    /// - negative quiet NaN
-    /// - negative signaling NaN
-    /// - negative infinity
-    /// - negative numbers
-    /// - negative subnormal numbers
-    /// - negative zero
-    /// - positive zero
-    /// - positive subnormal numbers
-    /// - positive numbers
-    /// - positive infinity
-    /// - positive signaling NaN
-    /// - positive quiet NaN.
-    ///
-    /// The ordering established by this function does not always agree with the
-    /// [`PartialOrd`] and [`PartialEq`] implementations of `f16`. For example,
-    /// they consider negative and positive zero equal, while `total_cmp`
-    /// doesn't.
-    ///
-    /// The interpretation of the signaling NaN bit follows the definition in
-    /// the IEEE 754 standard, which may not match the interpretation by some of
-    /// the older, non-conformant (e.g. MIPS) hardware implementations.
-    ///
-    /// # Examples
-    /// ```
-    /// # use half::f16;
-    /// let mut v: Vec<f16> = vec![];
-    /// v.push(f16::ONE);
-    /// v.push(f16::INFINITY);
-    /// v.push(f16::NEG_INFINITY);
-    /// v.push(f16::NAN);
-    /// v.push(f16::MAX_SUBNORMAL);
-    /// v.push(-f16::MAX_SUBNORMAL);
-    /// v.push(f16::ZERO);
-    /// v.push(f16::NEG_ZERO);
-    /// v.push(f16::NEG_ONE);
-    /// v.push(f16::MIN_POSITIVE);
-    ///
-    /// v.sort_by(|a, b| a.total_cmp(&b));
-    ///
-    /// assert!(v
-    ///     .into_iter()
-    ///     .zip(
-    ///         [
-    ///             f16::NEG_INFINITY,
-    ///             f16::NEG_ONE,
-    ///             -f16::MAX_SUBNORMAL,
-    ///             f16::NEG_ZERO,
-    ///             f16::ZERO,
-    ///             f16::MAX_SUBNORMAL,
-    ///             f16::MIN_POSITIVE,
-    ///             f16::ONE,
-    ///             f16::INFINITY,
-    ///             f16::NAN
-    ///         ]
-    ///         .iter()
-    ///     )
-    ///     .all(|(a, b)| a.to_bits() == b.to_bits()));
-    /// ```
-    // Implementation based on: https://doc.rust-lang.org/std/primitive.f32.html#method.total_cmp
-    #[inline]
-    #[must_use]
-    pub fn total_cmp(&self, other: &Self) -> Ordering {
-        let mut left = self.to_bits() as i16;
-        let mut right = other.to_bits() as i16;
-        left ^= (((left >> 15) as u16) >> 1) as i16;
-        right ^= (((right >> 15) as u16) >> 1) as i16;
-        left.cmp(&right)
-    }
-
-    /// Alternate serialize adapter for serializing as a float.
-    ///
-    /// By default, [`f16`] serializes as a newtype of [`u16`]. This is an alternate serialize
-    /// implementation that serializes as an [`f32`] value. It is designed for use with
-    /// `serialize_with` serde attributes. Deserialization from `f32` values is already supported by
-    /// the default deserialize implementation.
-    ///
-    /// # Examples
-    ///
-    /// A demonstration on how to use this adapater:
-    ///
-    /// ```
-    /// use serde::{Serialize, Deserialize};
-    /// use half::f16;
-    ///
-    /// #[derive(Serialize, Deserialize)]
-    /// struct MyStruct {
-    ///     #[serde(serialize_with = "f16::serialize_as_f32")]
-    ///     value: f16 // Will be serialized as f32 instead of u16
-    /// }
-    /// ```
-    #[cfg(feature = "serde")]
-    pub fn serialize_as_f32<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        serializer.serialize_f32(self.to_f32())
-    }
-
-    /// Alternate serialize adapter for serializing as a string.
-    ///
-    /// By default, [`f16`] serializes as a newtype of [`u16`]. This is an alternate serialize
-    /// implementation that serializes as a string value. It is designed for use with
-    /// `serialize_with` serde attributes. Deserialization from string values is already supported
-    /// by the default deserialize implementation.
-    ///
-    /// # Examples
-    ///
-    /// A demonstration on how to use this adapater:
-    ///
-    /// ```
-    /// use serde::{Serialize, Deserialize};
-    /// use half::f16;
-    ///
-    /// #[derive(Serialize, Deserialize)]
-    /// struct MyStruct {
-    ///     #[serde(serialize_with = "f16::serialize_as_string")]
-    ///     value: f16 // Will be serialized as a string instead of u16
-    /// }
-    /// ```
-    #[cfg(feature = "serde")]
-    pub fn serialize_as_string<S: serde::Serializer>(
-        &self,
-        serializer: S,
-    ) -> Result<S::Ok, S::Error> {
-        serializer.serialize_str(&self.to_string())
-    }
-
-    /// Approximate number of [`f16`] significant digits in base 10
-    pub const DIGITS: u32 = 3;
-    /// [`f16`]
-    /// [machine epsilon](https://en.wikipedia.org/wiki/Machine_epsilon) value
-    ///
-    /// This is the difference between 1.0 and the next largest representable number.
-    pub const EPSILON: f16 = f16(0x1400u16);
-    /// [`f16`] positive Infinity (+∞)
-    pub const INFINITY: f16 = f16(0x7C00u16);
-    /// Number of [`f16`] significant digits in base 2
-    pub const MANTISSA_DIGITS: u32 = 11;
-    /// Largest finite [`f16`] value
-    pub const MAX: f16 = f16(0x7BFF);
-    /// Maximum possible [`f16`] power of 10 exponent
-    pub const MAX_10_EXP: i32 = 4;
-    /// Maximum possible [`f16`] power of 2 exponent
-    pub const MAX_EXP: i32 = 16;
-    /// Smallest finite [`f16`] value
-    pub const MIN: f16 = f16(0xFBFF);
-    /// Minimum possible normal [`f16`] power of 10 exponent
-    pub const MIN_10_EXP: i32 = -4;
-    /// One greater than the minimum possible normal [`f16`] power of 2 exponent
-    pub const MIN_EXP: i32 = -13;
-    /// Smallest positive normal [`f16`] value
-    pub const MIN_POSITIVE: f16 = f16(0x0400u16);
-    /// [`f16`] Not a Number (NaN)
-    pub const NAN: f16 = f16(0x7E00u16);
-    /// [`f16`] negative infinity (-∞)
-    pub const NEG_INFINITY: f16 = f16(0xFC00u16);
-    /// The radix or base of the internal representation of [`f16`]
-    pub const RADIX: u32 = 2;
-
-    /// Minimum positive subnormal [`f16`] value
-    pub const MIN_POSITIVE_SUBNORMAL: f16 = f16(0x0001u16);
-    /// Maximum subnormal [`f16`] value
-    pub const MAX_SUBNORMAL: f16 = f16(0x03FFu16);
-
-    /// [`f16`] 1
-    pub const ONE: f16 = f16(0x3C00u16);
-    /// [`f16`] 0
-    pub const ZERO: f16 = f16(0x0000u16);
-    /// [`f16`] -0
-    pub const NEG_ZERO: f16 = f16(0x8000u16);
-    /// [`f16`] -1
-    pub const NEG_ONE: f16 = f16(0xBC00u16);
-
-    /// [`f16`] Euler's number (ℯ)
-    pub const E: f16 = f16(0x4170u16);
-    /// [`f16`] Archimedes' constant (π)
-    pub const PI: f16 = f16(0x4248u16);
-    /// [`f16`] 1/π
-    pub const FRAC_1_PI: f16 = f16(0x3518u16);
-    /// [`f16`] 1/√2
-    pub const FRAC_1_SQRT_2: f16 = f16(0x39A8u16);
-    /// [`f16`] 2/π
-    pub const FRAC_2_PI: f16 = f16(0x3918u16);
-    /// [`f16`] 2/√π
-    pub const FRAC_2_SQRT_PI: f16 = f16(0x3C83u16);
-    /// [`f16`] π/2
-    pub const FRAC_PI_2: f16 = f16(0x3E48u16);
-    /// [`f16`] π/3
-    pub const FRAC_PI_3: f16 = f16(0x3C30u16);
-    /// [`f16`] π/4
-    pub const FRAC_PI_4: f16 = f16(0x3A48u16);
-    /// [`f16`] π/6
-    pub const FRAC_PI_6: f16 = f16(0x3830u16);
-    /// [`f16`] π/8
-    pub const FRAC_PI_8: f16 = f16(0x3648u16);
-    /// [`f16`] 𝗅𝗇 10
-    pub const LN_10: f16 = f16(0x409Bu16);
-    /// [`f16`] 𝗅𝗇 2
-    pub const LN_2: f16 = f16(0x398Cu16);
-    /// [`f16`] 𝗅𝗈𝗀₁₀ℯ
-    pub const LOG10_E: f16 = f16(0x36F3u16);
-    /// [`f16`] 𝗅𝗈𝗀₁₀2
-    pub const LOG10_2: f16 = f16(0x34D1u16);
-    /// [`f16`] 𝗅𝗈𝗀₂ℯ
-    pub const LOG2_E: f16 = f16(0x3DC5u16);
-    /// [`f16`] 𝗅𝗈𝗀₂10
-    pub const LOG2_10: f16 = f16(0x42A5u16);
-    /// [`f16`] √2
-    pub const SQRT_2: f16 = f16(0x3DA8u16);
-}
-
-impl From<f16> for f32 {
-    #[inline]
-    fn from(x: f16) -> f32 {
-        x.to_f32()
-    }
-}
-
-impl From<f16> for f64 {
-    #[inline]
-    fn from(x: f16) -> f64 {
-        x.to_f64()
-    }
-}
-
-impl From<i8> for f16 {
-    #[inline]
-    fn from(x: i8) -> f16 {
-        // Convert to f32, then to f16
-        f16::from_f32(f32::from(x))
-    }
-}
-
-impl From<u8> for f16 {
-    #[inline]
-    fn from(x: u8) -> f16 {
-        // Convert to f32, then to f16
-        f16::from_f32(f32::from(x))
-    }
-}
-
-impl PartialEq for f16 {
-    fn eq(&self, other: &f16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            (self.0 == other.0) || ((self.0 | other.0) & 0x7FFFu16 == 0)
-        }
-    }
-}
-
-impl PartialOrd for f16 {
-    fn partial_cmp(&self, other: &f16) -> Option<Ordering> {
-        if self.is_nan() || other.is_nan() {
-            None
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => Some(self.0.cmp(&other.0)),
-                (false, true) => {
-                    if (self.0 | other.0) & 0x7FFFu16 == 0 {
-                        Some(Ordering::Equal)
-                    } else {
-                        Some(Ordering::Greater)
-                    }
-                }
-                (true, false) => {
-                    if (self.0 | other.0) & 0x7FFFu16 == 0 {
-                        Some(Ordering::Equal)
-                    } else {
-                        Some(Ordering::Less)
-                    }
-                }
-                (true, true) => Some(other.0.cmp(&self.0)),
-            }
-        }
-    }
-
-    fn lt(&self, other: &f16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 < other.0,
-                (false, true) => false,
-                (true, false) => (self.0 | other.0) & 0x7FFFu16 != 0,
-                (true, true) => self.0 > other.0,
-            }
-        }
-    }
-
-    fn le(&self, other: &f16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 <= other.0,
-                (false, true) => (self.0 | other.0) & 0x7FFFu16 == 0,
-                (true, false) => true,
-                (true, true) => self.0 >= other.0,
-            }
-        }
-    }
-
-    fn gt(&self, other: &f16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 > other.0,
-                (false, true) => (self.0 | other.0) & 0x7FFFu16 != 0,
-                (true, false) => false,
-                (true, true) => self.0 < other.0,
-            }
-        }
-    }
-
-    fn ge(&self, other: &f16) -> bool {
-        if self.is_nan() || other.is_nan() {
-            false
-        } else {
-            let neg = self.0 & 0x8000u16 != 0;
-            let other_neg = other.0 & 0x8000u16 != 0;
-            match (neg, other_neg) {
-                (false, false) => self.0 >= other.0,
-                (false, true) => true,
-                (true, false) => (self.0 | other.0) & 0x7FFFu16 == 0,
-                (true, true) => self.0 <= other.0,
-            }
-        }
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl FromStr for f16 {
-    type Err = ParseFloatError;
-    fn from_str(src: &str) -> Result<f16, ParseFloatError> {
-        f32::from_str(src).map(f16::from_f32)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Debug for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:?}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Display for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl LowerExp for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:e}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl UpperExp for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:E}", self.to_f32())
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Binary for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:b}", self.0)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl Octal for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:o}", self.0)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl LowerHex for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:x}", self.0)
-    }
-}
-
-#[cfg(not(target_arch = "spirv"))]
-impl UpperHex for f16 {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        write!(f, "{:X}", self.0)
-    }
-}
-
-impl Neg for f16 {
-    type Output = Self;
-
-    #[inline]
-    fn neg(self) -> Self::Output {
-        Self(self.0 ^ 0x8000)
-    }
-}
-
-impl Neg for &f16 {
-    type Output = <f16 as Neg>::Output;
-
-    #[inline]
-    fn neg(self) -> Self::Output {
-        Neg::neg(*self)
-    }
-}
-
-impl Add for f16 {
-    type Output = Self;
-
-    #[inline]
-    fn add(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) + Self::to_f32(rhs))
-    }
-}
-
-impl Add<&f16> for f16 {
-    type Output = <f16 as Add<f16>>::Output;
-
-    #[inline]
-    fn add(self, rhs: &f16) -> Self::Output {
-        self.add(*rhs)
-    }
-}
-
-impl Add<&f16> for &f16 {
-    type Output = <f16 as Add<f16>>::Output;
-
-    #[inline]
-    fn add(self, rhs: &f16) -> Self::Output {
-        (*self).add(*rhs)
-    }
-}
-
-impl Add<f16> for &f16 {
-    type Output = <f16 as Add<f16>>::Output;
-
-    #[inline]
-    fn add(self, rhs: f16) -> Self::Output {
-        (*self).add(rhs)
-    }
-}
-
-impl AddAssign for f16 {
-    #[inline]
-    fn add_assign(&mut self, rhs: Self) {
-        *self = (*self).add(rhs);
-    }
-}
-
-impl AddAssign<&f16> for f16 {
-    #[inline]
-    fn add_assign(&mut self, rhs: &f16) {
-        *self = (*self).add(rhs);
-    }
-}
-
-impl Sub for f16 {
-    type Output = Self;
-
-    #[inline]
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) - Self::to_f32(rhs))
-    }
-}
-
-impl Sub<&f16> for f16 {
-    type Output = <f16 as Sub<f16>>::Output;
-
-    #[inline]
-    fn sub(self, rhs: &f16) -> Self::Output {
-        self.sub(*rhs)
-    }
-}
-
-impl Sub<&f16> for &f16 {
-    type Output = <f16 as Sub<f16>>::Output;
-
-    #[inline]
-    fn sub(self, rhs: &f16) -> Self::Output {
-        (*self).sub(*rhs)
-    }
-}
-
-impl Sub<f16> for &f16 {
-    type Output = <f16 as Sub<f16>>::Output;
-
-    #[inline]
-    fn sub(self, rhs: f16) -> Self::Output {
-        (*self).sub(rhs)
-    }
-}
-
-impl SubAssign for f16 {
-    #[inline]
-    fn sub_assign(&mut self, rhs: Self) {
-        *self = (*self).sub(rhs);
-    }
-}
-
-impl SubAssign<&f16> for f16 {
-    #[inline]
-    fn sub_assign(&mut self, rhs: &f16) {
-        *self = (*self).sub(rhs);
-    }
-}
-
-impl Mul for f16 {
-    type Output = Self;
-
-    #[inline]
-    fn mul(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) * Self::to_f32(rhs))
-    }
-}
-
-impl Mul<&f16> for f16 {
-    type Output = <f16 as Mul<f16>>::Output;
-
-    #[inline]
-    fn mul(self, rhs: &f16) -> Self::Output {
-        self.mul(*rhs)
-    }
-}
-
-impl Mul<&f16> for &f16 {
-    type Output = <f16 as Mul<f16>>::Output;
-
-    #[inline]
-    fn mul(self, rhs: &f16) -> Self::Output {
-        (*self).mul(*rhs)
-    }
-}
-
-impl Mul<f16> for &f16 {
-    type Output = <f16 as Mul<f16>>::Output;
-
-    #[inline]
-    fn mul(self, rhs: f16) -> Self::Output {
-        (*self).mul(rhs)
-    }
-}
-
-impl MulAssign for f16 {
-    #[inline]
-    fn mul_assign(&mut self, rhs: Self) {
-        *self = (*self).mul(rhs);
-    }
-}
-
-impl MulAssign<&f16> for f16 {
-    #[inline]
-    fn mul_assign(&mut self, rhs: &f16) {
-        *self = (*self).mul(rhs);
-    }
-}
-
-impl Div for f16 {
-    type Output = Self;
-
-    #[inline]
-    fn div(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) / Self::to_f32(rhs))
-    }
-}
-
-impl Div<&f16> for f16 {
-    type Output = <f16 as Div<f16>>::Output;
-
-    #[inline]
-    fn div(self, rhs: &f16) -> Self::Output {
-        self.div(*rhs)
-    }
-}
-
-impl Div<&f16> for &f16 {
-    type Output = <f16 as Div<f16>>::Output;
-
-    #[inline]
-    fn div(self, rhs: &f16) -> Self::Output {
-        (*self).div(*rhs)
-    }
-}
-
-impl Div<f16> for &f16 {
-    type Output = <f16 as Div<f16>>::Output;
-
-    #[inline]
-    fn div(self, rhs: f16) -> Self::Output {
-        (*self).div(rhs)
-    }
-}
-
-impl DivAssign for f16 {
-    #[inline]
-    fn div_assign(&mut self, rhs: Self) {
-        *self = (*self).div(rhs);
-    }
-}
-
-impl DivAssign<&f16> for f16 {
-    #[inline]
-    fn div_assign(&mut self, rhs: &f16) {
-        *self = (*self).div(rhs);
-    }
-}
-
-impl Rem for f16 {
-    type Output = Self;
-
-    #[inline]
-    fn rem(self, rhs: Self) -> Self::Output {
-        Self::from_f32(Self::to_f32(self) % Self::to_f32(rhs))
-    }
-}
-
-impl Rem<&f16> for f16 {
-    type Output = <f16 as Rem<f16>>::Output;
-
-    #[inline]
-    fn rem(self, rhs: &f16) -> Self::Output {
-        self.rem(*rhs)
-    }
-}
-
-impl Rem<&f16> for &f16 {
-    type Output = <f16 as Rem<f16>>::Output;
-
-    #[inline]
-    fn rem(self, rhs: &f16) -> Self::Output {
-        (*self).rem(*rhs)
-    }
-}
-
-impl Rem<f16> for &f16 {
-    type Output = <f16 as Rem<f16>>::Output;
-
-    #[inline]
-    fn rem(self, rhs: f16) -> Self::Output {
-        (*self).rem(rhs)
-    }
-}
-
-impl RemAssign for f16 {
-    #[inline]
-    fn rem_assign(&mut self, rhs: Self) {
-        *self = (*self).rem(rhs);
-    }
-}
-
-impl RemAssign<&f16> for f16 {
-    #[inline]
-    fn rem_assign(&mut self, rhs: &f16) {
-        *self = (*self).rem(rhs);
-    }
-}
-
-impl Product for f16 {
-    #[inline]
-    fn product<I: Iterator<Item = Self>>(iter: I) -> Self {
-        f16::from_f32(iter.map(|f| f.to_f32()).product())
-    }
-}
-
-impl<'a> Product<&'a f16> for f16 {
-    #[inline]
-    fn product<I: Iterator<Item = &'a f16>>(iter: I) -> Self {
-        f16::from_f32(iter.map(|f| f.to_f32()).product())
-    }
-}
-
-impl Sum for f16 {
-    #[inline]
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        f16::from_f32(iter.map(|f| f.to_f32()).sum())
-    }
-}
-
-impl<'a> Sum<&'a f16> for f16 {
-    #[inline]
-    fn sum<I: Iterator<Item = &'a f16>>(iter: I) -> Self {
-        f16::from_f32(iter.map(|f| f.to_f32()).product())
-    }
-}
-
-#[cfg(feature = "serde")]
-struct Visitor;
-
-#[cfg(feature = "serde")]
-impl<'de> Deserialize<'de> for f16 {
-    fn deserialize<D>(deserializer: D) -> Result<f16, D::Error>
-    where
-        D: serde::de::Deserializer<'de>,
-    {
-        deserializer.deserialize_newtype_struct("f16", Visitor)
-    }
-}
-
-#[cfg(feature = "serde")]
-impl<'de> serde::de::Visitor<'de> for Visitor {
-    type Value = f16;
-
-    fn expecting(&self, formatter: &mut alloc::fmt::Formatter) -> alloc::fmt::Result {
-        write!(formatter, "tuple struct f16")
-    }
-
-    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        Ok(f16(<u16 as Deserialize>::deserialize(deserializer)?))
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        v.parse().map_err(|_| {
-            serde::de::Error::invalid_value(serde::de::Unexpected::Str(v), &"a float string")
-        })
-    }
-
-    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Ok(f16::from_f32(v))
-    }
-
-    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Ok(f16::from_f64(v))
-    }
-}
-
-#[allow(
-    clippy::cognitive_complexity,
-    clippy::float_cmp,
-    clippy::neg_cmp_op_on_partial_ord
-)]
-#[cfg(test)]
-mod test {
-    use super::*;
-    use core::cmp::Ordering;
-    #[cfg(feature = "num-traits")]
-    use num_traits::{AsPrimitive, FromPrimitive, ToPrimitive};
-    use quickcheck_macros::quickcheck;
-
-    #[cfg(feature = "num-traits")]
-    #[test]
-    fn as_primitive() {
-        let two = f16::from_f32(2.0);
-        assert_eq!(<i32 as AsPrimitive<f16>>::as_(2), two);
-        assert_eq!(<f16 as AsPrimitive<i32>>::as_(two), 2);
-
-        assert_eq!(<f32 as AsPrimitive<f16>>::as_(2.0), two);
-        assert_eq!(<f16 as AsPrimitive<f32>>::as_(two), 2.0);
-
-        assert_eq!(<f64 as AsPrimitive<f16>>::as_(2.0), two);
-        assert_eq!(<f16 as AsPrimitive<f64>>::as_(two), 2.0);
-    }
-
-    #[cfg(feature = "num-traits")]
-    #[test]
-    fn to_primitive() {
-        let two = f16::from_f32(2.0);
-        assert_eq!(ToPrimitive::to_i32(&two).unwrap(), 2i32);
-        assert_eq!(ToPrimitive::to_f32(&two).unwrap(), 2.0f32);
-        assert_eq!(ToPrimitive::to_f64(&two).unwrap(), 2.0f64);
-    }
-
-    #[cfg(feature = "num-traits")]
-    #[test]
-    fn from_primitive() {
-        let two = f16::from_f32(2.0);
-        assert_eq!(<f16 as FromPrimitive>::from_i32(2).unwrap(), two);
-        assert_eq!(<f16 as FromPrimitive>::from_f32(2.0).unwrap(), two);
-        assert_eq!(<f16 as FromPrimitive>::from_f64(2.0).unwrap(), two);
-    }
-
-    #[test]
-    fn test_f16_consts() {
-        // DIGITS
-        let digits = ((f16::MANTISSA_DIGITS as f32 - 1.0) * 2f32.log10()).floor() as u32;
-        assert_eq!(f16::DIGITS, digits);
-        // sanity check to show test is good
-        let digits32 = ((core::f32::MANTISSA_DIGITS as f32 - 1.0) * 2f32.log10()).floor() as u32;
-        assert_eq!(core::f32::DIGITS, digits32);
-
-        // EPSILON
-        let one = f16::from_f32(1.0);
-        let one_plus_epsilon = f16::from_bits(one.to_bits() + 1);
-        let epsilon = f16::from_f32(one_plus_epsilon.to_f32() - 1.0);
-        assert_eq!(f16::EPSILON, epsilon);
-        // sanity check to show test is good
-        let one_plus_epsilon32 = f32::from_bits(1.0f32.to_bits() + 1);
-        let epsilon32 = one_plus_epsilon32 - 1f32;
-        assert_eq!(core::f32::EPSILON, epsilon32);
-
-        // MAX, MIN and MIN_POSITIVE
-        let max = f16::from_bits(f16::INFINITY.to_bits() - 1);
-        let min = f16::from_bits(f16::NEG_INFINITY.to_bits() - 1);
-        let min_pos = f16::from_f32(2f32.powi(f16::MIN_EXP - 1));
-        assert_eq!(f16::MAX, max);
-        assert_eq!(f16::MIN, min);
-        assert_eq!(f16::MIN_POSITIVE, min_pos);
-        // sanity check to show test is good
-        let max32 = f32::from_bits(core::f32::INFINITY.to_bits() - 1);
-        let min32 = f32::from_bits(core::f32::NEG_INFINITY.to_bits() - 1);
-        let min_pos32 = 2f32.powi(core::f32::MIN_EXP - 1);
-        assert_eq!(core::f32::MAX, max32);
-        assert_eq!(core::f32::MIN, min32);
-        assert_eq!(core::f32::MIN_POSITIVE, min_pos32);
-
-        // MIN_10_EXP and MAX_10_EXP
-        let ten_to_min = 10f32.powi(f16::MIN_10_EXP);
-        assert!(ten_to_min / 10.0 < f16::MIN_POSITIVE.to_f32());
-        assert!(ten_to_min > f16::MIN_POSITIVE.to_f32());
-        let ten_to_max = 10f32.powi(f16::MAX_10_EXP);
-        assert!(ten_to_max < f16::MAX.to_f32());
-        assert!(ten_to_max * 10.0 > f16::MAX.to_f32());
-        // sanity check to show test is good
-        let ten_to_min32 = 10f64.powi(core::f32::MIN_10_EXP);
-        assert!(ten_to_min32 / 10.0 < f64::from(core::f32::MIN_POSITIVE));
-        assert!(ten_to_min32 > f64::from(core::f32::MIN_POSITIVE));
-        let ten_to_max32 = 10f64.powi(core::f32::MAX_10_EXP);
-        assert!(ten_to_max32 < f64::from(core::f32::MAX));
-        assert!(ten_to_max32 * 10.0 > f64::from(core::f32::MAX));
-    }
-
-    #[test]
-    fn test_f16_consts_from_f32() {
-        let one = f16::from_f32(1.0);
-        let zero = f16::from_f32(0.0);
-        let neg_zero = f16::from_f32(-0.0);
-        let neg_one = f16::from_f32(-1.0);
-        let inf = f16::from_f32(core::f32::INFINITY);
-        let neg_inf = f16::from_f32(core::f32::NEG_INFINITY);
-        let nan = f16::from_f32(core::f32::NAN);
-
-        assert_eq!(f16::ONE, one);
-        assert_eq!(f16::ZERO, zero);
-        assert!(zero.is_sign_positive());
-        assert_eq!(f16::NEG_ZERO, neg_zero);
-        assert!(neg_zero.is_sign_negative());
-        assert_eq!(f16::NEG_ONE, neg_one);
-        assert!(neg_one.is_sign_negative());
-        assert_eq!(f16::INFINITY, inf);
-        assert_eq!(f16::NEG_INFINITY, neg_inf);
-        assert!(nan.is_nan());
-        assert!(f16::NAN.is_nan());
-
-        let e = f16::from_f32(core::f32::consts::E);
-        let pi = f16::from_f32(core::f32::consts::PI);
-        let frac_1_pi = f16::from_f32(core::f32::consts::FRAC_1_PI);
-        let frac_1_sqrt_2 = f16::from_f32(core::f32::consts::FRAC_1_SQRT_2);
-        let frac_2_pi = f16::from_f32(core::f32::consts::FRAC_2_PI);
-        let frac_2_sqrt_pi = f16::from_f32(core::f32::consts::FRAC_2_SQRT_PI);
-        let frac_pi_2 = f16::from_f32(core::f32::consts::FRAC_PI_2);
-        let frac_pi_3 = f16::from_f32(core::f32::consts::FRAC_PI_3);
-        let frac_pi_4 = f16::from_f32(core::f32::consts::FRAC_PI_4);
-        let frac_pi_6 = f16::from_f32(core::f32::consts::FRAC_PI_6);
-        let frac_pi_8 = f16::from_f32(core::f32::consts::FRAC_PI_8);
-        let ln_10 = f16::from_f32(core::f32::consts::LN_10);
-        let ln_2 = f16::from_f32(core::f32::consts::LN_2);
-        let log10_e = f16::from_f32(core::f32::consts::LOG10_E);
-        // core::f32::consts::LOG10_2 requires rustc 1.43.0
-        let log10_2 = f16::from_f32(2f32.log10());
-        let log2_e = f16::from_f32(core::f32::consts::LOG2_E);
-        // core::f32::consts::LOG2_10 requires rustc 1.43.0
-        let log2_10 = f16::from_f32(10f32.log2());
-        let sqrt_2 = f16::from_f32(core::f32::consts::SQRT_2);
-
-        assert_eq!(f16::E, e);
-        assert_eq!(f16::PI, pi);
-        assert_eq!(f16::FRAC_1_PI, frac_1_pi);
-        assert_eq!(f16::FRAC_1_SQRT_2, frac_1_sqrt_2);
-        assert_eq!(f16::FRAC_2_PI, frac_2_pi);
-        assert_eq!(f16::FRAC_2_SQRT_PI, frac_2_sqrt_pi);
-        assert_eq!(f16::FRAC_PI_2, frac_pi_2);
-        assert_eq!(f16::FRAC_PI_3, frac_pi_3);
-        assert_eq!(f16::FRAC_PI_4, frac_pi_4);
-        assert_eq!(f16::FRAC_PI_6, frac_pi_6);
-        assert_eq!(f16::FRAC_PI_8, frac_pi_8);
-        assert_eq!(f16::LN_10, ln_10);
-        assert_eq!(f16::LN_2, ln_2);
-        assert_eq!(f16::LOG10_E, log10_e);
-        assert_eq!(f16::LOG10_2, log10_2);
-        assert_eq!(f16::LOG2_E, log2_e);
-        assert_eq!(f16::LOG2_10, log2_10);
-        assert_eq!(f16::SQRT_2, sqrt_2);
-    }
-
-    #[test]
-    fn test_f16_consts_from_f64() {
-        let one = f16::from_f64(1.0);
-        let zero = f16::from_f64(0.0);
-        let neg_zero = f16::from_f64(-0.0);
-        let inf = f16::from_f64(core::f64::INFINITY);
-        let neg_inf = f16::from_f64(core::f64::NEG_INFINITY);
-        let nan = f16::from_f64(core::f64::NAN);
-
-        assert_eq!(f16::ONE, one);
-        assert_eq!(f16::ZERO, zero);
-        assert!(zero.is_sign_positive());
-        assert_eq!(f16::NEG_ZERO, neg_zero);
-        assert!(neg_zero.is_sign_negative());
-        assert_eq!(f16::INFINITY, inf);
-        assert_eq!(f16::NEG_INFINITY, neg_inf);
-        assert!(nan.is_nan());
-        assert!(f16::NAN.is_nan());
-
-        let e = f16::from_f64(core::f64::consts::E);
-        let pi = f16::from_f64(core::f64::consts::PI);
-        let frac_1_pi = f16::from_f64(core::f64::consts::FRAC_1_PI);
-        let frac_1_sqrt_2 = f16::from_f64(core::f64::consts::FRAC_1_SQRT_2);
-        let frac_2_pi = f16::from_f64(core::f64::consts::FRAC_2_PI);
-        let frac_2_sqrt_pi = f16::from_f64(core::f64::consts::FRAC_2_SQRT_PI);
-        let frac_pi_2 = f16::from_f64(core::f64::consts::FRAC_PI_2);
-        let frac_pi_3 = f16::from_f64(core::f64::consts::FRAC_PI_3);
-        let frac_pi_4 = f16::from_f64(core::f64::consts::FRAC_PI_4);
-        let frac_pi_6 = f16::from_f64(core::f64::consts::FRAC_PI_6);
-        let frac_pi_8 = f16::from_f64(core::f64::consts::FRAC_PI_8);
-        let ln_10 = f16::from_f64(core::f64::consts::LN_10);
-        let ln_2 = f16::from_f64(core::f64::consts::LN_2);
-        let log10_e = f16::from_f64(core::f64::consts::LOG10_E);
-        // core::f64::consts::LOG10_2 requires rustc 1.43.0
-        let log10_2 = f16::from_f64(2f64.log10());
-        let log2_e = f16::from_f64(core::f64::consts::LOG2_E);
-        // core::f64::consts::LOG2_10 requires rustc 1.43.0
-        let log2_10 = f16::from_f64(10f64.log2());
-        let sqrt_2 = f16::from_f64(core::f64::consts::SQRT_2);
-
-        assert_eq!(f16::E, e);
-        assert_eq!(f16::PI, pi);
-        assert_eq!(f16::FRAC_1_PI, frac_1_pi);
-        assert_eq!(f16::FRAC_1_SQRT_2, frac_1_sqrt_2);
-        assert_eq!(f16::FRAC_2_PI, frac_2_pi);
-        assert_eq!(f16::FRAC_2_SQRT_PI, frac_2_sqrt_pi);
-        assert_eq!(f16::FRAC_PI_2, frac_pi_2);
-        assert_eq!(f16::FRAC_PI_3, frac_pi_3);
-        assert_eq!(f16::FRAC_PI_4, frac_pi_4);
-        assert_eq!(f16::FRAC_PI_6, frac_pi_6);
-        assert_eq!(f16::FRAC_PI_8, frac_pi_8);
-        assert_eq!(f16::LN_10, ln_10);
-        assert_eq!(f16::LN_2, ln_2);
-        assert_eq!(f16::LOG10_E, log10_e);
-        assert_eq!(f16::LOG10_2, log10_2);
-        assert_eq!(f16::LOG2_E, log2_e);
-        assert_eq!(f16::LOG2_10, log2_10);
-        assert_eq!(f16::SQRT_2, sqrt_2);
-    }
-
-    #[test]
-    fn test_nan_conversion_to_smaller() {
-        let nan64 = f64::from_bits(0x7FF0_0000_0000_0001u64);
-        let neg_nan64 = f64::from_bits(0xFFF0_0000_0000_0001u64);
-        let nan32 = f32::from_bits(0x7F80_0001u32);
-        let neg_nan32 = f32::from_bits(0xFF80_0001u32);
-        let nan32_from_64 = nan64 as f32;
-        let neg_nan32_from_64 = neg_nan64 as f32;
-        let nan16_from_64 = f16::from_f64(nan64);
-        let neg_nan16_from_64 = f16::from_f64(neg_nan64);
-        let nan16_from_32 = f16::from_f32(nan32);
-        let neg_nan16_from_32 = f16::from_f32(neg_nan32);
-
-        assert!(nan64.is_nan() && nan64.is_sign_positive());
-        assert!(neg_nan64.is_nan() && neg_nan64.is_sign_negative());
-        assert!(nan32.is_nan() && nan32.is_sign_positive());
-        assert!(neg_nan32.is_nan() && neg_nan32.is_sign_negative());
-        assert!(nan32_from_64.is_nan() && nan32_from_64.is_sign_positive());
-        assert!(neg_nan32_from_64.is_nan() && neg_nan32_from_64.is_sign_negative());
-        assert!(nan16_from_64.is_nan() && nan16_from_64.is_sign_positive());
-        assert!(neg_nan16_from_64.is_nan() && neg_nan16_from_64.is_sign_negative());
-        assert!(nan16_from_32.is_nan() && nan16_from_32.is_sign_positive());
-        assert!(neg_nan16_from_32.is_nan() && neg_nan16_from_32.is_sign_negative());
-    }
-
-    #[test]
-    fn test_nan_conversion_to_larger() {
-        let nan16 = f16::from_bits(0x7C01u16);
-        let neg_nan16 = f16::from_bits(0xFC01u16);
-        let nan32 = f32::from_bits(0x7F80_0001u32);
-        let neg_nan32 = f32::from_bits(0xFF80_0001u32);
-        let nan32_from_16 = f32::from(nan16);
-        let neg_nan32_from_16 = f32::from(neg_nan16);
-        let nan64_from_16 = f64::from(nan16);
-        let neg_nan64_from_16 = f64::from(neg_nan16);
-        let nan64_from_32 = f64::from(nan32);
-        let neg_nan64_from_32 = f64::from(neg_nan32);
-
-        assert!(nan16.is_nan() && nan16.is_sign_positive());
-        assert!(neg_nan16.is_nan() && neg_nan16.is_sign_negative());
-        assert!(nan32.is_nan() && nan32.is_sign_positive());
-        assert!(neg_nan32.is_nan() && neg_nan32.is_sign_negative());
-        assert!(nan32_from_16.is_nan() && nan32_from_16.is_sign_positive());
-        assert!(neg_nan32_from_16.is_nan() && neg_nan32_from_16.is_sign_negative());
-        assert!(nan64_from_16.is_nan() && nan64_from_16.is_sign_positive());
-        assert!(neg_nan64_from_16.is_nan() && neg_nan64_from_16.is_sign_negative());
-        assert!(nan64_from_32.is_nan() && nan64_from_32.is_sign_positive());
-        assert!(neg_nan64_from_32.is_nan() && neg_nan64_from_32.is_sign_negative());
-    }
-
-    #[test]
-    fn test_f16_to_f32() {
-        let f = f16::from_f32(7.0);
-        assert_eq!(f.to_f32(), 7.0f32);
-
-        // 7.1 is NOT exactly representable in 16-bit, it's rounded
-        let f = f16::from_f32(7.1);
-        let diff = (f.to_f32() - 7.1f32).abs();
-        // diff must be <= 4 * EPSILON, as 7 has two more significant bits than 1
-        assert!(diff <= 4.0 * f16::EPSILON.to_f32());
-
-        assert_eq!(f16::from_bits(0x0000_0001).to_f32(), 2.0f32.powi(-24));
-        assert_eq!(f16::from_bits(0x0000_0005).to_f32(), 5.0 * 2.0f32.powi(-24));
-
-        assert_eq!(f16::from_bits(0x0000_0001), f16::from_f32(2.0f32.powi(-24)));
-        assert_eq!(
-            f16::from_bits(0x0000_0005),
-            f16::from_f32(5.0 * 2.0f32.powi(-24))
-        );
-    }
-
-    #[test]
-    fn test_f16_to_f64() {
-        let f = f16::from_f64(7.0);
-        assert_eq!(f.to_f64(), 7.0f64);
-
-        // 7.1 is NOT exactly representable in 16-bit, it's rounded
-        let f = f16::from_f64(7.1);
-        let diff = (f.to_f64() - 7.1f64).abs();
-        // diff must be <= 4 * EPSILON, as 7 has two more significant bits than 1
-        assert!(diff <= 4.0 * f16::EPSILON.to_f64());
-
-        assert_eq!(f16::from_bits(0x0000_0001).to_f64(), 2.0f64.powi(-24));
-        assert_eq!(f16::from_bits(0x0000_0005).to_f64(), 5.0 * 2.0f64.powi(-24));
-
-        assert_eq!(f16::from_bits(0x0000_0001), f16::from_f64(2.0f64.powi(-24)));
-        assert_eq!(
-            f16::from_bits(0x0000_0005),
-            f16::from_f64(5.0 * 2.0f64.powi(-24))
-        );
-    }
-
-    #[test]
-    fn test_comparisons() {
-        let zero = f16::from_f64(0.0);
-        let one = f16::from_f64(1.0);
-        let neg_zero = f16::from_f64(-0.0);
-        let neg_one = f16::from_f64(-1.0);
-
-        assert_eq!(zero.partial_cmp(&neg_zero), Some(Ordering::Equal));
-        assert_eq!(neg_zero.partial_cmp(&zero), Some(Ordering::Equal));
-        assert!(zero == neg_zero);
-        assert!(neg_zero == zero);
-        assert!(!(zero != neg_zero));
-        assert!(!(neg_zero != zero));
-        assert!(!(zero < neg_zero));
-        assert!(!(neg_zero < zero));
-        assert!(zero <= neg_zero);
-        assert!(neg_zero <= zero);
-        assert!(!(zero > neg_zero));
-        assert!(!(neg_zero > zero));
-        assert!(zero >= neg_zero);
-        assert!(neg_zero >= zero);
-
-        assert_eq!(one.partial_cmp(&neg_zero), Some(Ordering::Greater));
-        assert_eq!(neg_zero.partial_cmp(&one), Some(Ordering::Less));
-        assert!(!(one == neg_zero));
-        assert!(!(neg_zero == one));
-        assert!(one != neg_zero);
-        assert!(neg_zero != one);
-        assert!(!(one < neg_zero));
-        assert!(neg_zero < one);
-        assert!(!(one <= neg_zero));
-        assert!(neg_zero <= one);
-        assert!(one > neg_zero);
-        assert!(!(neg_zero > one));
-        assert!(one >= neg_zero);
-        assert!(!(neg_zero >= one));
-
-        assert_eq!(one.partial_cmp(&neg_one), Some(Ordering::Greater));
-        assert_eq!(neg_one.partial_cmp(&one), Some(Ordering::Less));
-        assert!(!(one == neg_one));
-        assert!(!(neg_one == one));
-        assert!(one != neg_one);
-        assert!(neg_one != one);
-        assert!(!(one < neg_one));
-        assert!(neg_one < one);
-        assert!(!(one <= neg_one));
-        assert!(neg_one <= one);
-        assert!(one > neg_one);
-        assert!(!(neg_one > one));
-        assert!(one >= neg_one);
-        assert!(!(neg_one >= one));
-    }
-
-    #[test]
-    #[allow(clippy::erasing_op, clippy::identity_op)]
-    fn round_to_even_f32() {
-        // smallest positive subnormal = 0b0.0000_0000_01 * 2^-14 = 2^-24
-        let min_sub = f16::from_bits(1);
-        let min_sub_f = (-24f32).exp2();
-        assert_eq!(f16::from_f32(min_sub_f).to_bits(), min_sub.to_bits());
-        assert_eq!(f32::from(min_sub).to_bits(), min_sub_f.to_bits());
-
-        // 0.0000000000_011111 rounded to 0.0000000000 (< tie, no rounding)
-        // 0.0000000000_100000 rounded to 0.0000000000 (tie and even, remains at even)
-        // 0.0000000000_100001 rounded to 0.0000000001 (> tie, rounds up)
-        assert_eq!(
-            f16::from_f32(min_sub_f * 0.49).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            f16::from_f32(min_sub_f * 0.50).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            f16::from_f32(min_sub_f * 0.51).to_bits(),
-            min_sub.to_bits() * 1
-        );
-
-        // 0.0000000001_011111 rounded to 0.0000000001 (< tie, no rounding)
-        // 0.0000000001_100000 rounded to 0.0000000010 (tie and odd, rounds up to even)
-        // 0.0000000001_100001 rounded to 0.0000000010 (> tie, rounds up)
-        assert_eq!(
-            f16::from_f32(min_sub_f * 1.49).to_bits(),
-            min_sub.to_bits() * 1
-        );
-        assert_eq!(
-            f16::from_f32(min_sub_f * 1.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            f16::from_f32(min_sub_f * 1.51).to_bits(),
-            min_sub.to_bits() * 2
-        );
-
-        // 0.0000000010_011111 rounded to 0.0000000010 (< tie, no rounding)
-        // 0.0000000010_100000 rounded to 0.0000000010 (tie and even, remains at even)
-        // 0.0000000010_100001 rounded to 0.0000000011 (> tie, rounds up)
-        assert_eq!(
-            f16::from_f32(min_sub_f * 2.49).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            f16::from_f32(min_sub_f * 2.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            f16::from_f32(min_sub_f * 2.51).to_bits(),
-            min_sub.to_bits() * 3
-        );
-
-        assert_eq!(
-            f16::from_f32(2000.49f32).to_bits(),
-            f16::from_f32(2000.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2000.50f32).to_bits(),
-            f16::from_f32(2000.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2000.51f32).to_bits(),
-            f16::from_f32(2001.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2001.49f32).to_bits(),
-            f16::from_f32(2001.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2001.50f32).to_bits(),
-            f16::from_f32(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2001.51f32).to_bits(),
-            f16::from_f32(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2002.49f32).to_bits(),
-            f16::from_f32(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2002.50f32).to_bits(),
-            f16::from_f32(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f32(2002.51f32).to_bits(),
-            f16::from_f32(2003.0).to_bits()
-        );
-    }
-
-    #[test]
-    #[allow(clippy::erasing_op, clippy::identity_op)]
-    fn round_to_even_f64() {
-        // smallest positive subnormal = 0b0.0000_0000_01 * 2^-14 = 2^-24
-        let min_sub = f16::from_bits(1);
-        let min_sub_f = (-24f64).exp2();
-        assert_eq!(f16::from_f64(min_sub_f).to_bits(), min_sub.to_bits());
-        assert_eq!(f64::from(min_sub).to_bits(), min_sub_f.to_bits());
-
-        // 0.0000000000_011111 rounded to 0.0000000000 (< tie, no rounding)
-        // 0.0000000000_100000 rounded to 0.0000000000 (tie and even, remains at even)
-        // 0.0000000000_100001 rounded to 0.0000000001 (> tie, rounds up)
-        assert_eq!(
-            f16::from_f64(min_sub_f * 0.49).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            f16::from_f64(min_sub_f * 0.50).to_bits(),
-            min_sub.to_bits() * 0
-        );
-        assert_eq!(
-            f16::from_f64(min_sub_f * 0.51).to_bits(),
-            min_sub.to_bits() * 1
-        );
-
-        // 0.0000000001_011111 rounded to 0.0000000001 (< tie, no rounding)
-        // 0.0000000001_100000 rounded to 0.0000000010 (tie and odd, rounds up to even)
-        // 0.0000000001_100001 rounded to 0.0000000010 (> tie, rounds up)
-        assert_eq!(
-            f16::from_f64(min_sub_f * 1.49).to_bits(),
-            min_sub.to_bits() * 1
-        );
-        assert_eq!(
-            f16::from_f64(min_sub_f * 1.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            f16::from_f64(min_sub_f * 1.51).to_bits(),
-            min_sub.to_bits() * 2
-        );
-
-        // 0.0000000010_011111 rounded to 0.0000000010 (< tie, no rounding)
-        // 0.0000000010_100000 rounded to 0.0000000010 (tie and even, remains at even)
-        // 0.0000000010_100001 rounded to 0.0000000011 (> tie, rounds up)
-        assert_eq!(
-            f16::from_f64(min_sub_f * 2.49).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            f16::from_f64(min_sub_f * 2.50).to_bits(),
-            min_sub.to_bits() * 2
-        );
-        assert_eq!(
-            f16::from_f64(min_sub_f * 2.51).to_bits(),
-            min_sub.to_bits() * 3
-        );
-
-        assert_eq!(
-            f16::from_f64(2000.49f64).to_bits(),
-            f16::from_f64(2000.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2000.50f64).to_bits(),
-            f16::from_f64(2000.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2000.51f64).to_bits(),
-            f16::from_f64(2001.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2001.49f64).to_bits(),
-            f16::from_f64(2001.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2001.50f64).to_bits(),
-            f16::from_f64(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2001.51f64).to_bits(),
-            f16::from_f64(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2002.49f64).to_bits(),
-            f16::from_f64(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2002.50f64).to_bits(),
-            f16::from_f64(2002.0).to_bits()
-        );
-        assert_eq!(
-            f16::from_f64(2002.51f64).to_bits(),
-            f16::from_f64(2003.0).to_bits()
-        );
-    }
-
-    impl quickcheck::Arbitrary for f16 {
-        fn arbitrary(g: &mut quickcheck::Gen) -> Self {
-            f16(u16::arbitrary(g))
-        }
-    }
-
-    #[quickcheck]
-    fn qc_roundtrip_f16_f32_is_identity(f: f16) -> bool {
-        let roundtrip = f16::from_f32(f.to_f32());
-        if f.is_nan() {
-            roundtrip.is_nan() && f.is_sign_negative() == roundtrip.is_sign_negative()
-        } else {
-            f.0 == roundtrip.0
-        }
-    }
-
-    #[quickcheck]
-    fn qc_roundtrip_f16_f64_is_identity(f: f16) -> bool {
-        let roundtrip = f16::from_f64(f.to_f64());
-        if f.is_nan() {
-            roundtrip.is_nan() && f.is_sign_negative() == roundtrip.is_sign_negative()
-        } else {
-            f.0 == roundtrip.0
-        }
-    }
-}
diff --git a/vendor/half/src/binary16/convert.rs b/vendor/half/src/binary16/convert.rs
deleted file mode 100644
index b96910f..0000000
--- a/vendor/half/src/binary16/convert.rs
+++ /dev/null
@@ -1,752 +0,0 @@
-#![allow(dead_code, unused_imports)]
-use crate::leading_zeros::leading_zeros_u16;
-use core::mem;
-
-macro_rules! convert_fn {
-    (fn $name:ident($($var:ident : $vartype:ty),+) -> $restype:ty {
-            if feature("f16c") { $f16c:expr }
-            else { $fallback:expr }}) => {
-        #[inline]
-        pub(crate) fn $name($($var: $vartype),+) -> $restype {
-            // Use CPU feature detection if using std
-            #[cfg(all(
-                feature = "use-intrinsics",
-                feature = "std",
-                any(target_arch = "x86", target_arch = "x86_64"),
-                not(target_feature = "f16c")
-            ))]
-            {
-                if is_x86_feature_detected!("f16c") {
-                    $f16c
-                } else {
-                    $fallback
-                }
-            }
-            // Use intrinsics directly when a compile target or using no_std
-            #[cfg(all(
-                feature = "use-intrinsics",
-                any(target_arch = "x86", target_arch = "x86_64"),
-                target_feature = "f16c"
-            ))]
-            {
-                $f16c
-            }
-            // Fallback to software
-            #[cfg(any(
-                not(feature = "use-intrinsics"),
-                not(any(target_arch = "x86", target_arch = "x86_64")),
-                all(not(feature = "std"), not(target_feature = "f16c"))
-            ))]
-            {
-                $fallback
-            }
-        }
-    };
-}
-
-convert_fn! {
-    fn f32_to_f16(f: f32) -> u16 {
-        if feature("f16c") {
-            unsafe { x86::f32_to_f16_x86_f16c(f) }
-        } else {
-            f32_to_f16_fallback(f)
-        }
-    }
-}
-
-convert_fn! {
-    fn f64_to_f16(f: f64) -> u16 {
-        if feature("f16c") {
-            unsafe { x86::f32_to_f16_x86_f16c(f as f32) }
-        } else {
-            f64_to_f16_fallback(f)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16_to_f32(i: u16) -> f32 {
-        if feature("f16c") {
-            unsafe { x86::f16_to_f32_x86_f16c(i) }
-        } else {
-            f16_to_f32_fallback(i)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16_to_f64(i: u16) -> f64 {
-        if feature("f16c") {
-            unsafe { x86::f16_to_f32_x86_f16c(i) as f64 }
-        } else {
-            f16_to_f64_fallback(i)
-        }
-    }
-}
-
-convert_fn! {
-    fn f32x4_to_f16x4(f: &[f32; 4]) -> [u16; 4] {
-        if feature("f16c") {
-            unsafe { x86::f32x4_to_f16x4_x86_f16c(f) }
-        } else {
-            f32x4_to_f16x4_fallback(f)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16x4_to_f32x4(i: &[u16; 4]) -> [f32; 4] {
-        if feature("f16c") {
-            unsafe { x86::f16x4_to_f32x4_x86_f16c(i) }
-        } else {
-            f16x4_to_f32x4_fallback(i)
-        }
-    }
-}
-
-convert_fn! {
-    fn f64x4_to_f16x4(f: &[f64; 4]) -> [u16; 4] {
-        if feature("f16c") {
-            unsafe { x86::f64x4_to_f16x4_x86_f16c(f) }
-        } else {
-            f64x4_to_f16x4_fallback(f)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16x4_to_f64x4(i: &[u16; 4]) -> [f64; 4] {
-        if feature("f16c") {
-            unsafe { x86::f16x4_to_f64x4_x86_f16c(i) }
-        } else {
-            f16x4_to_f64x4_fallback(i)
-        }
-    }
-}
-
-convert_fn! {
-    fn f32x8_to_f16x8(f: &[f32; 8]) -> [u16; 8] {
-        if feature("f16c") {
-            unsafe { x86::f32x8_to_f16x8_x86_f16c(f) }
-        } else {
-            f32x8_to_f16x8_fallback(f)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16x8_to_f32x8(i: &[u16; 8]) -> [f32; 8] {
-        if feature("f16c") {
-            unsafe { x86::f16x8_to_f32x8_x86_f16c(i) }
-        } else {
-            f16x8_to_f32x8_fallback(i)
-        }
-    }
-}
-
-convert_fn! {
-    fn f64x8_to_f16x8(f: &[f64; 8]) -> [u16; 8] {
-        if feature("f16c") {
-            unsafe { x86::f64x8_to_f16x8_x86_f16c(f) }
-        } else {
-            f64x8_to_f16x8_fallback(f)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16x8_to_f64x8(i: &[u16; 8]) -> [f64; 8] {
-        if feature("f16c") {
-            unsafe { x86::f16x8_to_f64x8_x86_f16c(i) }
-        } else {
-            f16x8_to_f64x8_fallback(i)
-        }
-    }
-}
-
-convert_fn! {
-    fn f32_to_f16_slice(src: &[f32], dst: &mut [u16]) -> () {
-        if feature("f16c") {
-            convert_chunked_slice_8(src, dst, x86::f32x8_to_f16x8_x86_f16c,
-                x86::f32x4_to_f16x4_x86_f16c)
-        } else {
-            slice_fallback(src, dst, f32_to_f16_fallback)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16_to_f32_slice(src: &[u16], dst: &mut [f32]) -> () {
-        if feature("f16c") {
-            convert_chunked_slice_8(src, dst, x86::f16x8_to_f32x8_x86_f16c,
-                x86::f16x4_to_f32x4_x86_f16c)
-        } else {
-            slice_fallback(src, dst, f16_to_f32_fallback)
-        }
-    }
-}
-
-convert_fn! {
-    fn f64_to_f16_slice(src: &[f64], dst: &mut [u16]) -> () {
-        if feature("f16c") {
-            convert_chunked_slice_8(src, dst, x86::f64x8_to_f16x8_x86_f16c,
-                x86::f64x4_to_f16x4_x86_f16c)
-        } else {
-            slice_fallback(src, dst, f64_to_f16_fallback)
-        }
-    }
-}
-
-convert_fn! {
-    fn f16_to_f64_slice(src: &[u16], dst: &mut [f64]) -> () {
-        if feature("f16c") {
-            convert_chunked_slice_8(src, dst, x86::f16x8_to_f64x8_x86_f16c,
-                x86::f16x4_to_f64x4_x86_f16c)
-        } else {
-            slice_fallback(src, dst, f16_to_f64_fallback)
-        }
-    }
-}
-
-/// Chunks sliced into x8 or x4 arrays
-#[inline]
-fn convert_chunked_slice_8<S: Copy + Default, D: Copy>(
-    src: &[S],
-    dst: &mut [D],
-    fn8: unsafe fn(&[S; 8]) -> [D; 8],
-    fn4: unsafe fn(&[S; 4]) -> [D; 4],
-) {
-    assert_eq!(src.len(), dst.len());
-
-    // TODO: Can be further optimized with array_chunks when it becomes stabilized
-
-    let src_chunks = src.chunks_exact(8);
-    let mut dst_chunks = dst.chunks_exact_mut(8);
-    let src_remainder = src_chunks.remainder();
-    for (s, d) in src_chunks.zip(&mut dst_chunks) {
-        let chunk: &[S; 8] = s.try_into().unwrap();
-        d.copy_from_slice(unsafe { &fn8(chunk) });
-    }
-
-    // Process remainder
-    if src_remainder.len() > 4 {
-        let mut buf: [S; 8] = Default::default();
-        buf[..src_remainder.len()].copy_from_slice(src_remainder);
-        let vec = unsafe { fn8(&buf) };
-        let dst_remainder = dst_chunks.into_remainder();
-        dst_remainder.copy_from_slice(&vec[..dst_remainder.len()]);
-    } else if !src_remainder.is_empty() {
-        let mut buf: [S; 4] = Default::default();
-        buf[..src_remainder.len()].copy_from_slice(src_remainder);
-        let vec = unsafe { fn4(&buf) };
-        let dst_remainder = dst_chunks.into_remainder();
-        dst_remainder.copy_from_slice(&vec[..dst_remainder.len()]);
-    }
-}
-
-/// Chunks sliced into x4 arrays
-#[inline]
-fn convert_chunked_slice_4<S: Copy + Default, D: Copy>(
-    src: &[S],
-    dst: &mut [D],
-    f: unsafe fn(&[S; 4]) -> [D; 4],
-) {
-    assert_eq!(src.len(), dst.len());
-
-    // TODO: Can be further optimized with array_chunks when it becomes stabilized
-
-    let src_chunks = src.chunks_exact(4);
-    let mut dst_chunks = dst.chunks_exact_mut(4);
-    let src_remainder = src_chunks.remainder();
-    for (s, d) in src_chunks.zip(&mut dst_chunks) {
-        let chunk: &[S; 4] = s.try_into().unwrap();
-        d.copy_from_slice(unsafe { &f(chunk) });
-    }
-
-    // Process remainder
-    if !src_remainder.is_empty() {
-        let mut buf: [S; 4] = Default::default();
-        buf[..src_remainder.len()].copy_from_slice(src_remainder);
-        let vec = unsafe { f(&buf) };
-        let dst_remainder = dst_chunks.into_remainder();
-        dst_remainder.copy_from_slice(&vec[..dst_remainder.len()]);
-    }
-}
-
-/////////////// Fallbacks ////////////////
-
-// In the below functions, round to nearest, with ties to even.
-// Let us call the most significant bit that will be shifted out the round_bit.
-//
-// Round up if either
-//  a) Removed part > tie.
-//     (mantissa & round_bit) != 0 && (mantissa & (round_bit - 1)) != 0
-//  b) Removed part == tie, and retained part is odd.
-//     (mantissa & round_bit) != 0 && (mantissa & (2 * round_bit)) != 0
-// (If removed part == tie and retained part is even, do not round up.)
-// These two conditions can be combined into one:
-//     (mantissa & round_bit) != 0 && (mantissa & ((round_bit - 1) | (2 * round_bit))) != 0
-// which can be simplified into
-//     (mantissa & round_bit) != 0 && (mantissa & (3 * round_bit - 1)) != 0
-
-#[inline]
-pub(crate) const fn f32_to_f16_fallback(value: f32) -> u16 {
-    // TODO: Replace mem::transmute with to_bits() once to_bits is const-stabilized
-    // Convert to raw bytes
-    let x: u32 = unsafe { mem::transmute(value) };
-
-    // Extract IEEE754 components
-    let sign = x & 0x8000_0000u32;
-    let exp = x & 0x7F80_0000u32;
-    let man = x & 0x007F_FFFFu32;
-
-    // Check for all exponent bits being set, which is Infinity or NaN
-    if exp == 0x7F80_0000u32 {
-        // Set mantissa MSB for NaN (and also keep shifted mantissa bits)
-        let nan_bit = if man == 0 { 0 } else { 0x0200u32 };
-        return ((sign >> 16) | 0x7C00u32 | nan_bit | (man >> 13)) as u16;
-    }
-
-    // The number is normalized, start assembling half precision version
-    let half_sign = sign >> 16;
-    // Unbias the exponent, then bias for half precision
-    let unbiased_exp = ((exp >> 23) as i32) - 127;
-    let half_exp = unbiased_exp + 15;
-
-    // Check for exponent overflow, return +infinity
-    if half_exp >= 0x1F {
-        return (half_sign | 0x7C00u32) as u16;
-    }
-
-    // Check for underflow
-    if half_exp <= 0 {
-        // Check mantissa for what we can do
-        if 14 - half_exp > 24 {
-            // No rounding possibility, so this is a full underflow, return signed zero
-            return half_sign as u16;
-        }
-        // Don't forget about hidden leading mantissa bit when assembling mantissa
-        let man = man | 0x0080_0000u32;
-        let mut half_man = man >> (14 - half_exp);
-        // Check for rounding (see comment above functions)
-        let round_bit = 1 << (13 - half_exp);
-        if (man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0 {
-            half_man += 1;
-        }
-        // No exponent for subnormals
-        return (half_sign | half_man) as u16;
-    }
-
-    // Rebias the exponent
-    let half_exp = (half_exp as u32) << 10;
-    let half_man = man >> 13;
-    // Check for rounding (see comment above functions)
-    let round_bit = 0x0000_1000u32;
-    if (man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0 {
-        // Round it
-        ((half_sign | half_exp | half_man) + 1) as u16
-    } else {
-        (half_sign | half_exp | half_man) as u16
-    }
-}
-
-#[inline]
-pub(crate) const fn f64_to_f16_fallback(value: f64) -> u16 {
-    // Convert to raw bytes, truncating the last 32-bits of mantissa; that precision will always
-    // be lost on half-precision.
-    // TODO: Replace mem::transmute with to_bits() once to_bits is const-stabilized
-    let val: u64 = unsafe { mem::transmute(value) };
-    let x = (val >> 32) as u32;
-
-    // Extract IEEE754 components
-    let sign = x & 0x8000_0000u32;
-    let exp = x & 0x7FF0_0000u32;
-    let man = x & 0x000F_FFFFu32;
-
-    // Check for all exponent bits being set, which is Infinity or NaN
-    if exp == 0x7FF0_0000u32 {
-        // Set mantissa MSB for NaN (and also keep shifted mantissa bits).
-        // We also have to check the last 32 bits.
-        let nan_bit = if man == 0 && (val as u32 == 0) {
-            0
-        } else {
-            0x0200u32
-        };
-        return ((sign >> 16) | 0x7C00u32 | nan_bit | (man >> 10)) as u16;
-    }
-
-    // The number is normalized, start assembling half precision version
-    let half_sign = sign >> 16;
-    // Unbias the exponent, then bias for half precision
-    let unbiased_exp = ((exp >> 20) as i64) - 1023;
-    let half_exp = unbiased_exp + 15;
-
-    // Check for exponent overflow, return +infinity
-    if half_exp >= 0x1F {
-        return (half_sign | 0x7C00u32) as u16;
-    }
-
-    // Check for underflow
-    if half_exp <= 0 {
-        // Check mantissa for what we can do
-        if 10 - half_exp > 21 {
-            // No rounding possibility, so this is a full underflow, return signed zero
-            return half_sign as u16;
-        }
-        // Don't forget about hidden leading mantissa bit when assembling mantissa
-        let man = man | 0x0010_0000u32;
-        let mut half_man = man >> (11 - half_exp);
-        // Check for rounding (see comment above functions)
-        let round_bit = 1 << (10 - half_exp);
-        if (man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0 {
-            half_man += 1;
-        }
-        // No exponent for subnormals
-        return (half_sign | half_man) as u16;
-    }
-
-    // Rebias the exponent
-    let half_exp = (half_exp as u32) << 10;
-    let half_man = man >> 10;
-    // Check for rounding (see comment above functions)
-    let round_bit = 0x0000_0200u32;
-    if (man & round_bit) != 0 && (man & (3 * round_bit - 1)) != 0 {
-        // Round it
-        ((half_sign | half_exp | half_man) + 1) as u16
-    } else {
-        (half_sign | half_exp | half_man) as u16
-    }
-}
-
-#[inline]
-pub(crate) const fn f16_to_f32_fallback(i: u16) -> f32 {
-    // Check for signed zero
-    // TODO: Replace mem::transmute with from_bits() once from_bits is const-stabilized
-    if i & 0x7FFFu16 == 0 {
-        return unsafe { mem::transmute((i as u32) << 16) };
-    }
-
-    let half_sign = (i & 0x8000u16) as u32;
-    let half_exp = (i & 0x7C00u16) as u32;
-    let half_man = (i & 0x03FFu16) as u32;
-
-    // Check for an infinity or NaN when all exponent bits set
-    if half_exp == 0x7C00u32 {
-        // Check for signed infinity if mantissa is zero
-        if half_man == 0 {
-            return unsafe { mem::transmute((half_sign << 16) | 0x7F80_0000u32) };
-        } else {
-            // NaN, keep current mantissa but also set most significiant mantissa bit
-            return unsafe {
-                mem::transmute((half_sign << 16) | 0x7FC0_0000u32 | (half_man << 13))
-            };
-        }
-    }
-
-    // Calculate single-precision components with adjusted exponent
-    let sign = half_sign << 16;
-    // Unbias exponent
-    let unbiased_exp = ((half_exp as i32) >> 10) - 15;
-
-    // Check for subnormals, which will be normalized by adjusting exponent
-    if half_exp == 0 {
-        // Calculate how much to adjust the exponent by
-        let e = leading_zeros_u16(half_man as u16) - 6;
-
-        // Rebias and adjust exponent
-        let exp = (127 - 15 - e) << 23;
-        let man = (half_man << (14 + e)) & 0x7F_FF_FFu32;
-        return unsafe { mem::transmute(sign | exp | man) };
-    }
-
-    // Rebias exponent for a normalized normal
-    let exp = ((unbiased_exp + 127) as u32) << 23;
-    let man = (half_man & 0x03FFu32) << 13;
-    unsafe { mem::transmute(sign | exp | man) }
-}
-
-#[inline]
-pub(crate) const fn f16_to_f64_fallback(i: u16) -> f64 {
-    // Check for signed zero
-    // TODO: Replace mem::transmute with from_bits() once from_bits is const-stabilized
-    if i & 0x7FFFu16 == 0 {
-        return unsafe { mem::transmute((i as u64) << 48) };
-    }
-
-    let half_sign = (i & 0x8000u16) as u64;
-    let half_exp = (i & 0x7C00u16) as u64;
-    let half_man = (i & 0x03FFu16) as u64;
-
-    // Check for an infinity or NaN when all exponent bits set
-    if half_exp == 0x7C00u64 {
-        // Check for signed infinity if mantissa is zero
-        if half_man == 0 {
-            return unsafe { mem::transmute((half_sign << 48) | 0x7FF0_0000_0000_0000u64) };
-        } else {
-            // NaN, keep current mantissa but also set most significiant mantissa bit
-            return unsafe {
-                mem::transmute((half_sign << 48) | 0x7FF8_0000_0000_0000u64 | (half_man << 42))
-            };
-        }
-    }
-
-    // Calculate double-precision components with adjusted exponent
-    let sign = half_sign << 48;
-    // Unbias exponent
-    let unbiased_exp = ((half_exp as i64) >> 10) - 15;
-
-    // Check for subnormals, which will be normalized by adjusting exponent
-    if half_exp == 0 {
-        // Calculate how much to adjust the exponent by
-        let e = leading_zeros_u16(half_man as u16) - 6;
-
-        // Rebias and adjust exponent
-        let exp = ((1023 - 15 - e) as u64) << 52;
-        let man = (half_man << (43 + e)) & 0xF_FFFF_FFFF_FFFFu64;
-        return unsafe { mem::transmute(sign | exp | man) };
-    }
-
-    // Rebias exponent for a normalized normal
-    let exp = ((unbiased_exp + 1023) as u64) << 52;
-    let man = (half_man & 0x03FFu64) << 42;
-    unsafe { mem::transmute(sign | exp | man) }
-}
-
-#[inline]
-fn f16x4_to_f32x4_fallback(v: &[u16; 4]) -> [f32; 4] {
-    [
-        f16_to_f32_fallback(v[0]),
-        f16_to_f32_fallback(v[1]),
-        f16_to_f32_fallback(v[2]),
-        f16_to_f32_fallback(v[3]),
-    ]
-}
-
-#[inline]
-fn f32x4_to_f16x4_fallback(v: &[f32; 4]) -> [u16; 4] {
-    [
-        f32_to_f16_fallback(v[0]),
-        f32_to_f16_fallback(v[1]),
-        f32_to_f16_fallback(v[2]),
-        f32_to_f16_fallback(v[3]),
-    ]
-}
-
-#[inline]
-fn f16x4_to_f64x4_fallback(v: &[u16; 4]) -> [f64; 4] {
-    [
-        f16_to_f64_fallback(v[0]),
-        f16_to_f64_fallback(v[1]),
-        f16_to_f64_fallback(v[2]),
-        f16_to_f64_fallback(v[3]),
-    ]
-}
-
-#[inline]
-fn f64x4_to_f16x4_fallback(v: &[f64; 4]) -> [u16; 4] {
-    [
-        f64_to_f16_fallback(v[0]),
-        f64_to_f16_fallback(v[1]),
-        f64_to_f16_fallback(v[2]),
-        f64_to_f16_fallback(v[3]),
-    ]
-}
-
-#[inline]
-fn f16x8_to_f32x8_fallback(v: &[u16; 8]) -> [f32; 8] {
-    [
-        f16_to_f32_fallback(v[0]),
-        f16_to_f32_fallback(v[1]),
-        f16_to_f32_fallback(v[2]),
-        f16_to_f32_fallback(v[3]),
-        f16_to_f32_fallback(v[4]),
-        f16_to_f32_fallback(v[5]),
-        f16_to_f32_fallback(v[6]),
-        f16_to_f32_fallback(v[7]),
-    ]
-}
-
-#[inline]
-fn f32x8_to_f16x8_fallback(v: &[f32; 8]) -> [u16; 8] {
-    [
-        f32_to_f16_fallback(v[0]),
-        f32_to_f16_fallback(v[1]),
-        f32_to_f16_fallback(v[2]),
-        f32_to_f16_fallback(v[3]),
-        f32_to_f16_fallback(v[4]),
-        f32_to_f16_fallback(v[5]),
-        f32_to_f16_fallback(v[6]),
-        f32_to_f16_fallback(v[7]),
-    ]
-}
-
-#[inline]
-fn f16x8_to_f64x8_fallback(v: &[u16; 8]) -> [f64; 8] {
-    [
-        f16_to_f64_fallback(v[0]),
-        f16_to_f64_fallback(v[1]),
-        f16_to_f64_fallback(v[2]),
-        f16_to_f64_fallback(v[3]),
-        f16_to_f64_fallback(v[4]),
-        f16_to_f64_fallback(v[5]),
-        f16_to_f64_fallback(v[6]),
-        f16_to_f64_fallback(v[7]),
-    ]
-}
-
-#[inline]
-fn f64x8_to_f16x8_fallback(v: &[f64; 8]) -> [u16; 8] {
-    [
-        f64_to_f16_fallback(v[0]),
-        f64_to_f16_fallback(v[1]),
-        f64_to_f16_fallback(v[2]),
-        f64_to_f16_fallback(v[3]),
-        f64_to_f16_fallback(v[4]),
-        f64_to_f16_fallback(v[5]),
-        f64_to_f16_fallback(v[6]),
-        f64_to_f16_fallback(v[7]),
-    ]
-}
-
-#[inline]
-fn slice_fallback<S: Copy, D>(src: &[S], dst: &mut [D], f: fn(S) -> D) {
-    assert_eq!(src.len(), dst.len());
-    for (s, d) in src.iter().copied().zip(dst.iter_mut()) {
-        *d = f(s);
-    }
-}
-
-/////////////// x86/x86_64 f16c ////////////////
-#[cfg(all(
-    feature = "use-intrinsics",
-    any(target_arch = "x86", target_arch = "x86_64")
-))]
-mod x86 {
-    use core::{mem::MaybeUninit, ptr};
-
-    #[cfg(target_arch = "x86")]
-    use core::arch::x86::{
-        __m128, __m128i, __m256, _mm256_cvtph_ps, _mm256_cvtps_ph, _mm_cvtph_ps,
-        _MM_FROUND_TO_NEAREST_INT,
-    };
-    #[cfg(target_arch = "x86_64")]
-    use core::arch::x86_64::{
-        __m128, __m128i, __m256, _mm256_cvtph_ps, _mm256_cvtps_ph, _mm_cvtph_ps, _mm_cvtps_ph,
-        _MM_FROUND_TO_NEAREST_INT,
-    };
-
-    use super::convert_chunked_slice_8;
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f16_to_f32_x86_f16c(i: u16) -> f32 {
-        let mut vec = MaybeUninit::<__m128i>::zeroed();
-        vec.as_mut_ptr().cast::<u16>().write(i);
-        let retval = _mm_cvtph_ps(vec.assume_init());
-        *(&retval as *const __m128).cast()
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f32_to_f16_x86_f16c(f: f32) -> u16 {
-        let mut vec = MaybeUninit::<__m128>::zeroed();
-        vec.as_mut_ptr().cast::<f32>().write(f);
-        let retval = _mm_cvtps_ph(vec.assume_init(), _MM_FROUND_TO_NEAREST_INT);
-        *(&retval as *const __m128i).cast()
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f16x4_to_f32x4_x86_f16c(v: &[u16; 4]) -> [f32; 4] {
-        let mut vec = MaybeUninit::<__m128i>::zeroed();
-        ptr::copy_nonoverlapping(v.as_ptr(), vec.as_mut_ptr().cast(), 4);
-        let retval = _mm_cvtph_ps(vec.assume_init());
-        *(&retval as *const __m128).cast()
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f32x4_to_f16x4_x86_f16c(v: &[f32; 4]) -> [u16; 4] {
-        let mut vec = MaybeUninit::<__m128>::uninit();
-        ptr::copy_nonoverlapping(v.as_ptr(), vec.as_mut_ptr().cast(), 4);
-        let retval = _mm_cvtps_ph(vec.assume_init(), _MM_FROUND_TO_NEAREST_INT);
-        *(&retval as *const __m128i).cast()
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f16x4_to_f64x4_x86_f16c(v: &[u16; 4]) -> [f64; 4] {
-        let array = f16x4_to_f32x4_x86_f16c(v);
-        // Let compiler vectorize this regular cast for now.
-        // TODO: investigate auto-detecting sse2/avx convert features
-        [
-            array[0] as f64,
-            array[1] as f64,
-            array[2] as f64,
-            array[3] as f64,
-        ]
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f64x4_to_f16x4_x86_f16c(v: &[f64; 4]) -> [u16; 4] {
-        // Let compiler vectorize this regular cast for now.
-        // TODO: investigate auto-detecting sse2/avx convert features
-        let v = [v[0] as f32, v[1] as f32, v[2] as f32, v[3] as f32];
-        f32x4_to_f16x4_x86_f16c(&v)
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f16x8_to_f32x8_x86_f16c(v: &[u16; 8]) -> [f32; 8] {
-        let mut vec = MaybeUninit::<__m128i>::zeroed();
-        ptr::copy_nonoverlapping(v.as_ptr(), vec.as_mut_ptr().cast(), 8);
-        let retval = _mm256_cvtph_ps(vec.assume_init());
-        *(&retval as *const __m256).cast()
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f32x8_to_f16x8_x86_f16c(v: &[f32; 8]) -> [u16; 8] {
-        let mut vec = MaybeUninit::<__m256>::uninit();
-        ptr::copy_nonoverlapping(v.as_ptr(), vec.as_mut_ptr().cast(), 8);
-        let retval = _mm256_cvtps_ph(vec.assume_init(), _MM_FROUND_TO_NEAREST_INT);
-        *(&retval as *const __m128i).cast()
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f16x8_to_f64x8_x86_f16c(v: &[u16; 8]) -> [f64; 8] {
-        let array = f16x8_to_f32x8_x86_f16c(v);
-        // Let compiler vectorize this regular cast for now.
-        // TODO: investigate auto-detecting sse2/avx convert features
-        [
-            array[0] as f64,
-            array[1] as f64,
-            array[2] as f64,
-            array[3] as f64,
-            array[4] as f64,
-            array[5] as f64,
-            array[6] as f64,
-            array[7] as f64,
-        ]
-    }
-
-    #[target_feature(enable = "f16c")]
-    #[inline]
-    pub(super) unsafe fn f64x8_to_f16x8_x86_f16c(v: &[f64; 8]) -> [u16; 8] {
-        // Let compiler vectorize this regular cast for now.
-        // TODO: investigate auto-detecting sse2/avx convert features
-        let v = [
-            v[0] as f32,
-            v[1] as f32,
-            v[2] as f32,
-            v[3] as f32,
-            v[4] as f32,
-            v[5] as f32,
-            v[6] as f32,
-            v[7] as f32,
-        ];
-        f32x8_to_f16x8_x86_f16c(&v)
-    }
-}
diff --git a/vendor/half/src/leading_zeros.rs b/vendor/half/src/leading_zeros.rs
deleted file mode 100644
index 6c73148..0000000
--- a/vendor/half/src/leading_zeros.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-// https://doc.rust-lang.org/std/primitive.u16.html#method.leading_zeros
-
-#[cfg(not(any(all(
-    target_arch = "spirv",
-    not(all(
-        target_feature = "IntegerFunctions2INTEL",
-        target_feature = "SPV_INTEL_shader_integer_functions2"
-    ))
-))))]
-pub(crate) const fn leading_zeros_u16(x: u16) -> u32 {
-    x.leading_zeros()
-}
-
-#[cfg(all(
-    target_arch = "spirv",
-    not(all(
-        target_feature = "IntegerFunctions2INTEL",
-        target_feature = "SPV_INTEL_shader_integer_functions2"
-    ))
-))]
-pub(crate) const fn leading_zeros_u16(x: u16) -> u32 {
-    leading_zeros_u16_fallback(x)
-}
-
-#[cfg(any(
-    test,
-    all(
-        target_arch = "spirv",
-        not(all(
-            target_feature = "IntegerFunctions2INTEL",
-            target_feature = "SPV_INTEL_shader_integer_functions2"
-        ))
-    )
-))]
-const fn leading_zeros_u16_fallback(mut x: u16) -> u32 {
-    use crunchy::unroll;
-    let mut c = 0;
-    let msb = 1 << 15;
-    unroll! { for i in 0 .. 16 {
-        if x & msb == 0 {
-            c += 1;
-        } else {
-            return c;
-        }
-        #[allow(unused_assignments)]
-        if i < 15 {
-            x <<= 1;
-        }
-    }}
-    c
-}
-
-#[cfg(test)]
-mod test {
-
-    #[test]
-    fn leading_zeros_u16_fallback() {
-        for x in [44, 97, 304, 1179, 23571] {
-            assert_eq!(super::leading_zeros_u16_fallback(x), x.leading_zeros());
-        }
-    }
-}
diff --git a/vendor/half/src/lib.rs b/vendor/half/src/lib.rs
deleted file mode 100644
index f821945..0000000
--- a/vendor/half/src/lib.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-//! A crate that provides support for half-precision 16-bit floating point types.
-//!
-//! This crate provides the [`f16`] type, which is an implementation of the IEEE 754-2008 standard
-//! [`binary16`] a.k.a `half` floating point type. This 16-bit floating point type is intended for
-//! efficient storage where the full range and precision of a larger floating point value is not
-//! required. This is especially useful for image storage formats.
-//!
-//! This crate also provides a [`bf16`] type, an alternative 16-bit floating point format. The
-//! [`bfloat16`] format is a truncated IEEE 754 standard `binary32` float that preserves the
-//! exponent to allow the same range as [`f32`] but with only 8 bits of precision (instead of 11
-//! bits for [`f16`]). See the [`bf16`] type for details.
-//!
-//! Because [`f16`] and [`bf16`] are primarily for efficient storage, floating point operations such
-//! as addition, multiplication, etc. are not implemented by hardware. While this crate does provide
-//! the appropriate trait implementations for basic operations, they each convert the value to
-//! [`f32`] before performing the operation and then back afterward. When performing complex
-//! arithmetic, manually convert to and from [`f32`] before and after to reduce repeated conversions
-//! for each operation.
-//!
-//! This crate also provides a [`slice`][mod@slice] module for zero-copy in-place conversions of
-//! [`u16`] slices to both [`f16`] and [`bf16`], as well as efficient vectorized conversions of
-//! larger buffers of floating point values to and from these half formats.
-//!
-//! The crate uses `#[no_std]` by default, so can be used in embedded environments without using the
-//! Rust [`std`] library. A `std` feature to enable support for the standard library is available,
-//! see the [Cargo Features](#cargo-features) section below.
-//!
-//! A [`prelude`] module is provided for easy importing of available utility traits.
-//!
-//! # Serialization
-//!
-//! When the `serde` feature is enabled, [`f16`] and [`bf16`] will be serialized as a newtype of
-//! [`u16`] by default. In binary formats this is ideal, as it will generally use just two bytes for
-//! storage. For string formats like JSON, however, this isn't as useful, and due to design
-//! limitations of serde, it's not possible for the default `Serialize` implementation to support
-//! different serialization for different formats.
-//!
-//! Instead, it's up to the containter type of the floats to control how it is serialized. This can
-//! easily be controlled when using the derive macros using `#[serde(serialize_with="")]`
-//! attributes. For both [`f16`] and [`bf16`] a `serialize_as_f32` and `serialize_as_string` are
-//! provided for use with this attribute.
-//!
-//! Deserialization of both float types supports deserializing from the default serialization,
-//! strings, and `f32`/`f64` values, so no additional work is required.
-//!
-//! # Cargo Features
-//!
-//! This crate supports a number of optional cargo features. None of these features are enabled by
-//! default, even `std`.
-//!
-//! - **`use-intrinsics`** -- Use [`core::arch`] hardware intrinsics for `f16` and `bf16` conversions
-//!   if available on the compiler target. This feature currently only works on nightly Rust
-//!   until the corresponding intrinsics are stabilized.
-//!
-//!   When this feature is enabled and the hardware supports it, the functions and traits in the
-//!   [`slice`][mod@slice] module will use vectorized SIMD intructions for increased efficiency.
-//!
-//!   By default, without this feature, conversions are done only in software, which will also be
-//!   the fallback if the target does not have hardware support. Note that without the `std`
-//!   feature enabled, no runtime CPU feature detection is used, so the hardware support is only
-//!   compiled if the compiler target supports the CPU feature.
-//!
-//! - **`alloc`** -- Enable use of the [`alloc`] crate when not using the `std` library.
-//!
-//!   Among other functions, this enables the [`vec`] module, which contains zero-copy
-//!   conversions for the [`Vec`] type. This allows fast conversion between raw `Vec<u16>` bits and
-//!   `Vec<f16>` or `Vec<bf16>` arrays, and vice versa.
-//!
-//! - **`std`** -- Enable features that depend on the Rust [`std`] library. This also enables the
-//!   `alloc` feature automatically.
-//!
-//!   Enabling the `std` feature also enables runtime CPU feature detection when the
-//!   `use-intrsincis` feature is also enabled. Without this feature detection, intrinsics are only
-//!   used when compiler target supports the target feature.
-//!
-//! - **`serde`** -- Adds support for the [`serde`] crate by implementing [`Serialize`] and
-//!   [`Deserialize`] traits for both [`f16`] and [`bf16`].
-//!
-//! - **`num-traits`** -- Adds support for the [`num-traits`] crate by implementing [`ToPrimitive`],
-//!   [`FromPrimitive`], [`AsPrimitive`], [`Num`], [`Float`], [`FloatCore`], and [`Bounded`] traits
-//!   for both [`f16`] and [`bf16`].
-//!
-//! - **`bytemuck`** -- Adds support for the [`bytemuck`] crate by implementing [`Zeroable`] and
-//!   [`Pod`] traits for both [`f16`] and [`bf16`].
-//!
-//! - **`zerocopy`** -- Adds support for the [`zerocopy`] crate by implementing [`AsBytes`] and
-//!   [`FromBytes`] traits for both [`f16`] and [`bf16`].
-//!
-//! [`alloc`]: https://doc.rust-lang.org/alloc/
-//! [`std`]: https://doc.rust-lang.org/std/
-//! [`binary16`]: https://en.wikipedia.org/wiki/Half-precision_floating-point_format
-//! [`bfloat16`]: https://en.wikipedia.org/wiki/Bfloat16_floating-point_format
-//! [`serde`]: https://crates.io/crates/serde
-//! [`bytemuck`]: https://crates.io/crates/bytemuck
-//! [`num-traits`]: https://crates.io/crates/num-traits
-//! [`zerocopy`]: https://crates.io/crates/zerocopy
-#![cfg_attr(
-    feature = "alloc",
-    doc = "
-[`vec`]: mod@vec"
-)]
-#![cfg_attr(
-    not(feature = "alloc"),
-    doc = "
-[`vec`]: #
-[`Vec`]: https://docs.rust-lang.org/stable/alloc/vec/struct.Vec.html"
-)]
-#![cfg_attr(
-    feature = "serde",
-    doc = "
-[`Serialize`]: serde::Serialize
-[`Deserialize`]: serde::Deserialize"
-)]
-#![cfg_attr(
-    not(feature = "serde"),
-    doc = "
-[`Serialize`]: https://docs.rs/serde/*/serde/trait.Serialize.html
-[`Deserialize`]: https://docs.rs/serde/*/serde/trait.Deserialize.html"
-)]
-#![cfg_attr(
-    feature = "num-traits",
-    doc = "
-[`ToPrimitive`]: ::num_traits::ToPrimitive
-[`FromPrimitive`]: ::num_traits::FromPrimitive
-[`AsPrimitive`]: ::num_traits::AsPrimitive
-[`Num`]: ::num_traits::Num
-[`Float`]: ::num_traits::Float
-[`FloatCore`]: ::num_traits::float::FloatCore
-[`Bounded`]: ::num_traits::Bounded"
-)]
-#![cfg_attr(
-    not(feature = "num-traits"),
-    doc = "
-[`ToPrimitive`]: https://docs.rs/num-traits/*/num_traits/cast/trait.ToPrimitive.html
-[`FromPrimitive`]: https://docs.rs/num-traits/*/num_traits/cast/trait.FromPrimitive.html
-[`AsPrimitive`]: https://docs.rs/num-traits/*/num_traits/cast/trait.AsPrimitive.html
-[`Num`]: https://docs.rs/num-traits/*/num_traits/trait.Num.html
-[`Float`]: https://docs.rs/num-traits/*/num_traits/float/trait.Float.html
-[`FloatCore`]: https://docs.rs/num-traits/*/num_traits/float/trait.FloatCore.html
-[`Bounded`]: https://docs.rs/num-traits/*/num_traits/bounds/trait.Bounded.html"
-)]
-#![cfg_attr(
-    feature = "bytemuck",
-    doc = "
-[`Zeroable`]: bytemuck::Zeroable
-[`Pod`]: bytemuck::Pod"
-)]
-#![cfg_attr(
-    not(feature = "bytemuck"),
-    doc = "
-[`Zeroable`]: https://docs.rs/bytemuck/*/bytemuck/trait.Zeroable.html
-[`Pod`]: https://docs.rs/bytemuck/*bytemuck/trait.Pod.html"
-)]
-#![cfg_attr(
-    feature = "zerocopy",
-    doc = "
-[`AsBytes`]: zerocopy::AsBytes
-[`FromBytes`]: zerocopy::FromBytes"
-)]
-#![cfg_attr(
-    not(feature = "zerocopy"),
-    doc = "
-[`AsBytes`]: https://docs.rs/zerocopy/*/zerocopy/trait.AsBytes.html
-[`FromBytes`]: https://docs.rs/zerocopy/*/zerocopy/trait.FromBytes.html"
-)]
-#![warn(
-    missing_docs,
-    missing_copy_implementations,
-    trivial_numeric_casts,
-    future_incompatible
-)]
-#![cfg_attr(not(target_arch = "spirv"), warn(missing_debug_implementations))]
-#![allow(clippy::verbose_bit_mask, clippy::cast_lossless)]
-#![cfg_attr(not(feature = "std"), no_std)]
-#![cfg_attr(
-    all(
-        feature = "use-intrinsics",
-        any(target_arch = "x86", target_arch = "x86_64")
-    ),
-    feature(stdsimd, f16c_target_feature)
-)]
-#![doc(html_root_url = "https://docs.rs/half/2.2.1")]
-#![doc(test(attr(deny(warnings), allow(unused))))]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-
-#[cfg(feature = "alloc")]
-extern crate alloc;
-
-mod bfloat;
-mod binary16;
-mod leading_zeros;
-#[cfg(feature = "num-traits")]
-mod num_traits;
-
-#[cfg(not(target_arch = "spirv"))]
-pub mod slice;
-#[cfg(feature = "alloc")]
-#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-pub mod vec;
-
-pub use bfloat::bf16;
-pub use binary16::f16;
-
-/// A collection of the most used items and traits in this crate for easy importing.
-///
-/// # Examples
-///
-/// ```rust
-/// use half::prelude::*;
-/// ```
-pub mod prelude {
-    #[doc(no_inline)]
-    pub use crate::{bf16, f16};
-
-    #[cfg(not(target_arch = "spirv"))]
-    #[doc(no_inline)]
-    pub use crate::slice::{HalfBitsSliceExt, HalfFloatSliceExt};
-
-    #[cfg(feature = "alloc")]
-    #[doc(no_inline)]
-    #[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
-    pub use crate::vec::{HalfBitsVecExt, HalfFloatVecExt};
-}
-
-// Keep this module private to crate
-mod private {
-    use crate::{bf16, f16};
-
-    pub trait SealedHalf {}
-
-    impl SealedHalf for f16 {}
-    impl SealedHalf for bf16 {}
-}
diff --git a/vendor/half/src/num_traits.rs b/vendor/half/src/num_traits.rs
deleted file mode 100644
index 4318699..0000000
--- a/vendor/half/src/num_traits.rs
+++ /dev/null
@@ -1,1483 +0,0 @@
-use crate::{bf16, f16};
-use core::cmp::Ordering;
-use core::{num::FpCategory, ops::Div};
-use num_traits::{
-    AsPrimitive, Bounded, FloatConst, FromPrimitive, Num, NumCast, One, ToPrimitive, Zero,
-};
-
-impl ToPrimitive for f16 {
-    #[inline]
-    fn to_i64(&self) -> Option<i64> {
-        Self::to_f32(*self).to_i64()
-    }
-    #[inline]
-    fn to_u64(&self) -> Option<u64> {
-        Self::to_f32(*self).to_u64()
-    }
-    #[inline]
-    fn to_i8(&self) -> Option<i8> {
-        Self::to_f32(*self).to_i8()
-    }
-    #[inline]
-    fn to_u8(&self) -> Option<u8> {
-        Self::to_f32(*self).to_u8()
-    }
-    #[inline]
-    fn to_i16(&self) -> Option<i16> {
-        Self::to_f32(*self).to_i16()
-    }
-    #[inline]
-    fn to_u16(&self) -> Option<u16> {
-        Self::to_f32(*self).to_u16()
-    }
-    #[inline]
-    fn to_i32(&self) -> Option<i32> {
-        Self::to_f32(*self).to_i32()
-    }
-    #[inline]
-    fn to_u32(&self) -> Option<u32> {
-        Self::to_f32(*self).to_u32()
-    }
-    #[inline]
-    fn to_f32(&self) -> Option<f32> {
-        Some(Self::to_f32(*self))
-    }
-    #[inline]
-    fn to_f64(&self) -> Option<f64> {
-        Some(Self::to_f64(*self))
-    }
-}
-
-impl FromPrimitive for f16 {
-    #[inline]
-    fn from_i64(n: i64) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u64(n: u64) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_i8(n: i8) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u8(n: u8) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_i16(n: i16) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u16(n: u16) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_i32(n: i32) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u32(n: u32) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_f32(n: f32) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_f64(n: f64) -> Option<Self> {
-        n.to_f64().map(Self::from_f64)
-    }
-}
-
-impl Num for f16 {
-    type FromStrRadixErr = <f32 as Num>::FromStrRadixErr;
-
-    #[inline]
-    fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
-        Ok(Self::from_f32(f32::from_str_radix(str, radix)?))
-    }
-}
-
-impl One for f16 {
-    #[inline]
-    fn one() -> Self {
-        Self::ONE
-    }
-}
-
-impl Zero for f16 {
-    #[inline]
-    fn zero() -> Self {
-        Self::ZERO
-    }
-
-    #[inline]
-    fn is_zero(&self) -> bool {
-        *self == Self::ZERO
-    }
-}
-
-impl NumCast for f16 {
-    #[inline]
-    fn from<T: ToPrimitive>(n: T) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-}
-
-impl num_traits::float::FloatCore for f16 {
-    #[inline]
-    fn infinity() -> Self {
-        Self::INFINITY
-    }
-
-    #[inline]
-    fn neg_infinity() -> Self {
-        Self::NEG_INFINITY
-    }
-
-    #[inline]
-    fn nan() -> Self {
-        Self::NAN
-    }
-
-    #[inline]
-    fn neg_zero() -> Self {
-        Self::NEG_ZERO
-    }
-
-    #[inline]
-    fn min_value() -> Self {
-        Self::MIN
-    }
-
-    #[inline]
-    fn min_positive_value() -> Self {
-        Self::MIN_POSITIVE
-    }
-
-    #[inline]
-    fn epsilon() -> Self {
-        Self::EPSILON
-    }
-
-    #[inline]
-    fn max_value() -> Self {
-        Self::MAX
-    }
-
-    #[inline]
-    fn is_nan(self) -> bool {
-        self.is_nan()
-    }
-
-    #[inline]
-    fn is_infinite(self) -> bool {
-        self.is_infinite()
-    }
-
-    #[inline]
-    fn is_finite(self) -> bool {
-        self.is_finite()
-    }
-
-    #[inline]
-    fn is_normal(self) -> bool {
-        self.is_normal()
-    }
-
-    #[inline]
-    fn classify(self) -> FpCategory {
-        self.classify()
-    }
-
-    #[inline]
-    fn floor(self) -> Self {
-        Self::from_f32(self.to_f32().floor())
-    }
-
-    #[inline]
-    fn ceil(self) -> Self {
-        Self::from_f32(self.to_f32().ceil())
-    }
-
-    #[inline]
-    fn round(self) -> Self {
-        Self::from_f32(self.to_f32().round())
-    }
-
-    #[inline]
-    fn trunc(self) -> Self {
-        Self::from_f32(self.to_f32().trunc())
-    }
-
-    #[inline]
-    fn fract(self) -> Self {
-        Self::from_f32(self.to_f32().fract())
-    }
-
-    #[inline]
-    fn abs(self) -> Self {
-        Self::from_bits(self.to_bits() & 0x7FFF)
-    }
-
-    #[inline]
-    fn signum(self) -> Self {
-        self.signum()
-    }
-
-    #[inline]
-    fn is_sign_positive(self) -> bool {
-        self.is_sign_positive()
-    }
-
-    #[inline]
-    fn is_sign_negative(self) -> bool {
-        self.is_sign_negative()
-    }
-
-    fn min(self, other: Self) -> Self {
-        match self.partial_cmp(&other) {
-            None => {
-                if self.is_nan() {
-                    other
-                } else {
-                    self
-                }
-            }
-            Some(Ordering::Greater) | Some(Ordering::Equal) => other,
-            Some(Ordering::Less) => self,
-        }
-    }
-
-    fn max(self, other: Self) -> Self {
-        match self.partial_cmp(&other) {
-            None => {
-                if self.is_nan() {
-                    other
-                } else {
-                    self
-                }
-            }
-            Some(Ordering::Greater) | Some(Ordering::Equal) => self,
-            Some(Ordering::Less) => other,
-        }
-    }
-
-    #[inline]
-    fn recip(self) -> Self {
-        Self::from_f32(self.to_f32().recip())
-    }
-
-    #[inline]
-    fn powi(self, exp: i32) -> Self {
-        Self::from_f32(self.to_f32().powi(exp))
-    }
-
-    #[inline]
-    fn to_degrees(self) -> Self {
-        Self::from_f32(self.to_f32().to_degrees())
-    }
-
-    #[inline]
-    fn to_radians(self) -> Self {
-        Self::from_f32(self.to_f32().to_radians())
-    }
-
-    #[inline]
-    fn integer_decode(self) -> (u64, i16, i8) {
-        num_traits::float::FloatCore::integer_decode(self.to_f32())
-    }
-}
-
-impl num_traits::float::Float for f16 {
-    #[inline]
-    fn nan() -> Self {
-        Self::NAN
-    }
-
-    #[inline]
-    fn infinity() -> Self {
-        Self::INFINITY
-    }
-
-    #[inline]
-    fn neg_infinity() -> Self {
-        Self::NEG_INFINITY
-    }
-
-    #[inline]
-    fn neg_zero() -> Self {
-        Self::NEG_ZERO
-    }
-
-    #[inline]
-    fn min_value() -> Self {
-        Self::MIN
-    }
-
-    #[inline]
-    fn min_positive_value() -> Self {
-        Self::MIN_POSITIVE
-    }
-
-    #[inline]
-    fn epsilon() -> Self {
-        Self::EPSILON
-    }
-
-    #[inline]
-    fn max_value() -> Self {
-        Self::MAX
-    }
-
-    #[inline]
-    fn is_nan(self) -> bool {
-        self.is_nan()
-    }
-
-    #[inline]
-    fn is_infinite(self) -> bool {
-        self.is_infinite()
-    }
-
-    #[inline]
-    fn is_finite(self) -> bool {
-        self.is_finite()
-    }
-
-    #[inline]
-    fn is_normal(self) -> bool {
-        self.is_normal()
-    }
-
-    #[inline]
-    fn classify(self) -> FpCategory {
-        self.classify()
-    }
-
-    #[inline]
-    fn floor(self) -> Self {
-        Self::from_f32(self.to_f32().floor())
-    }
-
-    #[inline]
-    fn ceil(self) -> Self {
-        Self::from_f32(self.to_f32().ceil())
-    }
-
-    #[inline]
-    fn round(self) -> Self {
-        Self::from_f32(self.to_f32().round())
-    }
-
-    #[inline]
-    fn trunc(self) -> Self {
-        Self::from_f32(self.to_f32().trunc())
-    }
-
-    #[inline]
-    fn fract(self) -> Self {
-        Self::from_f32(self.to_f32().fract())
-    }
-
-    #[inline]
-    fn abs(self) -> Self {
-        Self::from_f32(self.to_f32().abs())
-    }
-
-    #[inline]
-    fn signum(self) -> Self {
-        Self::from_f32(self.to_f32().signum())
-    }
-
-    #[inline]
-    fn is_sign_positive(self) -> bool {
-        self.is_sign_positive()
-    }
-
-    #[inline]
-    fn is_sign_negative(self) -> bool {
-        self.is_sign_negative()
-    }
-
-    #[inline]
-    fn mul_add(self, a: Self, b: Self) -> Self {
-        Self::from_f32(self.to_f32().mul_add(a.to_f32(), b.to_f32()))
-    }
-
-    #[inline]
-    fn recip(self) -> Self {
-        Self::from_f32(self.to_f32().recip())
-    }
-
-    #[inline]
-    fn powi(self, n: i32) -> Self {
-        Self::from_f32(self.to_f32().powi(n))
-    }
-
-    #[inline]
-    fn powf(self, n: Self) -> Self {
-        Self::from_f32(self.to_f32().powf(n.to_f32()))
-    }
-
-    #[inline]
-    fn sqrt(self) -> Self {
-        Self::from_f32(self.to_f32().sqrt())
-    }
-
-    #[inline]
-    fn exp(self) -> Self {
-        Self::from_f32(self.to_f32().exp())
-    }
-
-    #[inline]
-    fn exp2(self) -> Self {
-        Self::from_f32(self.to_f32().exp2())
-    }
-
-    #[inline]
-    fn ln(self) -> Self {
-        Self::from_f32(self.to_f32().ln())
-    }
-
-    #[inline]
-    fn log(self, base: Self) -> Self {
-        Self::from_f32(self.to_f32().log(base.to_f32()))
-    }
-
-    #[inline]
-    fn log2(self) -> Self {
-        Self::from_f32(self.to_f32().log2())
-    }
-
-    #[inline]
-    fn log10(self) -> Self {
-        Self::from_f32(self.to_f32().log10())
-    }
-
-    #[inline]
-    fn to_degrees(self) -> Self {
-        Self::from_f32(self.to_f32().to_degrees())
-    }
-
-    #[inline]
-    fn to_radians(self) -> Self {
-        Self::from_f32(self.to_f32().to_radians())
-    }
-
-    #[inline]
-    fn max(self, other: Self) -> Self {
-        self.max(other)
-    }
-
-    #[inline]
-    fn min(self, other: Self) -> Self {
-        self.min(other)
-    }
-
-    #[inline]
-    fn abs_sub(self, other: Self) -> Self {
-        Self::from_f32((self.to_f32() - other.to_f32()).max(0.0))
-    }
-
-    #[inline]
-    fn cbrt(self) -> Self {
-        Self::from_f32(self.to_f32().cbrt())
-    }
-
-    #[inline]
-    fn hypot(self, other: Self) -> Self {
-        Self::from_f32(self.to_f32().hypot(other.to_f32()))
-    }
-
-    #[inline]
-    fn sin(self) -> Self {
-        Self::from_f32(self.to_f32().sin())
-    }
-
-    #[inline]
-    fn cos(self) -> Self {
-        Self::from_f32(self.to_f32().cos())
-    }
-
-    #[inline]
-    fn tan(self) -> Self {
-        Self::from_f32(self.to_f32().tan())
-    }
-
-    #[inline]
-    fn asin(self) -> Self {
-        Self::from_f32(self.to_f32().asin())
-    }
-
-    #[inline]
-    fn acos(self) -> Self {
-        Self::from_f32(self.to_f32().acos())
-    }
-
-    #[inline]
-    fn atan(self) -> Self {
-        Self::from_f32(self.to_f32().atan())
-    }
-
-    #[inline]
-    fn atan2(self, other: Self) -> Self {
-        Self::from_f32(self.to_f32().atan2(other.to_f32()))
-    }
-
-    #[inline]
-    fn sin_cos(self) -> (Self, Self) {
-        let (sin, cos) = self.to_f32().sin_cos();
-        (Self::from_f32(sin), Self::from_f32(cos))
-    }
-
-    #[inline]
-    fn exp_m1(self) -> Self {
-        Self::from_f32(self.to_f32().exp_m1())
-    }
-
-    #[inline]
-    fn ln_1p(self) -> Self {
-        Self::from_f32(self.to_f32().ln_1p())
-    }
-
-    #[inline]
-    fn sinh(self) -> Self {
-        Self::from_f32(self.to_f32().sinh())
-    }
-
-    #[inline]
-    fn cosh(self) -> Self {
-        Self::from_f32(self.to_f32().cosh())
-    }
-
-    #[inline]
-    fn tanh(self) -> Self {
-        Self::from_f32(self.to_f32().tanh())
-    }
-
-    #[inline]
-    fn asinh(self) -> Self {
-        Self::from_f32(self.to_f32().asinh())
-    }
-
-    #[inline]
-    fn acosh(self) -> Self {
-        Self::from_f32(self.to_f32().acosh())
-    }
-
-    #[inline]
-    fn atanh(self) -> Self {
-        Self::from_f32(self.to_f32().atanh())
-    }
-
-    #[inline]
-    fn integer_decode(self) -> (u64, i16, i8) {
-        num_traits::float::Float::integer_decode(self.to_f32())
-    }
-}
-
-impl FloatConst for f16 {
-    #[inline]
-    fn E() -> Self {
-        Self::E
-    }
-
-    #[inline]
-    fn FRAC_1_PI() -> Self {
-        Self::FRAC_1_PI
-    }
-
-    #[inline]
-    fn FRAC_1_SQRT_2() -> Self {
-        Self::FRAC_1_SQRT_2
-    }
-
-    #[inline]
-    fn FRAC_2_PI() -> Self {
-        Self::FRAC_2_PI
-    }
-
-    #[inline]
-    fn FRAC_2_SQRT_PI() -> Self {
-        Self::FRAC_2_SQRT_PI
-    }
-
-    #[inline]
-    fn FRAC_PI_2() -> Self {
-        Self::FRAC_PI_2
-    }
-
-    #[inline]
-    fn FRAC_PI_3() -> Self {
-        Self::FRAC_PI_3
-    }
-
-    #[inline]
-    fn FRAC_PI_4() -> Self {
-        Self::FRAC_PI_4
-    }
-
-    #[inline]
-    fn FRAC_PI_6() -> Self {
-        Self::FRAC_PI_6
-    }
-
-    #[inline]
-    fn FRAC_PI_8() -> Self {
-        Self::FRAC_PI_8
-    }
-
-    #[inline]
-    fn LN_10() -> Self {
-        Self::LN_10
-    }
-
-    #[inline]
-    fn LN_2() -> Self {
-        Self::LN_2
-    }
-
-    #[inline]
-    fn LOG10_E() -> Self {
-        Self::LOG10_E
-    }
-
-    #[inline]
-    fn LOG2_E() -> Self {
-        Self::LOG2_E
-    }
-
-    #[inline]
-    fn PI() -> Self {
-        Self::PI
-    }
-
-    fn SQRT_2() -> Self {
-        Self::SQRT_2
-    }
-
-    #[inline]
-    fn LOG10_2() -> Self
-    where
-        Self: Sized + Div<Self, Output = Self>,
-    {
-        Self::LOG10_2
-    }
-
-    #[inline]
-    fn LOG2_10() -> Self
-    where
-        Self: Sized + Div<Self, Output = Self>,
-    {
-        Self::LOG2_10
-    }
-}
-
-impl Bounded for f16 {
-    #[inline]
-    fn min_value() -> Self {
-        f16::MIN
-    }
-
-    #[inline]
-    fn max_value() -> Self {
-        f16::MAX
-    }
-}
-
-macro_rules! impl_as_primitive_to_f16 {
-    ($ty:ty, $meth:ident) => {
-        impl AsPrimitive<$ty> for f16 {
-            #[inline]
-            fn as_(self) -> $ty {
-                self.$meth().as_()
-            }
-        }
-    };
-}
-
-impl AsPrimitive<f16> for f16 {
-    #[inline]
-    fn as_(self) -> f16 {
-        self
-    }
-}
-
-impl_as_primitive_to_f16!(i64, to_f32);
-impl_as_primitive_to_f16!(u64, to_f32);
-impl_as_primitive_to_f16!(i8, to_f32);
-impl_as_primitive_to_f16!(u8, to_f32);
-impl_as_primitive_to_f16!(i16, to_f32);
-impl_as_primitive_to_f16!(u16, to_f32);
-impl_as_primitive_to_f16!(i32, to_f32);
-impl_as_primitive_to_f16!(u32, to_f32);
-impl_as_primitive_to_f16!(isize, to_f32);
-impl_as_primitive_to_f16!(usize, to_f32);
-impl_as_primitive_to_f16!(f32, to_f32);
-impl_as_primitive_to_f16!(f64, to_f64);
-
-macro_rules! impl_as_primitive_f16_from {
-    ($ty:ty, $meth:ident) => {
-        impl AsPrimitive<f16> for $ty {
-            #[inline]
-            fn as_(self) -> f16 {
-                f16::$meth(self.as_())
-            }
-        }
-    };
-}
-
-impl_as_primitive_f16_from!(i64, from_f32);
-impl_as_primitive_f16_from!(u64, from_f32);
-impl_as_primitive_f16_from!(i8, from_f32);
-impl_as_primitive_f16_from!(u8, from_f32);
-impl_as_primitive_f16_from!(i16, from_f32);
-impl_as_primitive_f16_from!(u16, from_f32);
-impl_as_primitive_f16_from!(i32, from_f32);
-impl_as_primitive_f16_from!(u32, from_f32);
-impl_as_primitive_f16_from!(isize, from_f32);
-impl_as_primitive_f16_from!(usize, from_f32);
-impl_as_primitive_f16_from!(f32, from_f32);
-impl_as_primitive_f16_from!(f64, from_f64);
-
-impl ToPrimitive for bf16 {
-    #[inline]
-    fn to_i64(&self) -> Option<i64> {
-        Self::to_f32(*self).to_i64()
-    }
-    #[inline]
-    fn to_u64(&self) -> Option<u64> {
-        Self::to_f32(*self).to_u64()
-    }
-    #[inline]
-    fn to_i8(&self) -> Option<i8> {
-        Self::to_f32(*self).to_i8()
-    }
-    #[inline]
-    fn to_u8(&self) -> Option<u8> {
-        Self::to_f32(*self).to_u8()
-    }
-    #[inline]
-    fn to_i16(&self) -> Option<i16> {
-        Self::to_f32(*self).to_i16()
-    }
-    #[inline]
-    fn to_u16(&self) -> Option<u16> {
-        Self::to_f32(*self).to_u16()
-    }
-    #[inline]
-    fn to_i32(&self) -> Option<i32> {
-        Self::to_f32(*self).to_i32()
-    }
-    #[inline]
-    fn to_u32(&self) -> Option<u32> {
-        Self::to_f32(*self).to_u32()
-    }
-    #[inline]
-    fn to_f32(&self) -> Option<f32> {
-        Some(Self::to_f32(*self))
-    }
-    #[inline]
-    fn to_f64(&self) -> Option<f64> {
-        Some(Self::to_f64(*self))
-    }
-}
-
-impl FromPrimitive for bf16 {
-    #[inline]
-    fn from_i64(n: i64) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u64(n: u64) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_i8(n: i8) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u8(n: u8) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_i16(n: i16) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u16(n: u16) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_i32(n: i32) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_u32(n: u32) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_f32(n: f32) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-    #[inline]
-    fn from_f64(n: f64) -> Option<Self> {
-        n.to_f64().map(Self::from_f64)
-    }
-}
-
-impl Num for bf16 {
-    type FromStrRadixErr = <f32 as Num>::FromStrRadixErr;
-
-    #[inline]
-    fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
-        Ok(Self::from_f32(f32::from_str_radix(str, radix)?))
-    }
-}
-
-impl One for bf16 {
-    #[inline]
-    fn one() -> Self {
-        Self::ONE
-    }
-}
-
-impl Zero for bf16 {
-    #[inline]
-    fn zero() -> Self {
-        Self::ZERO
-    }
-
-    #[inline]
-    fn is_zero(&self) -> bool {
-        *self == Self::ZERO
-    }
-}
-
-impl NumCast for bf16 {
-    #[inline]
-    fn from<T: ToPrimitive>(n: T) -> Option<Self> {
-        n.to_f32().map(Self::from_f32)
-    }
-}
-
-impl num_traits::float::FloatCore for bf16 {
-    #[inline]
-    fn infinity() -> Self {
-        Self::INFINITY
-    }
-
-    #[inline]
-    fn neg_infinity() -> Self {
-        Self::NEG_INFINITY
-    }
-
-    #[inline]
-    fn nan() -> Self {
-        Self::NAN
-    }
-
-    #[inline]
-    fn neg_zero() -> Self {
-        Self::NEG_ZERO
-    }
-
-    #[inline]
-    fn min_value() -> Self {
-        Self::MIN
-    }
-
-    #[inline]
-    fn min_positive_value() -> Self {
-        Self::MIN_POSITIVE
-    }
-
-    #[inline]
-    fn epsilon() -> Self {
-        Self::EPSILON
-    }
-
-    #[inline]
-    fn max_value() -> Self {
-        Self::MAX
-    }
-
-    #[inline]
-    fn is_nan(self) -> bool {
-        self.is_nan()
-    }
-
-    #[inline]
-    fn is_infinite(self) -> bool {
-        self.is_infinite()
-    }
-
-    #[inline]
-    fn is_finite(self) -> bool {
-        self.is_finite()
-    }
-
-    #[inline]
-    fn is_normal(self) -> bool {
-        self.is_normal()
-    }
-
-    #[inline]
-    fn classify(self) -> FpCategory {
-        self.classify()
-    }
-
-    #[inline]
-    fn floor(self) -> Self {
-        Self::from_f32(self.to_f32().floor())
-    }
-
-    #[inline]
-    fn ceil(self) -> Self {
-        Self::from_f32(self.to_f32().ceil())
-    }
-
-    #[inline]
-    fn round(self) -> Self {
-        Self::from_f32(self.to_f32().round())
-    }
-
-    #[inline]
-    fn trunc(self) -> Self {
-        Self::from_f32(self.to_f32().trunc())
-    }
-
-    #[inline]
-    fn fract(self) -> Self {
-        Self::from_f32(self.to_f32().fract())
-    }
-
-    #[inline]
-    fn abs(self) -> Self {
-        Self::from_bits(self.to_bits() & 0x7FFF)
-    }
-
-    #[inline]
-    fn signum(self) -> Self {
-        self.signum()
-    }
-
-    #[inline]
-    fn is_sign_positive(self) -> bool {
-        self.is_sign_positive()
-    }
-
-    #[inline]
-    fn is_sign_negative(self) -> bool {
-        self.is_sign_negative()
-    }
-
-    fn min(self, other: Self) -> Self {
-        match self.partial_cmp(&other) {
-            None => {
-                if self.is_nan() {
-                    other
-                } else {
-                    self
-                }
-            }
-            Some(Ordering::Greater) | Some(Ordering::Equal) => other,
-            Some(Ordering::Less) => self,
-        }
-    }
-
-    fn max(self, other: Self) -> Self {
-        match self.partial_cmp(&other) {
-            None => {
-                if self.is_nan() {
-                    other
-                } else {
-                    self
-                }
-            }
-            Some(Ordering::Greater) | Some(Ordering::Equal) => self,
-            Some(Ordering::Less) => other,
-        }
-    }
-
-    #[inline]
-    fn recip(self) -> Self {
-        Self::from_f32(self.to_f32().recip())
-    }
-
-    #[inline]
-    fn powi(self, exp: i32) -> Self {
-        Self::from_f32(self.to_f32().powi(exp))
-    }
-
-    #[inline]
-    fn to_degrees(self) -> Self {
-        Self::from_f32(self.to_f32().to_degrees())
-    }
-
-    #[inline]
-    fn to_radians(self) -> Self {
-        Self::from_f32(self.to_f32().to_radians())
-    }
-
-    #[inline]
-    fn integer_decode(self) -> (u64, i16, i8) {
-        num_traits::float::FloatCore::integer_decode(self.to_f32())
-    }
-}
-
-impl num_traits::float::Float for bf16 {
-    #[inline]
-    fn nan() -> Self {
-        Self::NAN
-    }
-
-    #[inline]
-    fn infinity() -> Self {
-        Self::INFINITY
-    }
-
-    #[inline]
-    fn neg_infinity() -> Self {
-        Self::NEG_INFINITY
-    }
-
-    #[inline]
-    fn neg_zero() -> Self {
-        Self::NEG_ZERO
-    }
-
-    #[inline]
-    fn min_value() -> Self {
-        Self::MIN
-    }
-
-    #[inline]
-    fn min_positive_value() -> Self {
-        Self::MIN_POSITIVE
-    }
-
-    #[inline]
-    fn epsilon() -> Self {
-        Self::EPSILON
-    }
-
-    #[inline]
-    fn max_value() -> Self {
-        Self::MAX
-    }
-
-    #[inline]
-    fn is_nan(self) -> bool {
-        self.is_nan()
-    }
-
-    #[inline]
-    fn is_infinite(self) -> bool {
-        self.is_infinite()
-    }
-
-    #[inline]
-    fn is_finite(self) -> bool {
-        self.is_finite()
-    }
-
-    #[inline]
-    fn is_normal(self) -> bool {
-        self.is_normal()
-    }
-
-    #[inline]
-    fn classify(self) -> FpCategory {
-        self.classify()
-    }
-
-    #[inline]
-    fn floor(self) -> Self {
-        Self::from_f32(self.to_f32().floor())
-    }
-
-    #[inline]
-    fn ceil(self) -> Self {
-        Self::from_f32(self.to_f32().ceil())
-    }
-
-    #[inline]
-    fn round(self) -> Self {
-        Self::from_f32(self.to_f32().round())
-    }
-
-    #[inline]
-    fn trunc(self) -> Self {
-        Self::from_f32(self.to_f32().trunc())
-    }
-
-    #[inline]
-    fn fract(self) -> Self {
-        Self::from_f32(self.to_f32().fract())
-    }
-
-    #[inline]
-    fn abs(self) -> Self {
-        Self::from_f32(self.to_f32().abs())
-    }
-
-    #[inline]
-    fn signum(self) -> Self {
-        Self::from_f32(self.to_f32().signum())
-    }
-
-    #[inline]
-    fn is_sign_positive(self) -> bool {
-        self.is_sign_positive()
-    }
-
-    #[inline]
-    fn is_sign_negative(self) -> bool {
-        self.is_sign_negative()
-    }
-
-    #[inline]
-    fn mul_add(self, a: Self, b: Self) -> Self {
-        Self::from_f32(self.to_f32().mul_add(a.to_f32(), b.to_f32()))
-    }
-
-    #[inline]
-    fn recip(self) -> Self {
-        Self::from_f32(self.to_f32().recip())
-    }
-
-    #[inline]
-    fn powi(self, n: i32) -> Self {
-        Self::from_f32(self.to_f32().powi(n))
-    }
-
-    #[inline]
-    fn powf(self, n: Self) -> Self {
-        Self::from_f32(self.to_f32().powf(n.to_f32()))
-    }
-
-    #[inline]
-    fn sqrt(self) -> Self {
-        Self::from_f32(self.to_f32().sqrt())
-    }
-
-    #[inline]
-    fn exp(self) -> Self {
-        Self::from_f32(self.to_f32().exp())
-    }
-
-    #[inline]
-    fn exp2(self) -> Self {
-        Self::from_f32(self.to_f32().exp2())
-    }
-
-    #[inline]
-    fn ln(self) -> Self {
-        Self::from_f32(self.to_f32().ln())
-    }
-
-    #[inline]
-    fn log(self, base: Self) -> Self {
-        Self::from_f32(self.to_f32().log(base.to_f32()))
-    }
-
-    #[inline]
-    fn log2(self) -> Self {
-        Self::from_f32(self.to_f32().log2())
-    }
-
-    #[inline]
-    fn log10(self) -> Self {
-        Self::from_f32(self.to_f32().log10())
-    }
-
-    #[inline]
-    fn to_degrees(self) -> Self {
-        Self::from_f32(self.to_f32().to_degrees())
-    }
-
-    #[inline]
-    fn to_radians(self) -> Self {
-        Self::from_f32(self.to_f32().to_radians())
-    }
-
-    #[inline]
-    fn max(self, other: Self) -> Self {
-        self.max(other)
-    }
-
-    #[inline]
-    fn min(self, other: Self) -> Self {
-        self.min(other)
-    }
-
-    #[inline]
-    fn abs_sub(self, other: Self) -> Self {
-        Self::from_f32((self.to_f32() - other.to_f32()).max(0.0))
-    }
-
-    #[inline]
-    fn cbrt(self) -> Self {
-        Self::from_f32(self.to_f32().cbrt())
-    }
-
-    #[inline]
-    fn hypot(self, other: Self) -> Self {
-        Self::from_f32(self.to_f32().hypot(other.to_f32()))
-    }
-
-    #[inline]
-    fn sin(self) -> Self {
-        Self::from_f32(self.to_f32().sin())
-    }
-
-    #[inline]
-    fn cos(self) -> Self {
-        Self::from_f32(self.to_f32().cos())
-    }
-
-    #[inline]
-    fn tan(self) -> Self {
-        Self::from_f32(self.to_f32().tan())
-    }
-
-    #[inline]
-    fn asin(self) -> Self {
-        Self::from_f32(self.to_f32().asin())
-    }
-
-    #[inline]
-    fn acos(self) -> Self {
-        Self::from_f32(self.to_f32().acos())
-    }
-
-    #[inline]
-    fn atan(self) -> Self {
-        Self::from_f32(self.to_f32().atan())
-    }
-
-    #[inline]
-    fn atan2(self, other: Self) -> Self {
-        Self::from_f32(self.to_f32().atan2(other.to_f32()))
-    }
-
-    #[inline]
-    fn sin_cos(self) -> (Self, Self) {
-        let (sin, cos) = self.to_f32().sin_cos();
-        (Self::from_f32(sin), Self::from_f32(cos))
-    }
-
-    #[inline]
-    fn exp_m1(self) -> Self {
-        Self::from_f32(self.to_f32().exp_m1())
-    }
-
-    #[inline]
-    fn ln_1p(self) -> Self {
-        Self::from_f32(self.to_f32().ln_1p())
-    }
-
-    #[inline]
-    fn sinh(self) -> Self {
-        Self::from_f32(self.to_f32().sinh())
-    }
-
-    #[inline]
-    fn cosh(self) -> Self {
-        Self::from_f32(self.to_f32().cosh())
-    }
-
-    #[inline]
-    fn tanh(self) -> Self {
-        Self::from_f32(self.to_f32().tanh())
-    }
-
-    #[inline]
-    fn asinh(self) -> Self {
-        Self::from_f32(self.to_f32().asinh())
-    }
-
-    #[inline]
-    fn acosh(self) -> Self {
-        Self::from_f32(self.to_f32().acosh())
-    }
-
-    #[inline]
-    fn atanh(self) -> Self {
-        Self::from_f32(self.to_f32().atanh())
-    }
-
-    #[inline]
-    fn integer_decode(self) -> (u64, i16, i8) {
-        num_traits::float::Float::integer_decode(self.to_f32())
-    }
-}
-
-impl FloatConst for bf16 {
-    #[inline]
-    fn E() -> Self {
-        Self::E
-    }
-
-    #[inline]
-    fn FRAC_1_PI() -> Self {
-        Self::FRAC_1_PI
-    }
-
-    #[inline]
-    fn FRAC_1_SQRT_2() -> Self {
-        Self::FRAC_1_SQRT_2
-    }
-
-    #[inline]
-    fn FRAC_2_PI() -> Self {
-        Self::FRAC_2_PI
-    }
-
-    #[inline]
-    fn FRAC_2_SQRT_PI() -> Self {
-        Self::FRAC_2_SQRT_PI
-    }
-
-    #[inline]
-    fn FRAC_PI_2() -> Self {
-        Self::FRAC_PI_2
-    }
-
-    #[inline]
-    fn FRAC_PI_3() -> Self {
-        Self::FRAC_PI_3
-    }
-
-    #[inline]
-    fn FRAC_PI_4() -> Self {
-        Self::FRAC_PI_4
-    }
-
-    #[inline]
-    fn FRAC_PI_6() -> Self {
-        Self::FRAC_PI_6
-    }
-
-    #[inline]
-    fn FRAC_PI_8() -> Self {
-        Self::FRAC_PI_8
-    }
-
-    #[inline]
-    fn LN_10() -> Self {
-        Self::LN_10
-    }
-
-    #[inline]
-    fn LN_2() -> Self {
-        Self::LN_2
-    }
-
-    #[inline]
-    fn LOG10_E() -> Self {
-        Self::LOG10_E
-    }
-
-    #[inline]
-    fn LOG2_E() -> Self {
-        Self::LOG2_E
-    }
-
-    #[inline]
-    fn PI() -> Self {
-        Self::PI
-    }
-
-    #[inline]
-    fn SQRT_2() -> Self {
-        Self::SQRT_2
-    }
-
-    #[inline]
-    fn LOG10_2() -> Self
-    where
-        Self: Sized + Div<Self, Output = Self>,
-    {
-        Self::LOG10_2
-    }
-
-    #[inline]
-    fn LOG2_10() -> Self
-    where
-        Self: Sized + Div<Self, Output = Self>,
-    {
-        Self::LOG2_10
-    }
-}
-
-impl Bounded for bf16 {
-    #[inline]
-    fn min_value() -> Self {
-        bf16::MIN
-    }
-
-    #[inline]
-    fn max_value() -> Self {
-        bf16::MAX
-    }
-}
-
-impl AsPrimitive<bf16> for bf16 {
-    #[inline]
-    fn as_(self) -> bf16 {
-        self
-    }
-}
-
-macro_rules! impl_as_primitive_to_bf16 {
-    ($ty:ty, $meth:ident) => {
-        impl AsPrimitive<$ty> for bf16 {
-            #[inline]
-            fn as_(self) -> $ty {
-                self.$meth().as_()
-            }
-        }
-    };
-}
-
-impl_as_primitive_to_bf16!(i64, to_f32);
-impl_as_primitive_to_bf16!(u64, to_f32);
-impl_as_primitive_to_bf16!(i8, to_f32);
-impl_as_primitive_to_bf16!(u8, to_f32);
-impl_as_primitive_to_bf16!(i16, to_f32);
-impl_as_primitive_to_bf16!(u16, to_f32);
-impl_as_primitive_to_bf16!(i32, to_f32);
-impl_as_primitive_to_bf16!(u32, to_f32);
-impl_as_primitive_to_bf16!(isize, to_f32);
-impl_as_primitive_to_bf16!(usize, to_f32);
-impl_as_primitive_to_bf16!(f32, to_f32);
-impl_as_primitive_to_bf16!(f64, to_f64);
-
-macro_rules! impl_as_primitive_bf16_from {
-    ($ty:ty, $meth:ident) => {
-        impl AsPrimitive<bf16> for $ty {
-            #[inline]
-            fn as_(self) -> bf16 {
-                bf16::$meth(self.as_())
-            }
-        }
-    };
-}
-
-impl_as_primitive_bf16_from!(i64, from_f32);
-impl_as_primitive_bf16_from!(u64, from_f32);
-impl_as_primitive_bf16_from!(i8, from_f32);
-impl_as_primitive_bf16_from!(u8, from_f32);
-impl_as_primitive_bf16_from!(i16, from_f32);
-impl_as_primitive_bf16_from!(u16, from_f32);
-impl_as_primitive_bf16_from!(i32, from_f32);
-impl_as_primitive_bf16_from!(u32, from_f32);
-impl_as_primitive_bf16_from!(isize, from_f32);
-impl_as_primitive_bf16_from!(usize, from_f32);
-impl_as_primitive_bf16_from!(f32, from_f32);
-impl_as_primitive_bf16_from!(f64, from_f64);
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);
-    }
-}
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[..]);
-    }
-}