Deleted vendor folder

1 files changed, 0 insertions, 233 deletions

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 {}
-}