Struct std::simd::Simd

#[repr(simd)]
pub struct Simd<T, const LANES: usize>(_)
 where
    T: SimdElement,
    LaneCount<LANES>: SupportedLaneCount;

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

A SIMD vector of LANES elements of type T.

Implementations

impl<T, const LANES: usize> Simd<T, LANES> where
    T: SimdElement + BitAnd<T, Output = T>,
    Simd<T, LANES>: BitAnd<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as BitAnd<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

pub fn horizontal_and(self) -> T

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

Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.

impl<T, const LANES: usize> Simd<T, LANES> where
    T: SimdElement + BitOr<T, Output = T>,
    Simd<T, LANES>: BitOr<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as BitOr<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

pub fn horizontal_or(self) -> T

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

Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.

impl<T, const LANES: usize> Simd<T, LANES> where
    T: SimdElement + BitXor<T, Output = T>,
    Simd<T, LANES>: BitXor<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as BitXor<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

pub fn horizontal_xor(self) -> T

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

Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.

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

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.

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.

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.

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.

Produces two vectors with lanes taken alternately from self and other.

The first result contains the first LANES / 2 lanes from self and other, alternating, starting with the first lane of self.

The second result contains the last LANES / 2 lanes from self and other, alternating, starting with the lane LANES / 2 from the start of self.

#![feature(portable_simd)]
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]);

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.

#![feature(portable_simd)]
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]);

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

pub fn lanes_eq(
    self,
    other: Simd<T, LANES>
) -> Mask<<T as SimdElement>::Mask, LANES>

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

Test if each lane is equal to the corresponding lane in other.

pub fn lanes_ne(
    self,
    other: Simd<T, LANES>
) -> Mask<<T as SimdElement>::Mask, LANES>

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

Test if each lane is not equal to the corresponding lane in other.

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

pub fn lanes_lt(
    self,
    other: Simd<T, LANES>
) -> Mask<<T as SimdElement>::Mask, LANES>

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

Test if each lane is less than the corresponding lane in other.

pub fn lanes_gt(
    self,
    other: Simd<T, LANES>
) -> Mask<<T as SimdElement>::Mask, LANES>

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

Test if each lane is greater than the corresponding lane in other.

pub fn lanes_le(
    self,
    other: Simd<T, LANES>
) -> Mask<<T as SimdElement>::Mask, LANES>

🔬 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.

pub fn lanes_ge(
    self,
    other: Simd<T, LANES>
) -> Mask<<T as SimdElement>::Mask, LANES>

🔬 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.

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

pub const LANES: usize

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

Number of lanes in this vector.

pub const fn lanes(&self) -> usize

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

Get the number of lanes in this vector.

pub const fn splat(value: T) -> Simd<T, LANES>

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

Construct a SIMD vector by setting all lanes to the given value.

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

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

Returns an array reference containing the entire SIMD vector.

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

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

Returns a mutable array reference containing the entire SIMD vector.

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

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

Converts an array to a SIMD vector.

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

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

Converts a SIMD vector to an array.

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

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

Converts a slice to a SIMD vector containing slice[..LANES]

Panics

from_slice will panic if the slice’s len is less than the vector’s Simd::LANES.

pub fn cast<U>(self) -> Simd<U, LANES> where
    U: SimdElement, 

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

Performs lanewise conversion of a SIMD vector’s elements to another SIMD-valid type. This follows the semantics of Rust’s as conversion for casting integers to unsigned integers (interpreting as the other type, so -1 to MAX), and from floats to integers (truncating, or saturating at the limits) for each lane, or vice versa.

Examples

let floats: Simd<f32, 4> = Simd::from_array([1.9, -4.5, f32::INFINITY, f32::NAN]);
let ints = floats.cast::<i32>();
assert_eq!(ints, Simd::from_array([1, -4, i32::MAX, 0]));

// Formally equivalent, but `Simd::cast` can optimize better.
assert_eq!(ints, Simd::from_array(floats.to_array().map(|x| x as i32)));

// The float conversion does not round-trip.
let floats_again = ints.cast();
assert_ne!(floats, floats_again);
assert_eq!(floats_again, Simd::from_array([1.0, -4.0, 2147483647.0, 0.0]));

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

🔬 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 lane 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]);
let alt = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::gather_or(&vec, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));

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

🔬 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 lane is set to the default value for the type.

Examples

let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);

let result = Simd::gather_or_default(&vec, idxs); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));

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

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

Reads from potentially discontiguous indices in slice to construct a SIMD vector. The mask enables all true lanes and disables all false lanes. If an index is disabled or is out-of-bounds, the lane 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]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.

let result = Simd::gather_select(&vec, enable, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));

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

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

Reads from potentially discontiguous indices in slice to construct a SIMD vector. The mask enables all true lanes and disables all false lanes. If an index is disabled, the lane is selected from the or vector.

Safety

Calling this function with an enabled 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]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Note the final mask lane.
// If this mask was used to gather, it would be unsound. Let's fix that.
let enable = enable & idxs.lanes_lt(Simd::splat(vec.len()));

// We have masked the OOB lane, 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]));

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

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

Writes the values in a SIMD vector to potentially discontiguous indices in slice. If two lanes in the scattered vector would write to the same index only the last lane 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]);
let vals = Simd::from_array([-27, 82, -41, 124]);

vals.scatter(&mut vec, idxs); // index 0 receives two writes.
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);

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

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

Writes the values in a SIMD vector to multiple potentially discontiguous indices in slice. The mask enables all true lanes and disables all false lanes. If an enabled index is out-of-bounds, the lane is not written. If two enabled lanes in the scattered vector would write to the same index, only the last lane 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]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.

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

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

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

Writes the values in a SIMD vector to multiple potentially discontiguous indices in slice. The mask enables all true lanes and disables all false lanes. If two enabled lanes in the scattered vector would write to the same index, only the last lane 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]); // Note the mask of the last lane.
// If this mask was used to scatter, it would be unsound. Let's fix that.
let enable = enable & idxs.lanes_lt(Simd::splat(vec.len()));

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

impl<const LANES: usize> Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i8

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i8

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> i8

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i8

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i16

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i16

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> i16

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i16

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i32

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i32

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> i32

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i32

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> i64

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> i64

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> i64

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> i64

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> isize

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> isize

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> isize

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> isize

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

Horizontal minimum. Returns the minimum lane in the vector.

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

pub fn horizontal_sum(self) -> u8

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u8

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> u8

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u8

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> u16

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u16

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> u16

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u16

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> u32

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u32

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> u32

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u32

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> u64

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> u64

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> u64

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> u64

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

Horizontal minimum. Returns the minimum lane in the vector.

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

pub fn horizontal_sum(self) -> usize

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

Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.

pub fn horizontal_product(self) -> usize

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

Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.

pub fn horizontal_max(self) -> usize

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

Horizontal maximum. Returns the maximum lane in the vector.

pub fn horizontal_min(self) -> usize

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

Horizontal minimum. Returns the minimum lane in the vector.

impl<const LANES: usize> Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> f32

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

Horizontal add. Returns the sum of the lanes of the vector.

pub fn horizontal_product(self) -> f32

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

Horizontal multiply. Returns the product of the lanes of the vector.

pub fn horizontal_max(self) -> f32

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

Horizontal maximum. Returns the maximum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

pub fn horizontal_min(self) -> f32

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

Horizontal minimum. Returns the minimum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

impl<const LANES: usize> Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn horizontal_sum(self) -> f64

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

Horizontal add. Returns the sum of the lanes of the vector.

pub fn horizontal_product(self) -> f64

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

Horizontal multiply. Returns the product of the lanes of the vector.

pub fn horizontal_max(self) -> f64

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

Horizontal maximum. Returns the maximum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

pub fn horizontal_min(self) -> f64

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

Horizontal minimum. Returns the minimum lane in the vector.

Returns values based on equality, so a vector containing both 0. and -0. may return either. This function will not return NaN unless all lanes are NaN.

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

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

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

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

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

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<u16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<u32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<u64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

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

pub fn saturating_add(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

pub fn saturating_sub(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

impl<const LANES: usize> Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Simd<i8, LANES>

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

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Simd<i8, LANES>

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

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Simd<i8, LANES>

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

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Simd<i16, LANES>

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

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Simd<i16, LANES>

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

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Simd<i16, LANES>

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

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Simd<i32, LANES>

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

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Simd<i32, LANES>

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

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Simd<i32, LANES>

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

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Simd<i64, LANES>

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

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Simd<i64, LANES>

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

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Simd<i64, LANES>

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

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

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

Lanewise saturating add.

Examples

let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

pub fn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>

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

Lanewise saturating subtract.

Examples

let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

pub fn abs(self) -> Simd<isize, LANES>

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

Lanewise absolute value, implemented in Rust. Every lane becomes its absolute value.

Examples

let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

pub fn saturating_abs(self) -> Simd<isize, LANES>

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

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

Examples

let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

pub fn saturating_neg(self) -> Simd<isize, LANES>

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

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

Examples

let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

impl<const LANES: usize> Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub unsafe fn to_int_unchecked(self) -> Simd<i32, LANES>

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

Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.

Safety

The value must:

• Not be NaN
• Not be infinite
• Be representable in the return type, after truncating off its fractional part

pub fn round_from_int(value: Simd<i32, LANES>) -> Simd<f32, LANES>

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

Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.

impl<const LANES: usize> Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub unsafe fn to_int_unchecked(self) -> Simd<i64, LANES>

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

Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.

Safety

The value must:

• Not be NaN
• Not be infinite
• Be representable in the return type, after truncating off its fractional part

pub fn round_from_int(value: Simd<i64, LANES>) -> Simd<f64, LANES>

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

Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.

impl<const LANES: usize> Simd<f32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn to_bits(self) -> Simd<u32, LANES>

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

Raw transmutation to an unsigned integer vector type with the same size and number of lanes.

pub fn from_bits(bits: Simd<u32, LANES>) -> Simd<f32, LANES>

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

Raw transmutation from an unsigned integer vector type with the same size and number of lanes.

pub fn abs(self) -> Simd<f32, LANES>

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

Produces a vector where every lane has the absolute value of the equivalently-indexed lane in self.

pub fn recip(self) -> Simd<f32, LANES>

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

Takes the reciprocal (inverse) of each lane, 1/x.

pub fn to_degrees(self) -> Simd<f32, LANES>

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

Converts each lane from radians to degrees.

pub fn to_radians(self) -> Simd<f32, LANES>

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

Converts each lane from degrees to radians.

pub fn is_sign_positive(self) -> Mask<i32, LANES>

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

Returns true for each lane if it has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

pub fn is_sign_negative(self) -> Mask<i32, LANES>

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

Returns true for each lane if it has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

pub fn is_nan(self) -> Mask<i32, LANES>

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

Returns true for each lane if its value is NaN.

pub fn is_infinite(self) -> Mask<i32, LANES>

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

Returns true for each lane if its value is positive infinity or negative infinity.

pub fn is_finite(self) -> Mask<i32, LANES>

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

Returns true for each lane if its value is neither infinite nor NaN.

pub fn is_subnormal(self) -> Mask<i32, LANES>

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

Returns true for each lane if its value is subnormal.

pub fn is_normal(self) -> Mask<i32, LANES>

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

Returns true for each lane if its value is neither zero, infinite, subnormal, nor NaN.

pub fn signum(self) -> Simd<f32, LANES>

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

Replaces each lane with a number that represents its sign.

• 1.0 if the number is positive, +0.0, or INFINITY
• -1.0 if the number is negative, -0.0, or NEG_INFINITY
• NAN if the number is NAN

pub fn copysign(self, sign: Simd<f32, LANES>) -> Simd<f32, LANES>

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

Returns each lane with the magnitude of self and the sign of sign.

If any lane is a NAN, then a NAN with the sign of sign is returned.

pub fn min(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>

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

Returns the minimum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn max(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>

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

Returns the maximum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn clamp(
    self,
    min: Simd<f32, LANES>,
    max: Simd<f32, LANES>
) -> Simd<f32, LANES>

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

Restrict each lane to a certain interval unless it is NaN.

For each lane in self, returns the corresponding lane in max if the lane is greater than max, and the corresponding lane in min if the lane is less than min. Otherwise returns the lane in self.

impl<const LANES: usize> Simd<f64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn to_bits(self) -> Simd<u64, LANES>

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

Raw transmutation to an unsigned integer vector type with the same size and number of lanes.

pub fn from_bits(bits: Simd<u64, LANES>) -> Simd<f64, LANES>

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

Raw transmutation from an unsigned integer vector type with the same size and number of lanes.

pub fn abs(self) -> Simd<f64, LANES>

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

Produces a vector where every lane has the absolute value of the equivalently-indexed lane in self.

pub fn recip(self) -> Simd<f64, LANES>

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

Takes the reciprocal (inverse) of each lane, 1/x.

pub fn to_degrees(self) -> Simd<f64, LANES>

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

Converts each lane from radians to degrees.

pub fn to_radians(self) -> Simd<f64, LANES>

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

Converts each lane from degrees to radians.

pub fn is_sign_positive(self) -> Mask<i64, LANES>

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

Returns true for each lane if it has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

pub fn is_sign_negative(self) -> Mask<i64, LANES>

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

Returns true for each lane if it has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

pub fn is_nan(self) -> Mask<i64, LANES>

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

Returns true for each lane if its value is NaN.

pub fn is_infinite(self) -> Mask<i64, LANES>

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

Returns true for each lane if its value is positive infinity or negative infinity.

pub fn is_finite(self) -> Mask<i64, LANES>

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

Returns true for each lane if its value is neither infinite nor NaN.

pub fn is_subnormal(self) -> Mask<i64, LANES>

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

Returns true for each lane if its value is subnormal.

pub fn is_normal(self) -> Mask<i64, LANES>

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

Returns true for each lane if its value is neither zero, infinite, subnormal, nor NaN.

pub fn signum(self) -> Simd<f64, LANES>

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

Replaces each lane with a number that represents its sign.

• 1.0 if the number is positive, +0.0, or INFINITY
• -1.0 if the number is negative, -0.0, or NEG_INFINITY
• NAN if the number is NAN

pub fn copysign(self, sign: Simd<f64, LANES>) -> Simd<f64, LANES>

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

Returns each lane with the magnitude of self and the sign of sign.

If any lane is a NAN, then a NAN with the sign of sign is returned.

pub fn min(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>

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

Returns the minimum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn max(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>

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

Returns the maximum of each lane.

If one of the values is NAN, then the other value is returned.

pub fn clamp(
    self,
    min: Simd<f64, LANES>,
    max: Simd<f64, LANES>
) -> Simd<f64, LANES>

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

Restrict each lane to a certain interval unless it is NaN.

For each lane in self, returns the corresponding lane in max if the lane is greater than max, and the corresponding lane in min if the lane is less than min. Otherwise returns the lane in self.

impl<const LANES: usize> Simd<isize, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<isize, LANES>

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

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<isize, LANES>

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

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Simd<isize, LANES>

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

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i16, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i16, LANES>

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

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i16, LANES>

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

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Simd<i16, LANES>

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

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i32, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i32, LANES>

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

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i32, LANES>

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

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Simd<i32, LANES>

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

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i64, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i64, LANES>

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

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i64, LANES>

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

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Simd<i64, LANES>

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

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

impl<const LANES: usize> Simd<i8, LANES> where
    LaneCount<LANES>: SupportedLaneCount, 

pub fn is_positive(self) -> Mask<i8, LANES>

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

Returns true for each positive lane and false if it is zero or negative.

pub fn is_negative(self) -> Mask<i8, LANES>

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

Returns true for each negative lane and false if it is zero or positive.

pub fn signum(self) -> Simd<i8, LANES>

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

Returns numbers representing the sign of each lane.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

Trait Implementations

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

type Output = Simd<T, LANES>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'lhs, 'rhs, T, const LANES: usize> Add<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: Add<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as Add<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<f32, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<f64, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<i16, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<i32, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<i64, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<i8, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<isize, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<u16, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<u32, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Simd<u64, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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.

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

Performs the + operation.

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

type Output = Simd<usize, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

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

pub fn as_mut(&mut self) -> &mut [T; LANES]

Performs the conversion.

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

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

Performs the conversion.

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

pub fn as_ref(&self) -> &[T; LANES]

Performs the conversion.

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

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

Performs the conversion.

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

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

Formats the value using the given formatter.

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

type Output = Simd<T, LANES>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'lhs, 'rhs, T, const LANES: usize> BitAnd<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: BitAnd<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as BitAnd<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<i16, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<i32, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<i64, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<i8, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<isize, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<u16, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<u32, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Simd<u64, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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.

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

Performs the & operation.

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

type Output = Simd<usize, N>

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Performs the &= operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'lhs, 'rhs, T, const LANES: usize> BitOr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: BitOr<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as BitOr<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<i16, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<i32, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<i64, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<i8, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<isize, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<u16, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<u32, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Simd<u64, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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.

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

Performs the | operation.

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

type Output = Simd<usize, N>

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Performs the |= operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'lhs, 'rhs, T, const LANES: usize> BitXor<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: BitXor<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as BitXor<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<i16, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<i32, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<i64, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<i8, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<isize, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<u16, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<u32, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Simd<u64, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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.

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

Performs the ^ operation.

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

type Output = Simd<usize, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Performs the ^= operation.

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

pub fn clone(&self) -> Simd<T, LANES>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

pub fn default() -> Simd<T, LANES>

Returns the “default value” for a type.

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

type Output = Simd<T, LANES>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'lhs, 'rhs, T, const LANES: usize> Div<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: Div<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as Div<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<f32, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<f64, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<i16, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<i32, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<i64, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<i8, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<isize, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<u16, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<u32, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Simd<u64, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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.

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

Performs the / operation.

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

type Output = Simd<usize, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

Performs the /= operation.

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

pub fn from(array: [T; LANES]) -> Simd<T, LANES>

Performs the conversion.

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

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

Performs the conversion.

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

pub fn from(vector: Simd<T, LANES>) -> [T; LANES]

Performs the conversion.

impl From<Simd<f32, 16_usize>> for __m512

pub fn from(value: Simd<f32, 16_usize>) -> __m512

Performs the conversion.

impl From<Simd<f32, 4_usize>> for __m128

pub fn from(value: Simd<f32, 4_usize>) -> __m128

Performs the conversion.

impl From<Simd<f32, 8_usize>> for __m256

pub fn from(value: Simd<f32, 8_usize>) -> __m256

Performs the conversion.

impl From<Simd<f64, 2_usize>> for __m128d

pub fn from(value: Simd<f64, 2_usize>) -> __m128d

Performs the conversion.

impl From<Simd<f64, 4_usize>> for __m256d

pub fn from(value: Simd<f64, 4_usize>) -> __m256d

Performs the conversion.

impl From<Simd<f64, 8_usize>> for __m512d

pub fn from(value: Simd<f64, 8_usize>) -> __m512d

Performs the conversion.

impl From<Simd<i16, 16_usize>> for __m256i

pub fn from(value: Simd<i16, 16_usize>) -> __m256i

Performs the conversion.

impl From<Simd<i16, 32_usize>> for __m512i

pub fn from(value: Simd<i16, 32_usize>) -> __m512i

Performs the conversion.

impl From<Simd<i16, 8_usize>> for __m128i

pub fn from(value: Simd<i16, 8_usize>) -> __m128i

Performs the conversion.

impl From<Simd<i32, 16_usize>> for __m512i

pub fn from(value: Simd<i32, 16_usize>) -> __m512i

Performs the conversion.

impl From<Simd<i32, 4_usize>> for __m128i

pub fn from(value: Simd<i32, 4_usize>) -> __m128i

Performs the conversion.

impl From<Simd<i32, 8_usize>> for __m256i

pub fn from(value: Simd<i32, 8_usize>) -> __m256i

Performs the conversion.

impl From<Simd<i64, 2_usize>> for __m128i

pub fn from(value: Simd<i64, 2_usize>) -> __m128i

Performs the conversion.

impl From<Simd<i64, 4_usize>> for __m256i

pub fn from(value: Simd<i64, 4_usize>) -> __m256i

Performs the conversion.

impl From<Simd<i64, 8_usize>> for __m512i

pub fn from(value: Simd<i64, 8_usize>) -> __m512i

Performs the conversion.

impl From<Simd<i8, 16_usize>> for __m128i

pub fn from(value: Simd<i8, 16_usize>) -> __m128i

Performs the conversion.

impl From<Simd<i8, 32_usize>> for __m256i

pub fn from(value: Simd<i8, 32_usize>) -> __m256i

Performs the conversion.

impl From<Simd<i8, 64_usize>> for __m512i

pub fn from(value: Simd<i8, 64_usize>) -> __m512i

Performs the conversion.

impl From<Simd<isize, 2_usize>> for __m128i

pub fn from(value: Simd<isize, 2_usize>) -> __m128i

Performs the conversion.

impl From<Simd<isize, 4_usize>> for __m256i

pub fn from(value: Simd<isize, 4_usize>) -> __m256i

Performs the conversion.

impl From<Simd<isize, 8_usize>> for __m512i

pub fn from(value: Simd<isize, 8_usize>) -> __m512i

Performs the conversion.

impl From<Simd<u16, 16_usize>> for __m256i

pub fn from(value: Simd<u16, 16_usize>) -> __m256i

Performs the conversion.

impl From<Simd<u16, 32_usize>> for __m512i

pub fn from(value: Simd<u16, 32_usize>) -> __m512i

Performs the conversion.

impl From<Simd<u16, 8_usize>> for __m128i

pub fn from(value: Simd<u16, 8_usize>) -> __m128i

Performs the conversion.

impl From<Simd<u32, 16_usize>> for __m512i

pub fn from(value: Simd<u32, 16_usize>) -> __m512i

Performs the conversion.

impl From<Simd<u32, 4_usize>> for __m128i

pub fn from(value: Simd<u32, 4_usize>) -> __m128i

Performs the conversion.

impl From<Simd<u32, 8_usize>> for __m256i

pub fn from(value: Simd<u32, 8_usize>) -> __m256i

Performs the conversion.

impl From<Simd<u64, 2_usize>> for __m128i

pub fn from(value: Simd<u64, 2_usize>) -> __m128i

Performs the conversion.

impl From<Simd<u64, 4_usize>> for __m256i

pub fn from(value: Simd<u64, 4_usize>) -> __m256i

Performs the conversion.

impl From<Simd<u64, 8_usize>> for __m512i

pub fn from(value: Simd<u64, 8_usize>) -> __m512i

Performs the conversion.

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

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

Performs the conversion.

impl From<Simd<u8, 32_usize>> for __m256i

pub fn from(value: Simd<u8, 32_usize>) -> __m256i

Performs the conversion.

impl From<Simd<u8, 64_usize>> for __m512i

pub fn from(value: Simd<u8, 64_usize>) -> __m512i

Performs the conversion.

impl From<Simd<usize, 2_usize>> for __m128i

pub fn from(value: Simd<usize, 2_usize>) -> __m128i

Performs the conversion.

impl From<Simd<usize, 4_usize>> for __m256i

pub fn from(value: Simd<usize, 4_usize>) -> __m256i

Performs the conversion.

impl From<Simd<usize, 8_usize>> for __m512i

pub fn from(value: Simd<usize, 8_usize>) -> __m512i

Performs the conversion.

impl From<__m128> for Simd<f32, 4_usize>

pub fn from(value: __m128) -> Simd<f32, 4_usize>

Performs the conversion.

impl From<__m128d> for Simd<f64, 2_usize>

pub fn from(value: __m128d) -> Simd<f64, 2_usize>

Performs the conversion.

impl From<__m128i> for Simd<isize, 2_usize>

pub fn from(value: __m128i) -> Simd<isize, 2_usize>

Performs the conversion.

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

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

Performs the conversion.

impl From<__m128i> for Simd<u64, 2_usize>

pub fn from(value: __m128i) -> Simd<u64, 2_usize>

Performs the conversion.

impl From<__m128i> for Simd<i32, 4_usize>

pub fn from(value: __m128i) -> Simd<i32, 4_usize>

Performs the conversion.

impl From<__m128i> for Simd<u16, 8_usize>

pub fn from(value: __m128i) -> Simd<u16, 8_usize>

Performs the conversion.

impl From<__m128i> for Simd<i8, 16_usize>

pub fn from(value: __m128i) -> Simd<i8, 16_usize>

Performs the conversion.

impl From<__m128i> for Simd<usize, 2_usize>

pub fn from(value: __m128i) -> Simd<usize, 2_usize>

Performs the conversion.

impl From<__m128i> for Simd<u32, 4_usize>

pub fn from(value: __m128i) -> Simd<u32, 4_usize>

Performs the conversion.

impl From<__m128i> for Simd<i64, 2_usize>

pub fn from(value: __m128i) -> Simd<i64, 2_usize>

Performs the conversion.

impl From<__m128i> for Simd<i16, 8_usize>

pub fn from(value: __m128i) -> Simd<i16, 8_usize>

Performs the conversion.

impl From<__m256> for Simd<f32, 8_usize>

pub fn from(value: __m256) -> Simd<f32, 8_usize>

Performs the conversion.

impl From<__m256d> for Simd<f64, 4_usize>

pub fn from(value: __m256d) -> Simd<f64, 4_usize>

Performs the conversion.

impl From<__m256i> for Simd<u32, 8_usize>

pub fn from(value: __m256i) -> Simd<u32, 8_usize>

Performs the conversion.

impl From<__m256i> for Simd<u64, 4_usize>

pub fn from(value: __m256i) -> Simd<u64, 4_usize>

Performs the conversion.

impl From<__m256i> for Simd<usize, 4_usize>

pub fn from(value: __m256i) -> Simd<usize, 4_usize>

Performs the conversion.

impl From<__m256i> for Simd<i16, 16_usize>

pub fn from(value: __m256i) -> Simd<i16, 16_usize>

Performs the conversion.

impl From<__m256i> for Simd<i32, 8_usize>

pub fn from(value: __m256i) -> Simd<i32, 8_usize>

Performs the conversion.

impl From<__m256i> for Simd<isize, 4_usize>

pub fn from(value: __m256i) -> Simd<isize, 4_usize>

Performs the conversion.

impl From<__m256i> for Simd<u16, 16_usize>

pub fn from(value: __m256i) -> Simd<u16, 16_usize>

Performs the conversion.

impl From<__m256i> for Simd<i64, 4_usize>

pub fn from(value: __m256i) -> Simd<i64, 4_usize>

Performs the conversion.

impl From<__m256i> for Simd<u8, 32_usize>

pub fn from(value: __m256i) -> Simd<u8, 32_usize>

Performs the conversion.

impl From<__m256i> for Simd<i8, 32_usize>

pub fn from(value: __m256i) -> Simd<i8, 32_usize>

Performs the conversion.

impl From<__m512> for Simd<f32, 16_usize>

pub fn from(value: __m512) -> Simd<f32, 16_usize>

Performs the conversion.

impl From<__m512d> for Simd<f64, 8_usize>

pub fn from(value: __m512d) -> Simd<f64, 8_usize>

Performs the conversion.

impl From<__m512i> for Simd<isize, 8_usize>

pub fn from(value: __m512i) -> Simd<isize, 8_usize>

Performs the conversion.

impl From<__m512i> for Simd<i64, 8_usize>

pub fn from(value: __m512i) -> Simd<i64, 8_usize>

Performs the conversion.

impl From<__m512i> for Simd<u32, 16_usize>

pub fn from(value: __m512i) -> Simd<u32, 16_usize>

Performs the conversion.

impl From<__m512i> for Simd<i32, 16_usize>

pub fn from(value: __m512i) -> Simd<i32, 16_usize>

Performs the conversion.

impl From<__m512i> for Simd<u8, 64_usize>

pub fn from(value: __m512i) -> Simd<u8, 64_usize>

Performs the conversion.

impl From<__m512i> for Simd<u16, 32_usize>

pub fn from(value: __m512i) -> Simd<u16, 32_usize>

Performs the conversion.

impl From<__m512i> for Simd<i16, 32_usize>

pub fn from(value: __m512i) -> Simd<i16, 32_usize>

Performs the conversion.

impl From<__m512i> for Simd<i8, 64_usize>

pub fn from(value: __m512i) -> Simd<i8, 64_usize>

Performs the conversion.

impl From<__m512i> for Simd<usize, 8_usize>

pub fn from(value: __m512i) -> Simd<usize, 8_usize>

Performs the conversion.

impl From<__m512i> for Simd<u64, 8_usize>

pub fn from(value: __m512i) -> Simd<u64, 8_usize>

Performs the conversion.

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

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

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

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

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

Performs the mutable indexing (container[index]) operation.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

type Output = Simd<T, LANES>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'lhs, 'rhs, T, const LANES: usize> Mul<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: Mul<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as Mul<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<f32, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<f64, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<i16, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<i32, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<i64, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<i8, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<isize, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<u16, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<u32, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Simd<u64, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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.

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

Performs the * operation.

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

type Output = Simd<usize, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

impl<const LANES: usize> Neg for Simd<f64, LANES> where
    f64: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f64, LANES>

The resulting type after applying the - operator.

pub fn neg(self) -> <Simd<f64, LANES> as Neg>::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<f32, LANES> where
    f32: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<f32, LANES>

The resulting type after applying the - operator.

pub fn neg(self) -> <Simd<f32, LANES> as Neg>::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<i8, LANES> where
    i8: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i8, LANES>

The resulting type after applying the - operator.

pub fn neg(self) -> <Simd<i8, LANES> as Neg>::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<isize, LANES> where
    isize: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<isize, LANES>

The resulting type after applying the - operator.

pub fn neg(self) -> <Simd<isize, LANES> as Neg>::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<i64, LANES> where
    i64: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i64, LANES>

The resulting type after applying the - operator.

pub fn neg(self) -> <Simd<i64, LANES> as Neg>::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<i32, LANES> where
    i32: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i32, LANES>

The resulting type after applying the - operator.

pub fn neg(self) -> <Simd<i32, LANES> as Neg>::Output

Performs the unary - operation.

impl<const LANES: usize> Neg for Simd<i16, LANES> where
    i16: SimdElement,
    LaneCount<LANES>: SupportedLaneCount, 

type Output = Simd<i16, LANES>

The resulting type after applying the - operator.

pub fn neg(self) -> <Simd<i16, LANES> as Neg>::Output

Performs the unary - operation.

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

type Output = Simd<i64, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<i64, LANES> as Not>::Output

Performs the unary ! operation.

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

type Output = Simd<i8, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<i8, LANES> as Not>::Output

Performs the unary ! operation.

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

type Output = Simd<u32, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<u32, LANES> as Not>::Output

Performs the unary ! operation.

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

type Output = Simd<i32, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<i32, LANES> as Not>::Output

Performs the unary ! operation.

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.

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

Performs the unary ! operation.

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

type Output = Simd<u64, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<u64, LANES> as Not>::Output

Performs the unary ! operation.

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

type Output = Simd<i16, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<i16, LANES> as Not>::Output

Performs the unary ! operation.

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

type Output = Simd<usize, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<usize, LANES> as Not>::Output

Performs the unary ! operation.

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

type Output = Simd<u16, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<u16, LANES> as Not>::Output

Performs the unary ! operation.

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

type Output = Simd<isize, LANES>

The resulting type after applying the ! operator.

pub fn not(self) -> <Simd<isize, LANES> as Not>::Output

Performs the unary ! operation.

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

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

Formats the value using the given formatter.

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

pub fn cmp(&self, other: &Simd<T, LANES>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

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

pub fn eq(&self, other: &Simd<T, LANES>) -> bool

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

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

This method tests for !=.

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

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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.

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

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

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

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

type Output = Simd<T, LANES>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'lhs, 'rhs, T, const LANES: usize> Rem<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: Rem<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as Rem<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<f32, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<f64, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<i16, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<i32, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<i64, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<i8, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<isize, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<u16, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<u32, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Simd<u64, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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.

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

Performs the % operation.

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

type Output = Simd<usize, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

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

Performs the %= operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'lhs, 'rhs, T, const LANES: usize> Shl<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: Shl<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as Shl<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<i16, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<i32, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<i64, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<i8, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<isize, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<u16, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<u32, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Simd<u64, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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.

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

Performs the << operation.

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

type Output = Simd<usize, N>

The resulting type after applying the << operator.

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

Performs the << operation.

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

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

Performs the <<= operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'lhs, 'rhs, T, const LANES: usize> Shr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: Shr<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as Shr<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<i16, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<i32, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<i64, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<i8, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<isize, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<u16, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<u32, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Simd<u64, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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.

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

Performs the >> operation.

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

type Output = Simd<usize, N>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

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

Performs the >>= operation.

impl<const N: usize> StdFloat for Simd<f32, N> where
    LaneCount<N>: SupportedLaneCount, 

fn fract(self) -> Self

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

Returns the floating point’s fractional value, with its integer part removed.

fn mul_add(self, a: Self, b: Self) -> Self

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

Fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add.

fn sqrt(self) -> Self

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

Produces a vector where every lane has the square root value of the equivalently-indexed lane in self

fn ceil(self) -> Self

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

Returns the smallest integer greater than or equal to each lane.

fn floor(self) -> Self

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

Returns the largest integer value less than or equal to each lane.

fn round(self) -> Self

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

Rounds to the nearest integer value. Ties round toward zero.

fn trunc(self) -> Self

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

Returns the floating point’s integer value, with its fractional part removed.

impl<const N: usize> StdFloat for Simd<f64, N> where
    LaneCount<N>: SupportedLaneCount, 

fn fract(self) -> Self

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

Returns the floating point’s fractional value, with its integer part removed.

fn mul_add(self, a: Self, b: Self) -> Self

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

Fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add.

fn sqrt(self) -> Self

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

Produces a vector where every lane has the square root value of the equivalently-indexed lane in self

fn ceil(self) -> Self

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

Returns the smallest integer greater than or equal to each lane.

fn floor(self) -> Self

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

Returns the largest integer value less than or equal to each lane.

fn round(self) -> Self

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

Rounds to the nearest integer value. Ties round toward zero.

fn trunc(self) -> Self

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

Returns the floating point’s integer value, with its fractional part removed.

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

type Output = Simd<T, LANES>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'lhs, 'rhs, T, const LANES: usize> Sub<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES> where
    T: SimdElement,
    Simd<T, LANES>: Sub<Simd<T, LANES>>,
    LaneCount<LANES>: SupportedLaneCount,
    <Simd<T, LANES> as Sub<Simd<T, LANES>>>::Output == Simd<T, LANES>, 

type Output = Simd<T, LANES>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<T, LANES>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<f32, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<f64, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<i16, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<i32, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<i64, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<i8, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<isize, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<u16, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<u32, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Simd<u64, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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.

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

Performs the - operation.

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

type Output = Simd<usize, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub 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.

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

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

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

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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