u8x16 in std::simd::prelude - Rust
Description: A SIMD vector with 16 elements of type `u8`.

# Type Alias std::simd::prelude::u8x16

source ·

    pub type u8x16 = Simd<u8, 16>;

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Expand description

A SIMD vector with 16 elements of type `u8`.

## Aliased Type§

    struct u8x16(/* private fields */);

## Implementations§

source§

### impl<T, const LANES: usize> Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source

#### pub fn reverse(self) -> Simd<T, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Reverse the order of the lanes in the vector.

source

#### pub fn rotate_lanes_left<const OFFSET: usize>(self) -> Simd<T, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Rotates the vector such that the first `OFFSET` elements of the slice move to the end while the last `LANES - OFFSET` elements move to the front. After calling `rotate_lanes_left`, the element previously in lane `OFFSET` will become the first element in the slice.

source

#### pub fn rotate_lanes_right<const OFFSET: usize>(self) -> Simd<T, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Rotates the vector such that the first `LANES - OFFSET` elements of the vector move to the end while the last `OFFSET` elements move to the front. After calling `rotate_lanes_right`, the element previously at index `LANES - OFFSET` will become the first element in the slice.

source

#### pub fn interleave( self, other: Simd<T, LANES> ) -> (Simd<T, LANES>, Simd<T, LANES>)

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Interleave two vectors.

The resulting vectors contain lanes taken alternatively from `self` and `other`, first filling the first result, and then the second.

The reverse of this operation is `Simd::deinterleave`.

    let a = Simd::from_array([0, 1, 2, 3]);
    let b = Simd::from_array([4, 5, 6, 7]);
    let (x, y) = a.interleave(b);
    assert_eq!(x.to_array(), [0, 4, 1, 5]);
    assert_eq!(y.to_array(), [2, 6, 3, 7]);

Run
source

#### pub fn deinterleave( self, other: Simd<T, LANES> ) -> (Simd<T, LANES>, Simd<T, LANES>)

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Deinterleave two vectors.

The first result takes every other lane of `self` and then `other`, starting with the first lane.

The second result takes every other lane of `self` and then `other`, starting with the second lane.

The reverse of this operation is `Simd::interleave`.

    let a = Simd::from_array([0, 4, 1, 5]);
    let b = Simd::from_array([2, 6, 3, 7]);
    let (x, y) = a.deinterleave(b);
    assert_eq!(x.to_array(), [0, 1, 2, 3]);
    assert_eq!(y.to_array(), [4, 5, 6, 7]);

Run
source§

### impl<const N: usize> Simd<u8, N>where LaneCount<N>: SupportedLaneCount,

source

#### pub fn swizzle_dyn(self, idxs: Simd<u8, N>) -> Simd<u8, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Swizzle a vector of bytes according to the index vector. Indices within range select the appropriate byte. Indices “out of bounds” instead select 0.

Note that the current implementation is selected during build-time of the standard library, so `cargo build -Zbuild-std` may be necessary to unlock better performance, especially for larger vectors. A planned compiler improvement will enable using `#[target_feature]` instead.

source§

### impl<T, const N: usize> Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source

#### pub const LANES: usize = N

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Number of elements in this vector.

source

#### pub const fn lanes(&self) -> usize

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Returns the number of elements in this SIMD vector.

##### Examples

    let v = u32x4::splat(0);
    assert_eq!(v.lanes(), 4);

Run
source

#### pub fn splat(value: T) -> Simd<T, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Constructs a new SIMD vector with all elements set to the given value.

##### Examples

    let v = u32x4::splat(8);
    assert_eq!(v.as_array(), &[8, 8, 8, 8]);

Run
source

#### pub const fn as_array(&self) -> &[T; N]

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Returns an array reference containing the entire SIMD vector.

##### Examples

    let v: u64x4 = Simd::from_array([0, 1, 2, 3]);
    assert_eq!(v.as_array(), &[0, 1, 2, 3]);

Run
source

#### pub fn as_mut_array(&mut self) -> &mut [T; N]

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Returns a mutable array reference containing the entire SIMD vector.

source

#### pub const fn from_array(array: [T; N]) -> Simd<T, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Converts an array to a SIMD vector.

source

#### pub const fn to_array(self) -> [T; N]

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Converts a SIMD vector to an array.

source

#### pub const fn from_slice(slice: &[T]) -> Simd<T, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Converts a slice to a SIMD vector containing `slice[..N]`.

##### Panics

Panics if the slice’s length is less than the vector’s `Simd::N`.

##### Example

    let source = vec![1, 2, 3, 4, 5, 6];
    let v = u32x4::from_slice(&source);
    assert_eq!(v.as_array(), &[1, 2, 3, 4]);

Run
source

#### pub fn copy_to_slice(self, slice: &mut [T])

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Writes a SIMD vector to the first `N` elements of a slice.

##### Panics

Panics if the slice’s length is less than the vector’s `Simd::N`.

##### Example

    let mut dest = vec![0; 6];
    let v = u32x4::from_array([1, 2, 3, 4]);
    v.copy_to_slice(&mut dest);
    assert_eq!(&dest, &[1, 2, 3, 4, 0, 0]);

Run
source

#### pub fn gather_or( slice: &[T], idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Reads from potentially discontiguous indices in `slice` to construct a SIMD vector. If an index is out-of-bounds, the element is instead selected from the `or` vector.

##### Examples

    let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
    let idxs = Simd::from_array([9, 3, 0, 5]);  // Note the index that is out-of-bounds
    let alt = Simd::from_array([-5, -4, -3, -2]);

    let result = Simd::gather_or(&vec, idxs, alt);
    assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));

Run
source

#### pub fn gather_or_default(slice: &[T], idxs: Simd<usize, N>) -> Simd<T, N>where T: Default,

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Reads from indices in `slice` to construct a SIMD vector. If an index is out-of-bounds, the element is set to the default given by `T: Default`.

##### Examples

    let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
    let idxs = Simd::from_array([9, 3, 0, 5]);  // Note the index that is out-of-bounds

    let result = Simd::gather_or_default(&vec, idxs);
    assert_eq!(result, Simd::from_array([0, 13, 10, 15]));

Run
source

#### pub fn gather_select( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Reads from indices in `slice` to construct a SIMD vector. The mask `enable`s all `true` indices and disables all `false` indices. If an index is disabled or is out-of-bounds, the element is selected from the `or` vector.

##### Examples

    let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
    let idxs = Simd::from_array([9, 3, 0, 5]); // Includes an out-of-bounds index
    let alt = Simd::from_array([-5, -4, -3, -2]);
    let enable = Mask::from_array([true, true, true, false]); // Includes a masked element

    let result = Simd::gather_select(&vec, enable, idxs, alt);
    assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));

Run
source

#### pub unsafe fn gather_select_unchecked( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Reads from indices in `slice` to construct a SIMD vector. The mask `enable`s all `true` indices and disables all `false` indices. If an index is disabled, the element is selected from the `or` vector.

##### Safety

Calling this function with an `enable`d out-of-bounds index is undefined behavior even if the resulting value is not used.

##### Examples

    let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
    let idxs = Simd::from_array([9, 3, 0, 5]); // Includes an out-of-bounds index
    let alt = Simd::from_array([-5, -4, -3, -2]);
    let enable = Mask::from_array([true, true, true, false]); // Includes a masked element
    // If this mask was used to gather, it would be unsound. Let's fix that.
    let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));

    // The out-of-bounds index has been masked, so it's safe to gather now.
    let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };
    assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));

Run
source

#### pub unsafe fn gather_ptr(source: Simd<*const T, N>) -> Simd<T, N>where T: Default,

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Read elementwise from pointers into a SIMD vector.

##### Safety

Each read must satisfy the same conditions as `core::ptr::read`.

##### Example

    let values = [6, 2, 4, 9];
    let offsets = Simd::from_array([1, 0, 0, 3]);
    let source = Simd::splat(values.as_ptr()).wrapping_add(offsets);
    let gathered = unsafe { Simd::gather_ptr(source) };
    assert_eq!(gathered, Simd::from_array([2, 6, 6, 9]));

Run
source

#### pub unsafe fn gather_select_ptr( source: Simd<*const T, N>, enable: Mask<isize, N>, or: Simd<T, N> ) -> Simd<T, N>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Conditionally read elementwise from pointers into a SIMD vector. The mask `enable`s all `true` pointers and disables all `false` pointers. If a pointer is disabled, the element is selected from the `or` vector, and no read is performed.

##### Safety

Enabled elements must satisfy the same conditions as `core::ptr::read`.

##### Example

    let values = [6, 2, 4, 9];
    let enable = Mask::from_array([true, true, false, true]);
    let offsets = Simd::from_array([1, 0, 0, 3]);
    let source = Simd::splat(values.as_ptr()).wrapping_add(offsets);
    let gathered = unsafe { Simd::gather_select_ptr(source, enable, Simd::splat(0)) };
    assert_eq!(gathered, Simd::from_array([2, 6, 0, 9]));

Run
source

#### pub fn scatter(self, slice: &mut [T], idxs: Simd<usize, N>)

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Writes the values in a SIMD vector to potentially discontiguous indices in `slice`. If an index is out-of-bounds, the write is suppressed without panicking. If two elements in the scattered vector would write to the same index only the last element is guaranteed to actually be written.

##### Examples

    let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
    let idxs = Simd::from_array([9, 3, 0, 0]); // Note the duplicate index.
    let vals = Simd::from_array([-27, 82, -41, 124]);

    vals.scatter(&mut vec, idxs); // two logical writes means the last wins.
    assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);

Run
source

#### pub fn scatter_select( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N> )

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Writes values from a SIMD vector to multiple potentially discontiguous indices in `slice`. The mask `enable`s all `true` indices and disables all `false` indices. If an enabled index is out-of-bounds, the write is suppressed without panicking. If two enabled elements in the scattered vector would write to the same index, only the last element is guaranteed to actually be written.

##### Examples

    let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
    let idxs = Simd::from_array([9, 3, 0, 0]); // Includes an out-of-bounds index
    let vals = Simd::from_array([-27, 82, -41, 124]);
    let enable = Mask::from_array([true, true, true, false]); // Includes a masked element

    vals.scatter_select(&mut vec, enable, idxs); // The last write is masked, thus omitted.
    assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);

Run
source

#### pub unsafe fn scatter_select_unchecked( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N> )

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Writes values from a SIMD vector to multiple potentially discontiguous indices in `slice`. The mask `enable`s all `true` indices and disables all `false` indices. If two enabled elements in the scattered vector would write to the same index, only the last element is guaranteed to actually be written.

##### Safety

Calling this function with an enabled out-of-bounds index is undefined behavior, and may lead to memory corruption.

##### Examples

    let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
    let idxs = Simd::from_array([9, 3, 0, 0]);
    let vals = Simd::from_array([-27, 82, -41, 124]);
    let enable = Mask::from_array([true, true, true, false]); // Masks the final index
    // If this mask was used to scatter, it would be unsound. Let's fix that.
    let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));

    // We have masked the OOB index, so it's safe to scatter now.
    unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }
    // The second write to index 0 was masked, thus omitted.
    assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);

Run
source

#### pub unsafe fn scatter_ptr(self, dest: Simd<*mut T, N>)

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Write pointers elementwise into a SIMD vector.

##### Safety

Each write must satisfy the same conditions as `core::ptr::write`.

##### Example

    let mut values = [0; 4];
    let offset = Simd::from_array([3, 2, 1, 0]);
    let ptrs = Simd::splat(values.as_mut_ptr()).wrapping_add(offset);
    unsafe { Simd::from_array([6, 3, 5, 7]).scatter_ptr(ptrs); }
    assert_eq!(values, [7, 5, 3, 6]);

Run
source

#### pub unsafe fn scatter_select_ptr( self, dest: Simd<*mut T, N>, enable: Mask<isize, N> )

🔬This is a nightly-only experimental API. (`portable_simd` #86656)

Conditionally write pointers elementwise into a SIMD vector. The mask `enable`s all `true` pointers and disables all `false` pointers. If a pointer is disabled, the write to its pointee is skipped.

##### Safety

Enabled pointers must satisfy the same conditions as `core::ptr::write`.

##### Example

    let mut values = [0; 4];
    let offset = Simd::from_array([3, 2, 1, 0]);
    let ptrs = Simd::splat(values.as_mut_ptr()).wrapping_add(offset);
    let enable = Mask::from_array([true, true, false, false]);
    unsafe { Simd::from_array([6, 3, 5, 7]).scatter_select_ptr(ptrs, enable); }
    assert_eq!(values, [0, 0, 3, 6]);

Run

## Trait Implementations§

source§

### impl<T, const LANES: usize> Add<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Add<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `+` operator.
source§

#### fn add( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as Add<&Simd<T, LANES>>>::Output

Performs the `+` operation. Read more
source§

### impl<const N: usize> Add<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `+` operator.
source§

#### fn add(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Add<Simd<u8, N>>>::Output

Performs the `+` operation. Read more
source§

### impl<T, U, const LANES: usize> AddAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Add<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn add_assign(&mut self, rhs: U)

Performs the `+=` operation. Read more
source§

### impl<T, const N: usize> AsMut<[T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

#### fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.
source§

### impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

#### fn as_mut(&mut self) -> &mut [T; N]

Converts this type into a mutable reference of the (usually inferred) input type.
source§

### impl<T, const N: usize> AsRef<[T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

#### fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.
source§

### impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

#### fn as_ref(&self) -> &[T; N]

Converts this type into a shared reference of the (usually inferred) input type.
source§

### impl<T, const LANES: usize> BitAnd<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as BitAnd<&Simd<T, LANES>>>::Output

Performs the `&` operation. Read more
source§

### impl<const N: usize> BitAnd<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `&` operator.
source§

#### fn bitand( self, rhs: Simd<u8, N> ) -> <Simd<u8, N> as BitAnd<Simd<u8, N>>>::Output

Performs the `&` operation. Read more
source§

### impl<T, U, const LANES: usize> BitAndAssign<U> for Simd<T, LANES>where Simd<T, LANES>: BitAnd<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn bitand_assign(&mut self, rhs: U)

Performs the `&=` operation. Read more
source§

### impl<T, const LANES: usize> BitOr<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: BitOr<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `|` operator.
source§

#### fn bitor( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as BitOr<&Simd<T, LANES>>>::Output

Performs the `|` operation. Read more
source§

### impl<const N: usize> BitOr<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as BitOr<Simd<u8, N>>>::Output

Performs the `|` operation. Read more
source§

### impl<T, U, const LANES: usize> BitOrAssign<U> for Simd<T, LANES>where Simd<T, LANES>: BitOr<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn bitor_assign(&mut self, rhs: U)

Performs the `|=` operation. Read more
source§

### impl<T, const LANES: usize> BitXor<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: BitXor<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as BitXor<&Simd<T, LANES>>>::Output

Performs the `^` operation. Read more
source§

### impl<const N: usize> BitXor<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `^` operator.
source§

#### fn bitxor( self, rhs: Simd<u8, N> ) -> <Simd<u8, N> as BitXor<Simd<u8, N>>>::Output

Performs the `^` operation. Read more
source§

### impl<T, U, const LANES: usize> BitXorAssign<U> for Simd<T, LANES>where Simd<T, LANES>: BitXor<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn bitxor_assign(&mut self, rhs: U)

Performs the `^=` operation. Read more
source§

### impl<T, const N: usize> Clone for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

#### fn clone(&self) -> Simd<T, N>

Returns a copy of the value. Read more
1.0.0 · source§

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more
source§

### impl<T, const LANES: usize> Debug for Simd<T, LANES>where LaneCount<LANES>: SupportedLaneCount, T: SimdElement + Debug,

source§

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

A `Simd<T, N>` has a debug format like the one for `[T]`:

    let floats = Simd::<f32, 4>::splat(-1.0);
    assert_eq!(format!("{:?}", [-1.0; 4]), format!("{:?}", floats));

Run
source§

### impl<T, const N: usize> Default for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Default,

source§

#### fn default() -> Simd<T, N>

Returns the “default value” for a type. Read more
source§

### impl<T, const LANES: usize> Div<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Div<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `/` operator.
source§

#### fn div( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as Div<&Simd<T, LANES>>>::Output

Performs the `/` operation. Read more
source§

### impl<const N: usize> Div<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `/` operator.
source§

#### fn div(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Div<Simd<u8, N>>>::Output

Performs the `/` operation. Read more
source§

### impl<T, U, const LANES: usize> DivAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Div<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn div_assign(&mut self, rhs: U)

Performs the `/=` operation. Read more
source§

### impl<T, const N: usize> From<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

#### fn from(array: [T; N]) -> Simd<T, N>

Converts to this type from the input type.
source§

### impl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES>where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn from(value: Mask<T, LANES>) -> Simd<T, LANES>

Converts to this type from the input type.
source§

### impl From<__m128i> for Simd<u8, 16>

source§

#### fn from(value: __m128i) -> Simd<u8, 16>

Converts to this type from the input type.
source§

### impl<T, const N: usize> Hash for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Hash,

source§

#### fn hash<H>(&self, state: &mut H)where H: Hasher,

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,

§

#### type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.
source§

#### fn index(&self, index: I) -> &<Simd<T, LANES> as Index<I>>::Output

Performs the indexing (`container[index]`) operation. Read more
source§

### impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES>where T: SimdElement, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,

source§

#### fn index_mut(&mut self, index: I) -> &mut <Simd<T, LANES> as Index<I>>::Output

Performs the mutable indexing (`container[index]`) operation. Read more
source§

### impl<T, const LANES: usize> Mul<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `*` operator.
source§

#### fn mul( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as Mul<&Simd<T, LANES>>>::Output

Performs the `*` operation. Read more
source§

### impl<const N: usize> Mul<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Mul<Simd<u8, N>>>::Output

Performs the `*` operation. Read more
source§

### impl<T, U, const LANES: usize> MulAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Mul<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn mul_assign(&mut self, rhs: U)

Performs the `*=` operation. Read more
source§

### impl<const LANES: usize> Not for Simd<u8, LANES>where u8: SimdElement, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<u8, LANES>

The resulting type after applying the `!` operator.
source§

#### fn not(self) -> <Simd<u8, LANES> as Not>::Output

Performs the unary `!` operation. Read more
source§

### impl<T, const N: usize> Ord for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Ord,

source§

#### fn cmp(&self, other: &Simd<T, N>) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more
source§

### impl<T, const N: usize> PartialEq<Simd<T, N>> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + PartialEq<T>,

source§

#### fn eq(&self, other: &Simd<T, N>) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`.
source§

#### fn ne(&self, other: &Simd<T, N>) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl<T, const N: usize> PartialOrd<Simd<T, N>> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + PartialOrd<T>,

source§

#### fn partial_cmp(&self, other: &Simd<T, N>) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · source§

#### fn lt(&self, other: &Rhs) -> bool

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · source§

#### fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · source§

#### fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · source§

#### fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
source§

### impl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

#### fn product<I>(iter: I) -> Simd<u8, LANES>where I: Iterator<Item = &'a Simd<u8, LANES>>,

Method which takes an iterator and generates `Self` from the elements by multiplying the items.
source§

### impl<const LANES: usize> Product<Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

#### fn product<I>(iter: I) -> Simd<u8, LANES>where I: Iterator<Item = Simd<u8, LANES>>,

Method which takes an iterator and generates `Self` from the elements by multiplying the items.
source§

### impl<T, const LANES: usize> Rem<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Rem<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `%` operator.
source§

#### fn rem( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as Rem<&Simd<T, LANES>>>::Output

Performs the `%` operation. Read more
source§

### impl<const N: usize> Rem<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `%` operator.
source§

#### fn rem(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Rem<Simd<u8, N>>>::Output

Performs the `%` operation. Read more
source§

### impl<T, U, const LANES: usize> RemAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Rem<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn rem_assign(&mut self, rhs: U)

Performs the `%=` operation. Read more
source§

### impl<T, const LANES: usize> Shl<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Shl<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `<<` operator.
source§

#### fn shl( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as Shl<&Simd<T, LANES>>>::Output

Performs the `<<` operation. Read more
source§

### impl<const N: usize> Shl<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `<<` operator.
source§

#### fn shl(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Shl<Simd<u8, N>>>::Output

Performs the `<<` operation. Read more
source§

### impl<T, U, const LANES: usize> ShlAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Shl<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn shl_assign(&mut self, rhs: U)

Performs the `<<=` operation. Read more
source§

### impl<T, const LANES: usize> Shr<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `>>` operator.
source§

#### fn shr( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as Shr<&Simd<T, LANES>>>::Output

Performs the `>>` operation. Read more
source§

### impl<const N: usize> Shr<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `>>` operator.
source§

#### fn shr(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Shr<Simd<u8, N>>>::Output

Performs the `>>` operation. Read more
source§

### impl<T, U, const LANES: usize> ShrAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Shr<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn shr_assign(&mut self, rhs: U)

Performs the `>>=` operation. Read more
source§

### impl<const LANES: usize> SimdOrd for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

#### fn simd_max(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the lane-wise maximum with `other`.
source§

#### fn simd_min(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the lane-wise minimum with `other`.
source§

#### fn simd_clamp( self, min: Simd<u8, LANES>, max: Simd<u8, LANES> ) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Restrict each lane to a certain interval. Read more
source§

### impl<const LANES: usize> SimdPartialEq for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

#### type Mask = Mask<<u8 as SimdElement>::Mask, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
The mask type returned by each comparison.
source§

#### fn simd_eq( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Test if each lane is equal to the corresponding lane in `other`.
source§

#### fn simd_ne( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Test if each lane is equal to the corresponding lane in `other`.
source§

### impl<const LANES: usize> SimdPartialOrd for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

#### fn simd_lt( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Test if each lane is less than the corresponding lane in `other`.
source§

#### fn simd_le( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Test if each lane is less than or equal to the corresponding lane in `other`.
source§

#### fn simd_gt( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Test if each lane is greater than the corresponding lane in `other`.
source§

#### fn simd_ge( self, other: Simd<u8, LANES> ) -> <Simd<u8, LANES> as SimdPartialEq>::Mask

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Test if each lane is greater than or equal to the corresponding lane in `other`.
source§

### impl<const LANES: usize> SimdUint for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

§

#### type Scalar = u8

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Scalar type contained by this SIMD vector type.
§

#### type Cast<T: SimdElement> = Simd<T, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
A SIMD vector with a different element type.
source§

#### fn cast<T>(self) -> <Simd<u8, LANES> as SimdUint>::Cast<T>where T: SimdCast,

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Performs elementwise conversion of this vector’s elements to another SIMD-valid type. Read more
source§

#### fn saturating_add(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Lanewise saturating add. Read more
source§

#### fn saturating_sub(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Lanewise saturating subtract. Read more
source§

#### fn reduce_sum(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the sum of the lanes of the vector, with wrapping addition.
source§

#### fn reduce_product(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the product of the lanes of the vector, with wrapping multiplication.
source§

#### fn reduce_max(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the maximum lane in the vector.
source§

#### fn reduce_min(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the minimum lane in the vector.
source§

#### fn reduce_and(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the cumulative bitwise “and” across the lanes of the vector.
source§

#### fn reduce_or(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the cumulative bitwise “or” across the lanes of the vector.
source§

#### fn reduce_xor(self) -> <Simd<u8, LANES> as SimdUint>::Scalar

🔬This is a nightly-only experimental API. (`portable_simd` #86656)
Returns the cumulative bitwise “xor” across the lanes of the vector.
source§

### impl<T, const LANES: usize> Sub<&Simd<T, LANES>> for Simd<T, LANES>where T: SimdElement, Simd<T, LANES>: Sub<Simd<T, LANES>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

§

#### type Output = Simd<T, LANES>

The resulting type after applying the `-` operator.
source§

#### fn sub( self, rhs: &Simd<T, LANES> ) -> <Simd<T, LANES> as Sub<&Simd<T, LANES>>>::Output

Performs the `-` operation. Read more
source§

### impl<const N: usize> Sub<Simd<u8, N>> for Simd<u8, N>where u8: SimdElement, LaneCount<N>: SupportedLaneCount,

§

#### type Output = Simd<u8, N>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, rhs: Simd<u8, N>) -> <Simd<u8, N> as Sub<Simd<u8, N>>>::Output

Performs the `-` operation. Read more
source§

### impl<T, U, const LANES: usize> SubAssign<U> for Simd<T, LANES>where Simd<T, LANES>: Sub<U, Output = Simd<T, LANES>>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

source§

#### fn sub_assign(&mut self, rhs: U)

Performs the `-=` operation. Read more
source§

### impl<'a, const LANES: usize> Sum<&'a Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

#### fn sum<I>(iter: I) -> Simd<u8, LANES>where I: Iterator<Item = &'a Simd<u8, LANES>>,

Method which takes an iterator and generates `Self` from the elements by “summing up” the items.
source§

### impl<const LANES: usize> Sum<Simd<u8, LANES>> for Simd<u8, LANES>where LaneCount<LANES>: SupportedLaneCount,

source§

#### fn sum<I>(iter: I) -> Simd<u8, LANES>where I: Iterator<Item = Simd<u8, LANES>>,

Method which takes an iterator and generates `Self` from the elements by “summing up” the items.
source§

### impl<T, const N: usize> TryFrom<&[T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

§

#### type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

#### fn try_from(slice: &[T]) -> Result<Simd<T, N>, TryFromSliceError>

Performs the conversion.
source§

### impl<T, const N: usize> TryFrom<&mut [T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

§

#### type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

#### fn try_from(slice: &mut [T]) -> Result<Simd<T, N>, TryFromSliceError>

Performs the conversion.
source§

### impl<T, const N: usize> Copy for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

source§

### impl<T, const N: usize> Eq for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement + Eq,