Wide

https://docs.rs/wide
Admin
A crate that provides SIMD-compatible data types, utilizing explicit SIMD for mathematical...
Tokens:874,102
Snippets:5,338
Trust Score:9.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### u64x2 Constructor

Source: https://docs.rs/wide/latest/wide/struct.u64x2.html

Demonstrates how to create a new u64x2 instance using the `new` constructor.

```APIDOC
## Constructor for u64x2

### Description
Creates a new `u64x2` instance from a 2-element array of `u64`.

### Method
`new(array: [u64; 2]) -> Self`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **array** (`[u64; 2]`) - Required - An array of two `u64` elements to initialize the vector.
```

--------------------------------

### i64x2::zeroed

Source: https://docs.rs/wide/latest/wide/struct.i64x2.html

Creates a new i64x2 vector with all lanes initialized to zero. This is a convenient way to get a default or starting value.

```APIDOC
## i64x2::zeroed

### Description
Creates a new i64x2 vector with all lanes initialized to zero. This is a convenient way to get a default or starting value.

### Method
`zeroed`

### Returns
`i64x2`: A new i64x2 vector with all elements set to zero.
```

--------------------------------

### new

Source: https://docs.rs/wide/latest/src/wide/f64x8_.rs.html

Constructs a new f64x8 instance from an array of 8 f64 values.

```APIDOC
## new

### Description
Constructs a new `f64x8` instance from an array of 8 `f64` values.

### Signature
```rust
pub const fn new(array: [f64; 8]) -> Self
```

### Parameters
* `array` - An array of 8 `f64` values to initialize the `f64x8` instance.
```

--------------------------------

### f32x4 Fused Multiply-Add Operation Example

Source: https://docs.rs/wide/latest/src/wide/f32x4_.rs.html

Example usage of the `mul_add` function for `f32x4`.

```rust
/// let a = f32x4::from([1.0, 2.0, 3.0, 4.0]);
/// let b = f32x4::from([2.0, 3.0, 4.0, 5.0]);
/// let c = f32x4::from([5.0, 10.0, 15.0, 20.0]);
///
/// let result = a.mul_add(b, c);
///
/// let expected = f32x4::from([7.0, 16.0, 27.0, 40.0]);
/// assert_eq!(result, expected);
/// ```
```

--------------------------------

### impl<T> Any for T

Source: https://docs.rs/wide/latest/wide/struct.i8x32.html

Provides the ability to get the `TypeId` of any type `T` that is `'static + ?Sized`.

```APIDOC
## Blanket Implementations

### impl<T> Any for T
where T: 'static + ?Sized,
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more
```

--------------------------------

### i8x16 Constructor

Source: https://docs.rs/wide/latest/wide/struct.i8x16.html

Demonstrates how to create a new i8x16 instance from an array of 16 i8 values.

```APIDOC
## Constructor

### `pub const fn new(array: [i8; 16]) -> Self`

Creates a new `i8x16` vector from a fixed-size array of 16 `i8` elements.
```

--------------------------------

### T::type_id

Source: https://docs.rs/wide/latest/wide/struct.i32x4.html

Gets the `TypeId` of the given type `T`. This is part of the `Any` trait implementation.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Returns
The `TypeId` of the object.
```

--------------------------------

### impl<T> NoUninit for T

Source: https://docs.rs/wide/latest/wide/struct.f32x8.html

Blanket implementation of `NoUninit` for types `T` that implement `Pod`.

```APIDOC
## impl<T> NoUninit for T

### Description
This is a blanket implementation of the `NoUninit` trait for any type `T` that implements `Pod`. This indicates that the type does not have any uninitialized memory within its representation.
```

--------------------------------

### impl<T> Any for T

Source: https://docs.rs/wide/latest/wide/struct.f32x16.html

Provides the `type_id` method to get the unique identifier of a type.

```APIDOC
## fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`.
```

--------------------------------

### u8x16 Constructor

Source: https://docs.rs/wide/latest/wide/struct.u8x16.html

Demonstrates how to create a new u8x16 instance from a fixed-size array of 16 u8 elements.

```APIDOC
## Constructor for u8x16

### `new`

`pub const fn new(array: [u8; 16]) -> Self`

Creates a new `u8x16` instance from a fixed-size array of 16 `u8` elements.
```

--------------------------------

### Zeroable Trait

Source: https://docs.rs/wide/latest/wide/struct.f32x16.html

Provides a method to get a zero-initialized value of f32x16.

```APIDOC
## Zeroable Trait

### `impl Zeroable for f32x16`

Provides a method to get a zero-initialized value.

#### `fn zeroed() -> Self`
```

--------------------------------

### Constructor

Source: https://docs.rs/wide/latest/wide/struct.i8x32.html

Provides a constructor for creating an i8x32 instance from an array.

```APIDOC
## Constructor

### `new`

`pub const fn new(array: [i8; 32]) -> Self`

Creates a new `i8x32` vector from a 32-element array.
```

--------------------------------

### i64x2 Constructor and Methods

Source: https://docs.rs/wide/latest/wide/struct.i64x2.html

Details on how to construct an i64x2 vector and various methods for element-wise comparison, blending, sign checking, reduction, absolute value, signum, rounding, bitmask conversion, transpose, array conversion, and arithmetic operations.

```APIDOC
## Constructor

### `new`
`pub const fn new(array: [i64; 2]) -> Self`
Creates a new `i64x2` vector from a 2-element array.

## Methods

### `simd_eq`
`pub fn simd_eq<Rhs>(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output`
Test if each element is equal to the corresponding element in `other`.

### `simd_ne`
`pub fn simd_ne<Rhs>(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output`
Test if each element is not equal to the corresponding element in `other`.

### `simd_lt`
`pub fn simd_lt<Rhs>(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output`
Test if each element is less than the corresponding element in `other`.

### `simd_gt`
`pub fn simd_gt<Rhs>(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output`
Test if each element is greater than the corresponding element in `other`.

### `simd_le`
`pub fn simd_le<Rhs>(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output`
Test if each element is less than or equal to the corresponding element in `other`.

### `simd_ge`
`pub fn simd_ge<Rhs>(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output`
Test if each element is greater than or equal to the corresponding element in `other`.

### `blend`
`pub fn blend(self, t: Self, f: Self) -> Self`
Blends two vectors based on a third boolean vector.

### `is_positive`
`pub fn is_positive(self) -> Self`
Returns true for each positive element and false if it is zero or negative.

### `is_negative`
`pub fn is_negative(self) -> Self`
Returns true for each negative element and false if it is zero or positive.

### `reduce_add`
`pub fn reduce_add(self) -> i64`
Adds all elements of the vector together.

### `reduce_max`
`pub fn reduce_max(self) -> i64`
Returns the maximum element in the vector.

### `reduce_min`
`pub fn reduce_min(self) -> i64`
Returns the minimum element in the vector.

### `abs`
`pub fn abs(self) -> Self`
Returns the absolute value of each element.

### `unsigned_abs`
`pub fn unsigned_abs(self) -> u64x2`
Returns the unsigned absolute value of each element.

### `signum`
`pub fn signum(self) -> Self`
Returns numbers representing the sign of each element:
  * `0` if the number is zero
  * `1` if the number is positive
  * `-1` if the number is negative

### `round_float`
`pub fn round_float(self) -> f64x2`
Rounds each element to the nearest floating-point number.

### `to_bitmask`
`pub fn to_bitmask(self) -> u32`
Returns the bit mask for each high bit set in the vector with the lowest lane being the lowest bit.

### `any`
`pub fn any(self) -> bool`
Returns true if any high bits are set for any value in the vector.

### `all`
`pub fn all(self) -> bool`
Returns true if all high bits are set for every value in the vector.

### `none`
`pub fn none(self) -> bool`
Returns true if no high bits are set for any values of the vector.

### `transpose`
`pub fn transpose(data: [i64x2; 2]) -> [i64x2; 2]`
Transpose matrix of 2x2 `i64` matrix.

### `to_array`
`pub fn to_array(self) -> [i64; 2]`
Converts the SIMD vector to a 2-element array.

### `as_array`
`pub fn as_array(&self) -> &[i64; 2]`
Returns a reference to the underlying array representation.

### `as_mut_array`
`pub fn as_mut_array(&mut self) -> &mut [i64; 2]`
Returns a mutable reference to the underlying array representation.

### `min`
`pub fn min(self, rhs: Self) -> Self`
Returns the element-wise minimum of two vectors.

### `max`
`pub fn max(self, rhs: Self) -> Self`
Returns the element-wise maximum of two vectors.

### `clamp`
`pub fn clamp(self, min: Self, max: Self) -> Self`
Restricts each element to a certain interval.
If `min > max`, the result is unspecified. Consider manually checking for that case.

### `saturating_add`
`pub fn saturating_add(self, rhs: Self) -> Self`
Performs saturating addition on each element.

### `saturating_sub`
`pub fn saturating_sub(self, rhs: Self) -> Self`
Performs saturating subtraction on each element.

### `saturating_mul`
`pub fn saturating_mul(self, rhs: Self) -> Self`
Lanewise saturating multiply.

### `saturating_div`
`pub fn saturating_div(self, rhs: Self) -> Self`
Lanewise saturating divide.
Note that because division has no hardware support, this operation is very slow and should be avoided if possible.
```

--------------------------------

### Get f32x8 infinity

Source: https://docs.rs/wide/latest/src/wide/f32x8_.rs.html

Returns an f32x8 vector with all elements set to positive infinity.

```rust
fn infinity() -> Self {
    cast::<_, f32x8>(i32x8::splat(0x7F800000))
  }
```

--------------------------------

### Any::type_id

Source: https://docs.rs/wide/latest/wide/struct.u8x32.html

Gets the TypeId of the object. This is part of the Any trait implementation, allowing for runtime type identification.

```APIDOC
## Any::type_id

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Response
- **TypeId**: The unique identifier for the type of `self`.
```

--------------------------------

### i64x8 Constructor

Source: https://docs.rs/wide/latest/wide/struct.i64x8.html

Demonstrates how to create a new i64x8 SIMD vector from an array of 8 i64 elements.

```APIDOC
## Constructor for i64x8

### `new(array: [i64; 8]) -> Self`
Creates a new `i64x8` SIMD vector from a fixed-size array of 8 `i64` elements.
```

--------------------------------

### Zeroable for f64x2

Source: https://docs.rs/wide/latest/wide/struct.f64x2.html

Implementation of the Zeroable trait for f64x2, providing a way to get a zeroed instance.

```APIDOC
## fn zeroed() -> Self

### Description
Calls `zeroed` to create a zeroed instance of `Self`.

### Returns
- Self - A zeroed instance of f64x2.
```

--------------------------------

### Constructor for u64x4

Source: https://docs.rs/wide/latest/wide/struct.u64x4.html

Provides a constructor to create a new u64x4 instance from an array of 4 u64 values.

```APIDOC
## Constructor

### `new`
`pub const fn new(array: [u64; 4]) -> Self`
* Creates a new `u64x4` from an array of 4 `u64` values.
```

--------------------------------

### Get f32x8 NaN

Source: https://docs.rs/wide/latest/src/wide/f32x8_.rs.html

Returns an f32x8 vector with all elements set to a specific NaN value.

```rust
fn nan_log() -> Self {
    cast::<_, f32x8>(i32x8::splat(0x7FC00000 | 0x101 & 0x003FFFFF))
  }
```

```rust
fn nan_pow() -> Self {
    cast::<_, f32x8>(i32x8::splat(0x7FC00000 | 0x101 & 0x003FFFFF))
  }
```

--------------------------------

### u64x2 Min/Max Methods

Source: https://docs.rs/wide/latest/wide/struct.u64x2.html

Explains the element-wise minimum and maximum methods for `u64x2` vectors.

```APIDOC
## Min/Max Methods for u64x2

### Description
Performs element-wise minimum and maximum operations between two `u64x2` vectors.

### Methods
- **min(self, rhs: Self) -> Self**: Returns a new vector where each element is the minimum of the corresponding elements in `self` and `rhs`.
- **max(self, rhs: Self) -> Self**: Returns a new vector where each element is the maximum of the corresponding elements in `self` and `rhs`.

### Parameters
- **self**: `u64x2` - The first vector.
- **rhs**: `Self` - The second vector.

### Returns
A new `u64x2` vector containing the element-wise minimum or maximum values.
```

--------------------------------

### Constructor and Utility Functions

Source: https://docs.rs/wide/latest/src/wide/u32x16_.rs.html

Provides a constructor for creating `u32x16` vectors and a macro for generating common comparison functions.

```APIDOC
## `u32x16::new`

### Description
Creates a new `u32x16` SIMD vector from a 16-element array of `u32`.

### Method
`pub const fn new(array: [u32; 16]) -> Self`

### Parameters
- `array`: A `[u32; 16]` array containing the values for the vector.

### Response
- `Self`: A new `u32x16` vector.

## `simd_comparison_fns!()` Macro

### Description
This macro is used internally to generate common SIMD comparison functions for the `u32x16` type. It is not intended for direct use by the end-user.
```

--------------------------------

### impl Zeroable for u64x2

Source: https://docs.rs/wide/latest/wide/struct.u64x2.html

Implements the `Zeroable` trait for u64x2, providing a method to get a zero-initialized instance.

```APIDOC
## fn zeroed() -> Self

Returns a `u64x2` value where all lanes are initialized to zero.

### Method
`zeroed`

### Returns
* `Self` (u64x2) - A `u64x2` instance with all lanes set to 0.
```

--------------------------------

### i32x4 Min/Max and Clamp Methods

Source: https://docs.rs/wide/latest/wide/struct.i32x4.html

Methods for element-wise minimum, maximum, and clamping operations.

```APIDOC
## i32x4 Min/Max and Clamp Methods

### `pub fn max(self, rhs: Self) -> Self`

Returns a vector containing the element-wise maximum of `self` and `rhs`.

### `pub fn min(self, rhs: Self) -> Self`

Returns a vector containing the element-wise minimum of `self` and `rhs`.

### `pub fn clamp(self, min: Self, max: Self) -> Self`

Restricts each element to the interval defined by `min` and `max`. If `min > max`, the result is unspecified. Consider manually checking for that case.
```

--------------------------------

### impl Zeroable for i8x32

Source: https://docs.rs/wide/latest/wide/struct.i8x32.html

Implements the Zeroable trait for i8x32, providing a method to get a zeroed value.

```APIDOC
## fn zeroed() -> Self

### Description
Calls `zeroed`.

### Method
zeroed

### Returns
- Self (i8x32) - A zeroed instance of i8x32.
```

--------------------------------

### Get Mutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.u64x4.html

Provides a mutable reference to the underlying `u64` array of the `u64x4` vector.

```rust
pub fn as_mut_array(&mut self) -> &mut [u64; 4]
```

--------------------------------

### u64x2 Splat Constructor

Source: https://docs.rs/wide/latest/wide/struct.u64x2.html

Demonstrates how to create a `u64x2` vector where all elements are initialized to the same value using the `splat` constructor.

```APIDOC
## Splat Constructor for u64x2

### Description
Creates a new `u64x2` instance where all elements are initialized to the same specified value.

### Method
`splat(elem: u64) -> u64x2`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **elem** (`u64`) - Required - The `u64` value to replicate across all elements of the vector.
```

--------------------------------

### Get Immutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.u64x4.html

Provides an immutable reference to the underlying `u64` array of the `u64x4` vector.

```rust
pub fn as_array(&self) -> &[u64; 4]
```

--------------------------------

### u64x2 Comparison Methods

Source: https://docs.rs/wide/latest/wide/struct.u64x2.html

Details the SIMD-aware comparison methods for u64x2, including equality, inequality, and relational comparisons.

```APIDOC
## Comparison Methods for u64x2

### Description
Performs element-wise comparisons between two `u64x2` vectors.

### Methods
- **simd_eq(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output**: Tests if each element is equal to the corresponding element in `other`.
- **simd_ne(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output**: Tests if each element is not equal to the corresponding element in `other`.
- **simd_lt(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output**: Tests if each element is less than the corresponding element in `other`.
- **simd_gt(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output**: Tests if each element is greater than the corresponding element in `other`.
- **simd_le(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output**: Tests if each element is less than or equal to the corresponding element in `other`.
- **simd_ge(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output**: Tests if each element is greater than or equal to the corresponding element in `other`.

### Parameters
- **self**: `u64x2` - The first vector.
- **other**: `Rhs` - The second vector to compare against. `Rhs` must implement the relevant comparison trait (`CmpEq`, `CmpNe`, etc.).

### Returns
A vector of booleans or a similar type indicating the result of each element-wise comparison.
```

--------------------------------

### impl<T> NoUninit for T

Source: https://docs.rs/wide/latest/wide/struct.i16x32.html

Indicates that the type does not have any uninitialized memory.

```APIDOC
## impl<T> NoUninit for T

### Description
Indicates that the type does not have any uninitialized memory.

### Trait
NoUninit
```

--------------------------------

### Get Mutable Reference to Array

Source: https://docs.rs/wide/latest/src/wide/f64x8_.rs.html

Provides a mutable reference to the underlying f64 array of the f64x8 vector.

```rust
  #[inline]
  #[must_use]
  pub fn as_mut_array(&mut self) -> &mut [f64; 8] {
    cast_mut(self)
  }
```

--------------------------------

### new

Source: https://docs.rs/wide/latest/src/wide/u16x32_.rs.html

Creates a new u16x32 instance from a 32-element array of u16.

```APIDOC
## new

### Description
Creates a new u16x32 instance from a 32-element array of u16.

### Signature
`pub const fn new(array: [u16; 32]) -> Self`

### Parameters
* `array` ([u16; 32]): An array of 32 unsigned 16-bit integers.
```

--------------------------------

### Get Immutable Reference to Array

Source: https://docs.rs/wide/latest/src/wide/f64x8_.rs.html

Provides an immutable reference to the underlying f64 array of the f64x8 vector.

```rust
  #[inline]
  #[must_use]
  pub fn as_array(&self) -> &[f64; 8] {
    cast_ref(self)
  }
```

--------------------------------

### i64x4 Constructor and Methods

Source: https://docs.rs/wide/latest/wide/struct.i64x4.html

Details the constructor and various methods available for the i64x4 struct, including SIMD comparisons, blending, sign checks, reduction operations, absolute value, signum, rounding, bitmask conversion, boolean checks, array conversions, min/max/clamp, saturating arithmetic, and matrix transpose.

```APIDOC
## i64x4 Struct Methods

### Description
Provides access to the constructor and various methods for the i64x4 SIMD vector.

### Constructor
#### `new(array: [i64; 4]) -> Self`
Creates a new `i64x4` instance from a 4-element array of `i64`.

### Comparison Methods
These methods perform element-wise comparisons between two `i64x4` vectors.

- **`simd_eq(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output`**: Tests if each element is equal to the corresponding element in `other`.
- **`simd_ne(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output`**: Tests if each element is not equal to the corresponding element in `other`.
- **`simd_lt(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output`**: Tests if each element is less than the corresponding element in `other`.
- **`simd_gt(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output`**: Tests if each element is greater than the corresponding element in `other`.
- **`simd_le(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output`**: Tests if each element is less than or equal to the corresponding element in `other`.
- **`simd_ge(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output`**: Tests if each element is greater than or equal to the corresponding element in `other`.

### Blending
- **`blend(self, t: Self, f: Self) -> Self`**: Blends two vectors based on a mask.

### Sign and Value Checks
- **`is_positive(self) -> Self`**: Returns true for each positive element and false if it is zero or negative.
- **`is_negative(self) -> Self`**: Returns true for each negative element and false if it is zero or positive.
- **`abs(self) -> Self`**: Computes the absolute value of each element.
- **`signum(self) -> Self`**: Returns numbers representing the sign of each element (`0` for zero, `1` for positive, `-1` for negative).

### Reduction Operations
These methods reduce the vector to a single scalar value.

- **`reduce_add(self) -> i64`**: Computes the sum of all elements.
- **`reduce_max(self) -> i64`**: Computes the maximum element.
- **`reduce_min(self) -> i64`**: Computes the minimum element.

### Conversions and Bit Operations
- **`unsigned_abs(self) -> u64x4`**: Computes the unsigned absolute value of each element.
- **`round_float(self) -> f64x4`**: Rounds each element to the nearest floating-point number.
- **`to_bitmask(self) -> u32`**: Returns the bit mask for each high bit set in the vector, with the lowest lane being the lowest bit.
- **`any(self) -> bool`**: Returns true if any high bits are set for any value in the vector.
- **`all(self) -> bool`**: Returns true if all high bits are set for every value in the vector.
- **`none(self) -> bool`**: Returns true if no high bits are set for any values of the vector.
- **`to_array(self) -> [i64; 4]`**: Converts the SIMD vector to a 4-element array.
- **`as_array(&self) -> &[i64; 4]`**: Returns a reference to the underlying array.
- **`as_mut_array(&mut self) -> &mut [i64; 4]`**: Returns a mutable reference to the underlying array.

### Arithmetic Operations
- **`min(self, rhs: Self) -> Self`**: Computes the element-wise minimum of two vectors.
- **`max(self, rhs: Self) -> Self`**: Computes the element-wise maximum of two vectors.
- **`clamp(self, min: Self, max: Self) -> Self`**: Restricts each element to a certain interval. If `min > max`, the result is unspecified.
- **`saturating_add(self, rhs: Self) -> Self`**: Performs saturating addition element-wise.
- **`saturating_sub(self, rhs: Self) -> Self`**: Performs saturating subtraction element-wise.
- **`saturating_mul(self, rhs: Self) -> Self`**: Performs saturating multiplication element-wise.
- **`saturating_div(self, rhs: Self) -> Self`**: Performs saturating division element-wise. Note that this operation is slow.

### Matrix Operations
- **`transpose(data: [i64x4; 4]) -> [i64x4; 4]`**: Transposes a 4x4 matrix of `i64x4` vectors.
```

--------------------------------

### Get Cosine from Sine-Cosine Pair

Source: https://docs.rs/wide/latest/src/wide/f64x8_.rs.html

Extracts the cosine component from a pre-calculated sine-cosine pair for f64x8 vectors.

```rust
let (_, c) = self.sin_cos();
c
```

--------------------------------

### Get Sine from Sine-Cosine Pair

Source: https://docs.rs/wide/latest/src/wide/f64x8_.rs.html

Extracts the sine component from a pre-calculated sine-cosine pair for f64x8 vectors.

```rust
let (s, _) = self.sin_cos();
s
```

--------------------------------

### u16x8 Min/Max and Clamp Methods

Source: https://docs.rs/wide/latest/wide/struct.u16x8.html

Methods for element-wise minimum, maximum, and clamping operations.

```APIDOC
## Min/Max and Clamp Methods

### `max(self, rhs: Self) -> Self`

Performs element-wise maximum operation between two vectors.

### `min(self, rhs: Self) -> Self`

Performs element-wise minimum operation between two vectors.

### `clamp(self, min: Self, max: Self) -> Self`

Restricts each element to a certain interval defined by `min` and `max`. If `min > max`, the result is unspecified.
```

--------------------------------

### Get mutable reference to array

Source: https://docs.rs/wide/latest/src/wide/i64x4_.rs.html

Provides a mutable reference to the underlying array representation of the i64x4 vector.

```rust
  #[inline]
  pub fn as_mut_array(&mut self) -> &mut [i64; 4] {
    cast_mut(self)
  }
```

--------------------------------

### i64x8 Splat Constructor

Source: https://docs.rs/wide/latest/wide/struct.i64x8.html

Demonstrates how to create a new i64x8 SIMD vector where all elements are initialized to the same value.

```APIDOC
## Splat Constructor for i64x8

### `splat(elem: i64) -> i64x8`
Creates a new `i64x8` SIMD vector where all 8 elements are initialized to the provided `elem` value.
```

--------------------------------

### Get immutable reference to array

Source: https://docs.rs/wide/latest/src/wide/i64x4_.rs.html

Provides an immutable reference to the underlying array representation of the i64x4 vector.

```rust
  #[inline]
  pub fn as_array(&self) -> &[i64; 4] {
    cast_ref(self)
  }
```

--------------------------------

### u64x8 Constructor and Basic Operations

Source: https://docs.rs/wide/latest/wide/struct.u64x8.html

Methods for creating and performing basic SIMD operations on u64x8 vectors.

```APIDOC
## Constructor

### `new(array: [u64; 8]) -> Self`

Creates a new `u64x8` vector from an array of 8 `u64` elements.

### `splat(elem: u64) -> u64x8`

Creates a new `u64x8` vector with all lanes set to the given element.
```

--------------------------------

### f64x8 Bitwise AND Implementation

Source: https://docs.rs/wide/latest/src/wide/f64x8_.rs.html

Implements the BitAnd trait for f64x8. This snippet is incomplete and only shows the start of the implementation.

```rust
impl BitAnd for f64x8 {
  type Output = Self;
  #[inline]
  fn bitand(self, rhs: Self) -> Self::Output {
    pick! {

```

--------------------------------

### i32x8 Constructor

Source: https://docs.rs/wide/latest/wide/struct.i32x8.html

Provides a constructor for creating an i32x8 instance from an array of 8 i32 values.

```APIDOC
## i32x8 Constructor

### `pub const fn new(array: [i32; 8]) -> Self`
```

--------------------------------

### u32x4 Constructor

Source: https://docs.rs/wide/latest/wide/struct.u32x4.html

Demonstrates how to create a new u32x4 SIMD vector from an array of four u32 elements.

```APIDOC
## Constructor

### `new`

`pub const fn new(array: [u32; 4]) -> Self`

Creates a new `u32x4` vector from a four-element array.
```

--------------------------------

### Get Mutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.u64x8.html

Provides a mutable reference to the underlying data as a slice of 8 u64 elements.

```rust
pub fn as_mut_array(&mut self) -> &mut [u64; 8]
```

--------------------------------

### u32x8 Constructor

Source: https://docs.rs/wide/latest/wide/struct.u32x8.html

Demonstrates how to create a new u32x8 SIMD vector from an array of 8 u32 elements.

```APIDOC
## Constructor

### `new(array: [u32; 8]) -> Self`

Creates a new `u32x8` instance from a fixed-size array of 8 `u32` elements.
```

--------------------------------

### Get Immutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.u64x8.html

Provides an immutable reference to the underlying data as a slice of 8 u64 elements.

```rust
pub fn as_array(&self) -> &[u64; 8]
```

--------------------------------

### f32x4 Constructor and Comparison Methods

Source: https://docs.rs/wide/latest/wide/struct.f32x4.html

Methods for creating new f32x4 vectors and performing element-wise comparisons.

```APIDOC
## Constructor

### `f32x4::new(array: [f32; 4]) -> Self`
Creates a new `f32x4` vector from a four-element array of `f32`.

## Comparison Methods

### `simd_eq(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output`
Tests if each element is equal to the corresponding element in `other`.

### `simd_ne(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output`
Tests if each element is not equal to the corresponding element in `other`.

### `simd_lt(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output`
Tests if each element is less than the corresponding element in `other`.

### `simd_gt(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output`
Tests if each element is greater than the corresponding element in `other`.

### `simd_le(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output`
Tests if each element is less than or equal to the corresponding element in `other`.

### `simd_ge(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output`
Tests if each element is greater than or equal to the corresponding element in `other`.
```

--------------------------------

### Get Mutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.u32x8.html

Provides a mutable slice reference to the underlying array of 8 u32 elements.

```rust
pub fn as_mut_array(&mut self) -> &mut [u32; 8]
```

--------------------------------

### CloneToUninit for T

Source: https://docs.rs/wide/latest/wide/struct.f64x2.html

Nightly-only experimental API for cloning to uninitialized memory.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest` in uninitialized memory.

### Parameters
#### Path Parameters
- **self** (&T) - Required - The source value to clone.
- **dest** (*mut u8) - Required - A pointer to the destination memory.
```

--------------------------------

### Get Immutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.u32x8.html

Provides an immutable slice reference to the underlying array of 8 u32 elements.

```rust
pub fn as_array(&self) -> &[u32; 8]
```

--------------------------------

### Get Mutable Slice of Array

Source: https://docs.rs/wide/latest/wide/struct.i32x8.html

Returns a mutable slice reference to the underlying array of 8 i32 elements.

```rust
pub fn as_mut_array(&mut self) -> &mut [i32; 8]
```

--------------------------------

### u8x16 Splat Constructor

Source: https://docs.rs/wide/latest/wide/struct.u8x16.html

Demonstrates how to create a u8x16 instance where all lanes are initialized to the same scalar value.

```APIDOC
## Splat Constructor for u8x16

### `splat`

`pub const fn splat(elem: u8) -> u8x16`

Creates a `u8x16` vector where all 16 lanes are initialized to the given `elem` value.
```

--------------------------------

### u8x32::new

Source: https://docs.rs/wide/latest/src/wide/u8x32_.rs.html

Constructs a new u8x32 instance from a 32-byte array.

```APIDOC
## u8x32::new

### Description
Constructs a new u8x32 instance from a 32-byte array.

### Signature
`pub const fn new(array: [u8; 32]) -> Self`

### Parameters
* `array` ([u8; 32]) - The array of 32 bytes to initialize the u8x32 with.
```

--------------------------------

### Get Immutable Slice of Array

Source: https://docs.rs/wide/latest/wide/struct.i32x8.html

Returns an immutable slice reference to the underlying array of 8 i32 elements.

```rust
pub fn as_array(&self) -> &[i32; 8]
```

--------------------------------

### Default

Source: https://docs.rs/wide/latest/wide/struct.i64x2.html

Provides a default value for i64x2.

```APIDOC
## Default for i64x2

### Description
Returns the default value for the i64x2 type.

### Method
`default() -> i64x2`
```

--------------------------------

### Get Mutable Slice of u64x4 as Array

Source: https://docs.rs/wide/latest/src/wide/u64x4_.rs.html

Provides a mutable reference to the u64x4 vector as a slice of [u64; 4].

```rust
pub fn as_mut_array(&mut self) -> &mut [u64; 4] {
    cast_mut(self)
  }
```

--------------------------------

### i32x4 Constructor

Source: https://docs.rs/wide/latest/wide/struct.i32x4.html

Provides a constructor for creating an i32x4 instance from an array of four i32 integers.

```APIDOC
## i32x4 Constructor

### `pub const fn new(array: [i32; 4]) -> Self`

Creates a new `i32x4` vector from a fixed-size array of four `i32` integers.
```

--------------------------------

### Get Immutable Slice of u64x4 as Array

Source: https://docs.rs/wide/latest/src/wide/u64x4_.rs.html

Provides an immutable reference to the u64x4 vector as a slice of [u64; 4].

```rust
pub fn as_array(&self) -> &[u64; 4] {
    cast_ref(self)
  }
```

--------------------------------

### Get Mutable Reference to i64 Array

Source: https://docs.rs/wide/latest/src/wide/i64x2_.rs.html

Provides a mutable reference to the underlying array representation of an i64x2 vector.

```rust
pub fn as_mut_array(&mut self) -> &mut [i64; 2] {
    cast_mut(self)
  }
```

--------------------------------

### impl<T> CloneToUninit for T

Source: https://docs.rs/wide/latest/wide/struct.i16x32.html

Provides an experimental method for cloning data to an uninitialized memory location. `clone_to_uninit` performs copy-assignment.

```APIDOC
## impl<T> CloneToUninit for T

### Description
Provides an experimental method for cloning data to an uninitialized memory location. `clone_to_uninit` performs copy-assignment.

### Methods
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.
```

--------------------------------

### Get Slice Reference to Array

Source: https://docs.rs/wide/latest/wide/struct.u8x16.html

Provides a reference to the underlying array of 16 u8 elements within a u8x16 vector.

```rust
pub fn as_array(&self) -> &[u8; 16]
```

--------------------------------

### From<i32x8> for f64x8

Source: https://docs.rs/wide/latest/src/wide/f64x8_.rs.html

Implements the `From` trait to allow direct conversion from `i32x8` to `f64x8` using the `into()` method.

```APIDOC
## From<i32x8> for f64x8

### Description
This implementation allows for idiomatic conversion of an `i32x8` vector into an `f64x8` vector using the `into()` method. It leverages the `from_i32x8` function internally.

### Parameters
* `v` - `i32x8` - The `i32x8` vector to convert.

### Returns
* `Self` - A new `f64x8` vector.

### Example
```rust
let i32_vector: i32x8 = ...; // Initialize your i32x8 vector
let f64_vector: f64x8 = i32_vector.into();
```
```

--------------------------------

### Get Mutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.i8x32.html

Provides a mutable reference to the underlying `[i8; 32]` array representation of the `i8x32` vector.

```rust
pub fn as_mut_array(&mut self) -> &mut [i8; 32]
```

--------------------------------

### impl Binary for u64x2

Source: https://docs.rs/wide/latest/wide/struct.u64x2.html

Enables binary formatting for u64x2 vectors.

```APIDOC
## impl Binary for u64x2

### Description
Allows `u64x2` vectors to be formatted using binary representation.

### Method
`fmt(&self, f: &mut Formatter<'_>) -> Result`

### Parameters
- `self`: The `u64x2` vector to format.
- `f`: The formatter to use.
```

--------------------------------

### Get Immutable Array Slice

Source: https://docs.rs/wide/latest/wide/struct.i8x32.html

Provides an immutable reference to the underlying `[i8; 32]` array representation of the `i8x32` vector.

```rust
pub fn as_array(&self) -> &[i8; 32]
```

--------------------------------

### new

Source: https://docs.rs/wide/latest/src/wide/i16x8_.rs.html

Constructs a new i16x8 vector from a fixed-size array of 8 i16 values.

```APIDOC
## new

### Description
Constructs a new i16x8 vector from a fixed-size array of 8 i16 values.

### Method
`new(array: [i16; 8]) -> Self`

### Parameters
- `array`: A fixed-size array of 8 `i16` values.

### Returns
A new `i16x8` vector.
```

--------------------------------

### Constructor

Source: https://docs.rs/wide/latest/wide/struct.i16x8.html

Creates a new i16x8 vector from an array of 8 i16 values.

```APIDOC
## new

### Description
Creates a new `i16x8` vector from an array of 8 `i16` values.

### Signature
`pub const fn new(array: [i16; 8]) -> Self`
```

--------------------------------

### Get Slice Reference to Array

Source: https://docs.rs/wide/latest/wide/struct.i64x2.html

Provides a slice reference to the underlying 2-element array of i64 within the i64x2 vector.

```rust
pub fn as_array(&self) -> &[i64; 2]
```

--------------------------------

### f64x8 SIMD Comparison Methods

Source: https://docs.rs/wide/latest/wide/struct.f64x8.html

Methods for element-wise comparison between `f64x8` instances.

```APIDOC
## SIMD Comparison Methods

### `simd_eq<Rhs>(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output`
Tests if each element is equal to the corresponding element in `other`.

### `simd_ne<Rhs>(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output`
Tests if each element is not equal to the corresponding element in `other`.

### `simd_lt<Rhs>(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output`
Tests if each element is less than the corresponding element in `other`.

### `simd_gt<Rhs>(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output`
Tests if each element is greater than the corresponding element in `other`.

### `simd_le<Rhs>(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output`
Tests if each element is less than or equal to the corresponding element in `other`.

### `simd_ge<Rhs>(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output`
Tests if each element is greater than or equal to the corresponding element in `other`.
```

--------------------------------

### Get Mutable Reference to Array

Source: https://docs.rs/wide/latest/src/wide/f32x16_.rs.html

Provides a mutable reference to the underlying [f32; 16] array representation of the f32x16 vector.

```rust
#[inline]
#[must_use]
pub fn as_mut_array(&mut self) -> &mut [f32; 16] {
  cast_mut(self)
}
```

--------------------------------

### Implement From<i32x4> for f64x4

Source: https://docs.rs/wide/latest/src/wide/f64x4_.rs.html

Provides a convenient way to convert an i32x4 vector into an f64x4 vector using the `into()` method.

```rust
impl From<i32x4> for f64x4 {
  #[inline]
  fn from(v: i32x4) -> Self {
    Self::from_i32x4(v)
  }
}
```

--------------------------------

### Get Immutable Reference to Array

Source: https://docs.rs/wide/latest/src/wide/f32x16_.rs.html

Provides an immutable reference to the underlying [f32; 16] array representation of the f32x16 vector.

```rust
#[inline]
#[must_use]
pub fn as_array(&self) -> &[f32; 16] {
  cast_ref(self)
}
```

--------------------------------

### new

Source: https://docs.rs/wide/latest/src/wide/u32x8_.rs.html

Constructs a new u32x8 vector from an array of 8 u32 values.

```APIDOC
## new

### Description
Constructs a new u32x8 vector from an array of 8 u32 values.

### Method
`new(array: [u32; 8]) -> Self`

### Parameters
- `array`: An array of 8 u32 values to initialize the vector with.

### Request Example
```rust
# use wide::u32x8;
let vec = u32x8::new([1, 2, 3, 4, 5, 6, 7, 8]);
```

### Response
- `Self`: A new u32x8 vector.
```

--------------------------------

### Get fraction part of f32x8

Source: https://docs.rs/wide/latest/src/wide/f32x8_.rs.html

Calculates the fractional part of each element in an f32x8 vector, effectively isolating the mantissa for analysis.

```rust
fn fraction_2(self) -> Self {
    let t1 = cast::<_, u32x8>(self);
    let t2 = cast::<_, u32x8>(
      (t1 & u32x8::from(0x007FFFFF)) | u32x8::from(0x3F000000),
    );
    cast::<_, f32x8>(t2)
  }
```

--------------------------------

### CmpLt Implementations

Source: https://docs.rs/wide/latest/wide/struct.u8x16.html

Provides implementations for less-than comparison for u8x16. Note: These are deprecated.

```APIDOC
## CmpLt for u8x16

### Description
Compares two u8x16 vectors element-wise for less than.

### Method
Implicit (operator overload)

### Endpoint
N/A (Method implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let a: u8x16 = ...;
let b: u8x16 = ...;
let result = a < b; // Uses CmpLt
```

### Response
#### Success Response (200)
- **Output** (u8x16) - A u8x16 vector where each element is true if the corresponding element in `self` is less than the corresponding element in `rhs`, and false otherwise.

#### Response Example
```json
{
  "example": "[true, false, true, ...]"
}
```

**Deprecated since 1.5.0**: Use inherit function instead.
```

```APIDOC
## CmpLt<u8> for u8x16

### Description
Compares a u8x16 vector with a scalar u8 for less than.

### Method
Implicit (operator overload)

### Endpoint
N/A (Method implementation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
let a: u8x16 = ...;
let b: u8 = ...;
let result = a < b; // Uses CmpLt<u8>
```

### Response
#### Success Response (200)
- **Output** (u8x16) - A u8x16 vector where each element is true if the corresponding element in `self` is less than `rhs`, and false otherwise.

#### Response Example
```json
{
  "example": "[true, false, true, ...]"
}
```

**Deprecated since 1.5.0**: Use inherit function instead.
```

--------------------------------

### Get Immutable Slice of u16x16 as Array

Source: https://docs.rs/wide/latest/src/wide/u16x16_.rs.html

Provides an immutable reference to the u16x16 vector as a slice of 16 u16 elements.

```rust
pub fn as_array(&self) -> &[u16; 16] {
    cast_ref(self)
  }
```

--------------------------------

### i32x16 Min/Max and Clamp Methods

Source: https://docs.rs/wide/latest/wide/struct.i32x16.html

Performs element-wise minimum, maximum, and clamping operations on i32x16 vectors.

```APIDOC
## Min/Max and Clamp Methods

### `min`

`pub fn min(self, rhs: Self) -> Self`

Returns a new vector where each element is the minimum of the corresponding elements in `self` and `rhs`.

### `max`

`pub fn max(self, rhs: Self) -> Self`

Returns a new vector where each element is the maximum of the corresponding elements in `self` and `rhs`.

### `clamp`

`pub fn clamp(self, min: Self, max: Self) -> Self`

Restricts each element to a certain interval defined by `min` and `max`. If `min > max`, the result is unspecified. Consider manually checking for that case.
```

--------------------------------

### Get Slice Reference to i8x16 Array

Source: https://docs.rs/wide/latest/wide/struct.i8x16.html

Provides a reference to the underlying array of 16 i8 elements within an i8x16 vector.

```rust
pub fn as_array(&self) -> &[i8; 16]
```

--------------------------------

### Get Mutable Slice of Array

Source: https://docs.rs/wide/latest/wide/struct.i64x8.html

Provides a mutable reference to the underlying array of 8 i64 integers within the i64x8 vector.

```rust
pub fn as_mut_array(&mut self) -> &mut [i64; 8]
```
Tokens:
Raw