Struct core::simd::Simd

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

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

A SIMD vector with the shape of [T; N] but the operations of T.

Simd<T, N> supports the operators (+, *, etc.) that T does in “elementwise” fashion. These take the element at each index from the left-hand side and right-hand side, perform the operation, then return the result in the same index in a vector of equal size. However, Simd differs from normal iteration and normal arrays:

• Simd<T, N> executes N operations in a single step with no breaks
• Simd<T, N> can have an alignment greater than T, for better mechanical sympathy

By always imposing these constraints on Simd, it is easier to compile elementwise operations into machine instructions that can themselves be executed in parallel.

let a: [i32; 4] = [-2, 0, 2, 4];
let b = [10, 9, 8, 7];
let sum = array::from_fn(|i| a[i] + b[i]);
let prod = array::from_fn(|i| a[i] * b[i]);

// `Simd<T, N>` implements `From<[T; N]>`
let (v, w) = (Simd::from(a), Simd::from(b));
// Which means arrays implement `Into<Simd<T, N>>`.
assert_eq!(v + w, sum.into());
assert_eq!(v * w, prod.into());

Simd with integer elements treats operators as wrapping, as if T was Wrapping<T>. Thus, Simd does not implement wrapping_add, because that is the default behavior. This means there is no warning on overflows, even in “debug” builds. For most applications where Simd is appropriate, it is “not a bug” to wrap, and even “debug builds” are unlikely to tolerate the loss of performance. You may want to consider using explicitly checked arithmetic if such is required. Division by zero on integers still causes a panic, so you may want to consider using f32 or f64 if that is unacceptable.

Layout

Simd<T, N> has a layout similar to [T; N] (identical “shapes”), with a greater alignment. [T; N] is aligned to T, but Simd<T, N> will have an alignment based on both T and N. Thus it is sound to transmute Simd<T, N> to [T; N] and should optimize to “zero cost”, but the reverse transmutation may require a copy the compiler cannot simply elide.

ABI “Features”

Due to Rust’s safety guarantees, Simd<T, N> is currently passed and returned via memory, not SIMD registers, except as an optimization. Using #[inline] on functions that accept Simd<T, N> or return it is recommended, at the cost of code generation time, as inlining SIMD-using functions can omit a large function prolog or epilog and thus improve both speed and code size. The need for this may be corrected in the future.

Using #[inline(always)] still requires additional care.

Safe SIMD with Unsafe Rust

Operations with Simd are typically safe, but there are many reasons to want to combine SIMD with unsafe code. Care must be taken to respect differences between Simd and other types it may be transformed into or derived from. In particular, the layout of Simd<T, N> may be similar to [T; N], and may allow some transmutations, but references to [T; N] are not interchangeable with those to Simd<T, N>. Thus, when using unsafe Rust to read and write Simd<T, N> through raw pointers, it is a good idea to first try with read_unaligned and write_unaligned. This is because:

• read and write require full alignment (in this case, Simd<T, N>’s alignment)
• Simd<T, N> is often read from or written to [T] and other types aligned to T
• combining these actions violates the unsafe contract and explodes the program into a puff of undefined behavior
• the compiler can implicitly adjust layouts to make unaligned reads or writes fully aligned if it sees the optimization
• most contemporary processors with “aligned” and “unaligned” read and write instructions exhibit no performance difference if the “unaligned” variant is aligned at runtime

Less obligations mean unaligned reads and writes are less likely to make the program unsound, and may be just as fast as stricter alternatives. When trying to guarantee alignment, [T]::as_simd is an option for converting [T] to [Simd<T, N>], and allows soundly operating on an aligned SIMD body, but it may cost more time when handling the scalar head and tail. If these are not enough, it is most ideal to design data structures to be already aligned to mem::align_of::<Simd<T, N>>() before using unsafe Rust to read or write. Other ways to compensate for these facts, like materializing Simd to or from an array first, are handled by safe methods like Simd::from_array and Simd::from_slice.

Tuple Fields

0: [T; N]

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

Implementations

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

pub fn reverse(self) -> Self

🔬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) -> Self

🔬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) -> Self

🔬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: Self) -> (Self, Self)

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

Interleave two vectors.

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

The reverse of this operation is Simd::deinterleave.

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

pub fn deinterleave(self, other: Self) -> (Self, Self)

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

Deinterleave two vectors.

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

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

The reverse of this operation is Simd::interleave.

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

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

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

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

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

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

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

pub const LANES: usize = N

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

Number of elements in this vector.

pub const fn lanes(&self) -> usize

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

Returns the number of elements in this SIMD vector.

Examples

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

pub fn splat(value: T) -> Self

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

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

Examples

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

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

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

Returns an array reference containing the entire SIMD vector.

Examples

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

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

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

Returns a mutable array reference containing the entire SIMD vector.

const unsafe fn load(ptr: *const [T; N]) -> Self

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

Load a vector from an array of T.

This function is necessary since repr(simd) has padding for non-power-of-2 vectors (at the time of writing). With padding, read_unaligned will read past the end of an array of N elements.

Safety

Reading ptr must be safe, as if by <*const [T; N]>::read_unaligned.

const unsafe fn store(self, ptr: *mut [T; N])

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

Store a vector to an array of T.

See load as to why this function is necessary.

Safety

Writing to ptr must be safe, as if by <*mut [T; N]>::write_unaligned.

pub const fn from_array(array: [T; N]) -> Self

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

Converts an array to a SIMD vector.

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

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

Converts a SIMD vector to an array.

pub const fn from_slice(slice: &[T]) -> Self

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

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

Panics

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

Example

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

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

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

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

Panics

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

Example

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

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

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

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

Examples

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

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

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

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

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

Examples

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

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

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

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

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

Examples

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

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

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

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

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

Safety

Calling this function with an 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]); // Includes an out-of-bounds index
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Includes a masked element
// If this mask was used to gather, it would be unsound. Let's fix that.
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));

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

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

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

Read elementwise from pointers into a SIMD vector.

Safety

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

Example

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

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

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

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

Safety

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

Example

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

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

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

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

Examples

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

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

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

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

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

Examples

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

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

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

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

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

Safety

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

Examples

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

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

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

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

Write pointers elementwise into a SIMD vector.

Safety

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

Example

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

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

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

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

Safety

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

Example

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

Trait Implementations

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the + operator.

fn add(self, rhs: Simd<T, LANES>) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::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.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

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

fn add_assign(&mut self, rhs: U)

Performs the += operation.

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

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

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

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

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

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

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

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

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

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

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

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

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the & operator.

fn bitand(self, rhs: Simd<T, LANES>) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::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.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

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

fn bitand_assign(&mut self, rhs: U)

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the | operator.

fn bitor(self, rhs: Simd<T, LANES>) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::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.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

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

fn bitor_assign(&mut self, rhs: U)

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Simd<T, LANES>) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::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.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

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

fn bitxor_assign(&mut self, rhs: U)

Performs the ^= operation.

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

fn clone(&self) -> Self

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 LaneCount<LANES>: SupportedLaneCount, T: SimdElement + Debug,

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

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

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

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

fn default() -> Self

Returns the “default value” for a type.

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the / operator.

fn div(self, rhs: Simd<T, LANES>) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::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.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

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

fn div_assign(&mut self, rhs: U)

Performs the /= operation.

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

fn assert_receiver_is_total_eq(&self)

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

fn from(array: [T; N]) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(vector: Simd<T, N>) -> Self

Converts to this type from the input type.

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

fn from(value: f32x16) -> __m512

Converts to this type from the input type.

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

fn from(value: f32x4) -> __m128

Converts to this type from the input type.

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

fn from(value: f32x8) -> __m256

Converts to this type from the input type.

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

fn from(value: f64x2) -> __m128d

Converts to this type from the input type.

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

fn from(value: f64x4) -> __m256d

Converts to this type from the input type.

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

fn from(value: f64x8) -> __m512d

Converts to this type from the input type.

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

fn from(value: i16x16) -> __m256i

Converts to this type from the input type.

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

fn from(value: i16x32) -> __m512i

Converts to this type from the input type.

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

fn from(value: i16x8) -> __m128i

Converts to this type from the input type.

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

fn from(value: i32x16) -> __m512i

Converts to this type from the input type.

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

fn from(value: i32x4) -> __m128i

Converts to this type from the input type.

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

fn from(value: i32x8) -> __m256i

Converts to this type from the input type.

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

fn from(value: i64x2) -> __m128i

Converts to this type from the input type.

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

fn from(value: i64x4) -> __m256i

Converts to this type from the input type.

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

fn from(value: i64x8) -> __m512i

Converts to this type from the input type.

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

fn from(value: i8x16) -> __m128i

Converts to this type from the input type.

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

fn from(value: i8x32) -> __m256i

Converts to this type from the input type.

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

fn from(value: i8x64) -> __m512i

Converts to this type from the input type.

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

fn from(value: isizex2) -> __m128i

Converts to this type from the input type.

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

fn from(value: isizex4) -> __m256i

Converts to this type from the input type.

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

fn from(value: isizex8) -> __m512i

Converts to this type from the input type.

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

fn from(value: u16x16) -> __m256i

Converts to this type from the input type.

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

fn from(value: u16x32) -> __m512i

Converts to this type from the input type.

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

fn from(value: u16x8) -> __m128i

Converts to this type from the input type.

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

fn from(value: u32x16) -> __m512i

Converts to this type from the input type.

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

fn from(value: u32x4) -> __m128i

Converts to this type from the input type.

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

fn from(value: u32x8) -> __m256i

Converts to this type from the input type.

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

fn from(value: u64x2) -> __m128i

Converts to this type from the input type.

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

fn from(value: u64x4) -> __m256i

Converts to this type from the input type.

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

fn from(value: u64x8) -> __m512i

Converts to this type from the input type.

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

fn from(value: u8x16) -> __m128i

Converts to this type from the input type.

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

fn from(value: u8x32) -> __m256i

Converts to this type from the input type.

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

fn from(value: u8x64) -> __m512i

Converts to this type from the input type.

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

fn from(value: usizex2) -> __m128i

Converts to this type from the input type.

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

fn from(value: usizex4) -> __m256i

Converts to this type from the input type.

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

fn from(value: usizex8) -> __m512i

Converts to this type from the input type.

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

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

Feeds this value into the given Hasher.

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

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, LaneCount<LANES>: SupportedLaneCount, I: SliceIndex<[T]>,

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

The returned type after indexing.

fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

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

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) 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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the * operator.

fn mul(self, rhs: Simd<T, LANES>) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::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.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

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

fn mul_assign(&mut self, rhs: U)

Performs the *= 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.

fn neg(self) -> Self::Output

Performs the unary - 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.

fn neg(self) -> Self::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.

fn neg(self) -> Self::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.

fn neg(self) -> Self::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.

fn neg(self) -> Self::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.

fn neg(self) -> Self::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.

fn neg(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::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.

fn not(self) -> Self::Output

Performs the unary ! operation.

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

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

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

fn eq(&self, other: &Self) -> bool

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

fn ne(&self, other: &Self) -> bool

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

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

fn partial_cmp(&self, other: &Self) -> 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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the % operator.

fn rem(self, rhs: Simd<T, LANES>) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::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.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

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

fn rem_assign(&mut self, rhs: U)

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the << operator.

fn shl(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the << operator.

fn shl(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the << operator.

fn shl(self, rhs: Simd<T, LANES>) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::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.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

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

fn shl_assign(&mut self, rhs: U)

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the >> operator.

fn shr(self, rhs: Simd<T, LANES>) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::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.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

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

fn shr_assign(&mut self, rhs: U)

Performs the >>= operation.

impl<T, const LANES: usize> SimdConstPtr for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Usize = Simd<usize, LANES>

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

Vector of usize with the same number of lanes.

type Isize = Simd<isize, LANES>

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

Vector of isize with the same number of lanes.

type CastPtr<U> = Simd<*const U, LANES>

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

Vector of const pointers with the same number of lanes.

type MutPtr = Simd<*mut T, LANES>

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

Vector of mutable pointers to the same type.

type Mask = Mask<isize, LANES>

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

Mask type used for manipulating this SIMD vector type.

fn is_null(self) -> Self::Mask

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

Returns true for each lane that is null.

fn cast<U>(self) -> Self::CastPtr<U>

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

Casts to a pointer of another type.

fn cast_mut(self) -> Self::MutPtr

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

Changes constness without changing the type.

fn addr(self) -> Self::Usize

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

Gets the “address” portion of the pointer.

fn with_addr(self, addr: Self::Usize) -> Self

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

Creates a new pointer with the given address.

fn expose_addr(self) -> Self::Usize

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

Gets the “address” portion of the pointer, and “exposes” the provenance part for future use in Self::from_exposed_addr.

fn from_exposed_addr(addr: Self::Usize) -> Self

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

Convert an address back to a pointer, picking up a previously “exposed” provenance.

fn wrapping_offset(self, count: Self::Isize) -> Self

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

Calculates the offset from a pointer using wrapping arithmetic.

fn wrapping_add(self, count: Self::Usize) -> Self

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

Calculates the offset from a pointer using wrapping arithmetic.

fn wrapping_sub(self, count: Self::Usize) -> Self

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

Calculates the offset from a pointer using wrapping arithmetic.

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

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

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

Mask type used for manipulating this SIMD vector type.

type Scalar = f32

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

Scalar type contained by this SIMD vector type.

type Bits = Simd<u32, LANES>

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

Bit representation of this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

unsafe fn to_int_unchecked<I: SimdCast>(self) -> Self::Cast<I>where Self::Scalar: FloatToInt<I>,

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

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.

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

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

fn abs(self) -> Self

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

fn recip(self) -> Self

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

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

fn to_degrees(self) -> Self

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

Converts each lane from radians to degrees.

fn to_radians(self) -> Self

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

Converts each lane from degrees to radians.

fn is_sign_positive(self) -> Self::Mask

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

fn is_sign_negative(self) -> Self::Mask

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

fn is_nan(self) -> Self::Mask

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

Returns true for each lane if its value is NaN.

fn is_infinite(self) -> Self::Mask

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

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

fn is_finite(self) -> Self::Mask

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

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

fn is_subnormal(self) -> Self::Mask

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

Returns true for each lane if its value is subnormal.

fn is_normal(self) -> Self::Mask

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

fn signum(self) -> Self

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

Replaces each lane with a number that represents its sign.

fn copysign(self, sign: Self) -> Self

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

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

fn simd_min(self, other: Self) -> Self

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

Returns the minimum of each lane.

fn simd_max(self, other: Self) -> Self

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

Returns the maximum of each lane.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

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

fn reduce_sum(self) -> Self::Scalar

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

Returns the sum of the lanes of the vector.

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

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

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

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

Mask type used for manipulating this SIMD vector type.

type Scalar = f64

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

Scalar type contained by this SIMD vector type.

type Bits = Simd<u64, LANES>

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

Bit representation of this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

unsafe fn to_int_unchecked<I: SimdCast>(self) -> Self::Cast<I>where Self::Scalar: FloatToInt<I>,

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

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.

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

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

fn abs(self) -> Self

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

fn recip(self) -> Self

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

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

fn to_degrees(self) -> Self

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

Converts each lane from radians to degrees.

fn to_radians(self) -> Self

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

Converts each lane from degrees to radians.

fn is_sign_positive(self) -> Self::Mask

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

fn is_sign_negative(self) -> Self::Mask

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

fn is_nan(self) -> Self::Mask

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

Returns true for each lane if its value is NaN.

fn is_infinite(self) -> Self::Mask

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

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

fn is_finite(self) -> Self::Mask

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

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

fn is_subnormal(self) -> Self::Mask

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

Returns true for each lane if its value is subnormal.

fn is_normal(self) -> Self::Mask

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

fn signum(self) -> Self

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

Replaces each lane with a number that represents its sign.

fn copysign(self, sign: Self) -> Self

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

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

fn simd_min(self, other: Self) -> Self

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

Returns the minimum of each lane.

fn simd_max(self, other: Self) -> Self

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

Returns the maximum of each lane.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

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

fn reduce_sum(self) -> Self::Scalar

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

Returns the sum of the lanes of the vector.

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

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

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

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

Mask type used for manipulating this SIMD vector type.

type Scalar = i16

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn abs(self) -> Self

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

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

fn saturating_abs(self) -> Self

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

fn saturating_neg(self) -> Self

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

fn is_positive(self) -> Self::Mask

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

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

fn is_negative(self) -> Self::Mask

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

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

fn signum(self) -> Self

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

Returns numbers representing the sign of each lane.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

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

Mask type used for manipulating this SIMD vector type.

type Scalar = i32

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn abs(self) -> Self

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

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

fn saturating_abs(self) -> Self

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

fn saturating_neg(self) -> Self

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

fn is_positive(self) -> Self::Mask

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

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

fn is_negative(self) -> Self::Mask

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

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

fn signum(self) -> Self

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

Returns numbers representing the sign of each lane.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

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

Mask type used for manipulating this SIMD vector type.

type Scalar = i64

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn abs(self) -> Self

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

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

fn saturating_abs(self) -> Self

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

fn saturating_neg(self) -> Self

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

fn is_positive(self) -> Self::Mask

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

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

fn is_negative(self) -> Self::Mask

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

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

fn signum(self) -> Self

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

Returns numbers representing the sign of each lane.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Mask = Mask<<i8 as SimdElement>::Mask, LANES>

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

Mask type used for manipulating this SIMD vector type.

type Scalar = i8

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn abs(self) -> Self

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

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

fn saturating_abs(self) -> Self

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

fn saturating_neg(self) -> Self

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

fn is_positive(self) -> Self::Mask

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

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

fn is_negative(self) -> Self::Mask

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

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

fn signum(self) -> Self

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

Returns numbers representing the sign of each lane.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Mask = Mask<<isize as SimdElement>::Mask, LANES>

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

Mask type used for manipulating this SIMD vector type.

type Scalar = isize

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn abs(self) -> Self

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

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

fn saturating_abs(self) -> Self

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

fn saturating_neg(self) -> Self

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

fn is_positive(self) -> Self::Mask

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

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

fn is_negative(self) -> Self::Mask

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

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

fn signum(self) -> Self

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

Returns numbers representing the sign of each lane.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

impl<T, const LANES: usize> SimdMutPtr for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Usize = Simd<usize, LANES>

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

Vector of usize with the same number of lanes.

type Isize = Simd<isize, LANES>

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

Vector of isize with the same number of lanes.

type CastPtr<U> = Simd<*mut U, LANES>

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

Vector of const pointers with the same number of lanes.

type ConstPtr = Simd<*const T, LANES>

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

Vector of constant pointers to the same type.

type Mask = Mask<isize, LANES>

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

Mask type used for manipulating this SIMD vector type.

fn is_null(self) -> Self::Mask

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

Returns true for each lane that is null.

fn cast<U>(self) -> Self::CastPtr<U>

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

Casts to a pointer of another type.

fn cast_const(self) -> Self::ConstPtr

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

Changes constness without changing the type.

fn addr(self) -> Self::Usize

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

Gets the “address” portion of the pointer.

fn with_addr(self, addr: Self::Usize) -> Self

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

Creates a new pointer with the given address.

fn expose_addr(self) -> Self::Usize

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

Gets the “address” portion of the pointer, and “exposes” the provenance part for future use in Self::from_exposed_addr.

fn from_exposed_addr(addr: Self::Usize) -> Self

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

Convert an address back to a pointer, picking up a previously “exposed” provenance.

fn wrapping_offset(self, count: Self::Isize) -> Self

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

Calculates the offset from a pointer using wrapping arithmetic.

fn wrapping_add(self, count: Self::Usize) -> Self

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

Calculates the offset from a pointer using wrapping arithmetic.

fn wrapping_sub(self, count: Self::Usize) -> Self

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

Calculates the offset from a pointer using wrapping arithmetic.

impl<T, const LANES: usize> SimdOrd for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

impl<T, const LANES: usize> SimdOrd for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

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

fn simd_max(self, other: Self) -> Self

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

Returns the lane-wise maximum with other.

fn simd_min(self, other: Self) -> Self

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

Returns the lane-wise minimum with other.

fn simd_clamp(self, min: Self, max: Self) -> Self

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

Restrict each lane to a certain interval.

impl<T, const LANES: usize> SimdPartialEq for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<isize, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

impl<T, const LANES: usize> SimdPartialEq for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

type Mask = Mask<isize, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<f32 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<f64 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<i16 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<i32 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<i64 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<i8 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<isize as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<u16 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<u32 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<u64 as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

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

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

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

type Mask = Mask<<usize as SimdElement>::Mask, LANES>

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

The mask type returned by each comparison.

fn simd_eq(self, other: Self) -> Self::Mask

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

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

fn simd_ne(self, other: Self) -> Self::Mask

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

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

impl<T, const LANES: usize> SimdPartialOrd for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

impl<T, const LANES: usize> SimdPartialOrd for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

fn simd_lt(self, other: Self) -> Self::Mask

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

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

fn simd_le(self, other: Self) -> Self::Mask

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

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

fn simd_gt(self, other: Self) -> Self::Mask

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

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

fn simd_ge(self, other: Self) -> Self::Mask

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

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

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

type Scalar = u16

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Scalar = u32

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Scalar = u64

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Scalar = u8

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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

type Scalar = usize

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

Scalar type contained by this SIMD vector type.

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

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

A SIMD vector with a different element type.

fn cast<T: SimdCast>(self) -> Self::Cast<T>

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

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

fn saturating_add(self, second: Self) -> Self

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

Lanewise saturating add.

fn saturating_sub(self, second: Self) -> Self

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

Lanewise saturating subtract.

fn reduce_sum(self) -> Self::Scalar

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

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

fn reduce_product(self) -> Self::Scalar

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

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

fn reduce_max(self) -> Self::Scalar

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

Returns the maximum lane in the vector.

fn reduce_min(self) -> Self::Scalar

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

Returns the minimum lane in the vector.

fn reduce_and(self) -> Self::Scalar

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

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

fn reduce_or(self) -> Self::Scalar

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

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

fn reduce_xor(self) -> Self::Scalar

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

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

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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: &'rhs Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: &Simd<T, LANES>) -> Self::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>, Output = Simd<T, LANES>>, LaneCount<LANES>: SupportedLaneCount,

type Output = Simd<T, LANES>

The resulting type after applying the - operator.

fn sub(self, rhs: Simd<T, LANES>) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::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.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

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

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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

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

type Error = TryFromSliceError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Error = TryFromSliceError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

impl<T, const LANES: usize> Sealed for Simd<*const T, LANES>where LaneCount<LANES>: SupportedLaneCount,

impl<T, const LANES: usize> Sealed for Simd<*mut T, LANES>where LaneCount<LANES>: SupportedLaneCount,

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

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

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

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

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

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

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

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

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

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

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

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