Struct Simd

#[repr(simd, packed(1))]
pub struct Simd<T, const N: usize>(pub(in ::core_simd::vector) [T; N])
where
    T: SimdElement,;

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:

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

# #![feature(portable_simd)]
# use core::simd::{Simd};
# use core::array;
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.

N cannot be 0 and may be at most 64. This limit may be increased in the future.

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:

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

Fields

0: [T; N]

Implementations

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

fn reverse(self) -> Self

Reverse the order of the elements in the vector.

fn rotate_elements_left<const OFFSET: usize>(self) -> Self

Rotates the vector such that the first OFFSET elements of the slice move to the end while the last self.len() - OFFSET elements move to the front. After calling rotate_elements_left, the element previously at index OFFSET will become the first element in the slice.

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd::Simd;
# #[cfg(not(feature = "as_crate"))] use core::simd::Simd;
let a = Simd::from_array([0, 1, 2, 3]);
let x = a.rotate_elements_left::<3>();
assert_eq!(x.to_array(), [3, 0, 1, 2]);

let y = a.rotate_elements_left::<7>();
assert_eq!(y.to_array(), [3, 0, 1, 2]);

fn rotate_elements_right<const OFFSET: usize>(self) -> Self

Rotates the vector such that the first self.len() - OFFSET elements of the vector move to the end while the last OFFSET elements move to the front. After calling rotate_elements_right, the element previously at index self.len() - OFFSET will become the first element in the slice.

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd::Simd;
# #[cfg(not(feature = "as_crate"))] use core::simd::Simd;
let a = Simd::from_array([0, 1, 2, 3]);
let x = a.rotate_elements_right::<3>();
assert_eq!(x.to_array(), [1, 2, 3, 0]);

let y = a.rotate_elements_right::<7>();
assert_eq!(y.to_array(), [1, 2, 3, 0]);

fn shift_elements_left<const OFFSET: usize>(self, padding: T) -> Self

Shifts the vector elements to the left by OFFSET, filling in with padding from the right.

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd::Simd;
# #[cfg(not(feature = "as_crate"))] use core::simd::Simd;
let a = Simd::from_array([0, 1, 2, 3]);
let x = a.shift_elements_left::<3>(255);
assert_eq!(x.to_array(), [3, 255, 255, 255]);

let y = a.shift_elements_left::<7>(255);
assert_eq!(y.to_array(), [255, 255, 255, 255]);

fn shift_elements_right<const OFFSET: usize>(self, padding: T) -> Self

Shifts the vector elements to the right by OFFSET, filling in with padding from the left.

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd::Simd;
# #[cfg(not(feature = "as_crate"))] use core::simd::Simd;
let a = Simd::from_array([0, 1, 2, 3]);
let x = a.shift_elements_right::<3>(255);
assert_eq!(x.to_array(), [255, 255, 255, 0]);

let y = a.shift_elements_right::<7>(255);
assert_eq!(y.to_array(), [255, 255, 255, 255]);

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

Interleave two vectors.

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

The reverse of this operation is Simd::deinterleave.

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

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

Deinterleave two vectors.

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

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

The reverse of this operation is Simd::interleave.

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::Simd;
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);

fn resize<const M: usize>(self, value: T) -> Simd<T, M>

Resize a vector.

If M > N, extends the length of a vector, setting the new elements to value. If M < N, truncates the vector to the first M elements.

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::u32x4;
let x = u32x4::from_array([0, 1, 2, 3]);
assert_eq!(x.resize::<8>(9).to_array(), [0, 1, 2, 3, 9, 9, 9, 9]);
assert_eq!(x.resize::<2>(9).to_array(), [0, 1]);

fn extract<const START: usize, const LEN: usize>(self) -> Simd<T, LEN>

Extract a vector from another vector.

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::u32x4;
let x = u32x4::from_array([0, 1, 2, 3]);
assert_eq!(x.extract::<1, 2>().to_array(), [1, 2]);

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

const LEN: usize = N;

Number of elements in this vector.

const fn len(&self) -> usize

Returns the number of elements in this SIMD vector.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::u32x4;
let v = u32x4::splat(0);
assert_eq!(v.len(), 4);

const fn splat(value: T) -> Self

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

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::u32x4;
let v = u32x4::splat(8);
assert_eq!(v.as_array(), &[8, 8, 8, 8]);

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

Returns an array reference containing the entire SIMD vector.

Examples

# #![feature(portable_simd)]
# use core::simd::{Simd, u64x4};
let v: u64x4 = Simd::from_array([0, 1, 2, 3]);
assert_eq!(v.as_array(), &[0, 1, 2, 3]);

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

Returns a mutable array reference containing the entire SIMD vector.

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

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

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

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.

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

Converts an array to a SIMD vector.

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

Converts a SIMD vector to an array.

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

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. Use load_or_default for an alternative that does not panic.

Example

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

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

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

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::u32x4;
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]);

fn load_or_default(slice: &[T]) -> Self
where
    T: Default,

Reads contiguous elements from slice. Elements are read so long as they're in-bounds for the slice. Otherwise, the default value for the element type is returned.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::Simd;
let vec: Vec<i32> = vec![10, 11];

let result = Simd::<i32, 4>::load_or_default(&vec);
assert_eq!(result, Simd::from_array([10, 11, 0, 0]));

fn load_or(slice: &[T], or: Self) -> Self

Reads contiguous elements from slice. Elements are read so long as they're in-bounds for the slice. Otherwise, the corresponding value from or is passed through.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::Simd;
let vec: Vec<i32> = vec![10, 11];
let or = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::load_or(&vec, or);
assert_eq!(result, Simd::from_array([10, 11, -3, -2]));

fn load_select_or_default(slice: &[T], enable: Mask<<T as SimdElement>::Mask, N>) -> Self
where
    T: Default,

Reads contiguous elements from slice. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled or out of bounds for the slice, that memory location is not accessed and the default value for the element type is returned.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, Mask};
let vec: Vec<i32> = vec![10, 11, 12];
let enable = Mask::from_array([false, true, true, true]);

let result = Simd::load_select_or_default(&vec, enable);
assert_eq!(result, Simd::from_array([0, 11, 12, 0]));

fn load_select(slice: &[T], enable: Mask<<T as SimdElement>::Mask, N>, or: Self) -> Self

Reads contiguous elements from slice. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled or out of bounds for the slice, that memory location is not accessed and the corresponding value from or is passed through.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, Mask};
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let enable = Mask::from_array([true, true, false, true]);
let or = Simd::from_array([-5, -4, -3, -2]);

let result = Simd::load_select(&vec, enable, or);
assert_eq!(result, Simd::from_array([10, 11, -3, 13]));

unsafe fn load_select_unchecked(slice: &[T], enable: Mask<<T as SimdElement>::Mask, N>, or: Self) -> Self

Reads contiguous elements from slice. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled, that memory location is not accessed and the corresponding value from or is passed through.

Safety

Enabled loads must not exceed the length of slice.

unsafe fn load_select_ptr(ptr: *const T, enable: Mask<<T as SimdElement>::Mask, N>, or: Self) -> Self

Reads contiguous elements starting at ptr. Each element is read from memory if its corresponding element in enable is true.

When the element is disabled, that memory location is not accessed and the corresponding value from or is passed through.

Safety

Enabled ptr elements must be safe to read as if by core::ptr::read.

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

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

# #![feature(portable_simd)]
# use core::simd::Simd;
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]));

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

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

# #![feature(portable_simd)]
# use core::simd::Simd;
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]));

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

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

# #![feature(portable_simd)]
# use core::simd::{Simd, Mask};
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]));

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

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

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, cmp::SimdPartialOrd, Mask};
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]));

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

Reads elementwise from pointers into a SIMD vector.

Safety

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

Example

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::prelude::*;
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]));

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

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

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::prelude::*;
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]));

fn store_select(self, slice: &mut [T], enable: Mask<<T as SimdElement>::Mask, N>)

Conditionally write contiguous elements to slice. The enable mask controls which elements are written, as long as they're in-bounds of the slice. If the element is disabled or out of bounds, no memory access to that location is made.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, Mask};
let mut arr = [0i32; 4];
let write = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([false, true, true, true]);

write.store_select(&mut arr[..3], enable);
assert_eq!(arr, [0, -4, -3, 0]);

unsafe fn store_select_unchecked(self, slice: &mut [T], enable: Mask<<T as SimdElement>::Mask, N>)

Conditionally write contiguous elements to slice. The enable mask controls which elements are written.

Safety

Every enabled element must be in bounds for the slice.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, Mask};
let mut arr = [0i32; 4];
let write = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([false, true, true, true]);

unsafe { write.store_select_unchecked(&mut arr, enable) };
assert_eq!(arr, [0, -4, -3, -2]);

unsafe fn store_select_ptr(self, ptr: *mut T, enable: Mask<<T as SimdElement>::Mask, N>)

Conditionally write contiguous elements starting from ptr. The enable mask controls which elements are written. When disabled, the memory location corresponding to that element is not accessed.

Safety

Memory addresses for element are calculated pointer::wrapping_offset and each enabled element must satisfy the same conditions as core::ptr::write.

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

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

# #![feature(portable_simd)]
# use core::simd::Simd;
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]);

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

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

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, Mask};
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]);

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

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

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, cmp::SimdPartialOrd, Mask};
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]);

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

Writes pointers elementwise into a SIMD vector.

Safety

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

Example

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Simd, ptr::SimdMutPtr};
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]);

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

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

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::{Mask, Simd, ptr::SimdMutPtr};
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]);

impl<const N: usize> Simd<u8, N>

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

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.

Trait Implementations

impl ToBytes for Simd<f32, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f32, 16>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f32, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f32, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f32, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f64, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f64, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f64, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<f64, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i16, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i16, 16>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i16, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i16, 32>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i16, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i16, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i32, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i32, 16>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i32, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i32, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i32, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i64, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i64, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i64, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i64, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i8, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i8, 16>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i8, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i8, 32>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i8, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i8, 64>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<i8, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<isize, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<isize, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<isize, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<isize, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u16, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u16, 16>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u16, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u16, 32>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u16, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u16, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u32, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u32, 16>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u32, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u32, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u32, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u64, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u64, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u64, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u64, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u8, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u8, 16>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u8, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u8, 32>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u8, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u8, 64>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<u8, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<usize, 1>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<usize, 2>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<usize, 4>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl ToBytes for Simd<usize, 8>

type Bytes = Simd<u8, { $size * $elems }>;
fn to_ne_bytes(self) -> Self::Bytes
fn to_be_bytes(self) -> Self::Bytes
fn to_le_bytes(self) -> Self::Bytes
fn from_ne_bytes(bytes: Self::Bytes) -> Self
fn from_be_bytes(bytes: Self::Bytes) -> Self
fn from_le_bytes(bytes: Self::Bytes) -> Self

impl<'a, const N: usize> Product<&'a Simd<f32, N>> for Simd<f32, N>

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

impl<'a, const N: usize> Product<&'a Simd<f64, N>> for Simd<f64, N>

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

impl<'a, const N: usize> Product<&'a Simd<i16, N>> for Simd<i16, N>

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

impl<'a, const N: usize> Product<&'a Simd<i32, N>> for Simd<i32, N>

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

impl<'a, const N: usize> Product<&'a Simd<i64, N>> for Simd<i64, N>

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

impl<'a, const N: usize> Product<&'a Simd<i8, N>> for Simd<i8, N>

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

impl<'a, const N: usize> Product<&'a Simd<isize, N>> for Simd<isize, N>

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

impl<'a, const N: usize> Product<&'a Simd<u16, N>> for Simd<u16, N>

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

impl<'a, const N: usize> Product<&'a Simd<u32, N>> for Simd<u32, N>

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

impl<'a, const N: usize> Product<&'a Simd<u64, N>> for Simd<u64, N>

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

impl<'a, const N: usize> Product<&'a Simd<u8, N>> for Simd<u8, N>

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

impl<'a, const N: usize> Product<&'a Simd<usize, N>> for Simd<usize, N>

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

impl<'a, const N: usize> Sum<&'a Simd<f32, N>> for Simd<f32, N>

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

impl<'a, const N: usize> Sum<&'a Simd<f64, N>> for Simd<f64, N>

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

impl<'a, const N: usize> Sum<&'a Simd<i16, N>> for Simd<i16, N>

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

impl<'a, const N: usize> Sum<&'a Simd<i32, N>> for Simd<i32, N>

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

impl<'a, const N: usize> Sum<&'a Simd<i64, N>> for Simd<i64, N>

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

impl<'a, const N: usize> Sum<&'a Simd<i8, N>> for Simd<i8, N>

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

impl<'a, const N: usize> Sum<&'a Simd<isize, N>> for Simd<isize, N>

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

impl<'a, const N: usize> Sum<&'a Simd<u16, N>> for Simd<u16, N>

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

impl<'a, const N: usize> Sum<&'a Simd<u32, N>> for Simd<u32, N>

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

impl<'a, const N: usize> Sum<&'a Simd<u64, N>> for Simd<u64, N>

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

impl<'a, const N: usize> Sum<&'a Simd<u8, N>> for Simd<u8, N>

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

impl<'a, const N: usize> Sum<&'a Simd<usize, N>> for Simd<usize, N>

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

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

type Output = <I as SliceIndex<[T]>>::Output;
fn index(&self, index: I) -> &Self::Output

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

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

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

fn add_assign(&mut self, rhs: U)

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

fn bitand_assign(&mut self, rhs: U)

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

fn bitor_assign(&mut self, rhs: U)

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

fn bitxor_assign(&mut self, rhs: U)

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

fn div_assign(&mut self, rhs: U)

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

fn mul_assign(&mut self, rhs: U)

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

fn rem_assign(&mut self, rhs: U)

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

fn shl_assign(&mut self, rhs: U)

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

fn shr_assign(&mut self, rhs: U)

impl<T, U, const N: usize> SubAssign<U> for Simd<T, N> where Self: Sub<U, Output = Self>, T: SimdElement,

fn sub_assign(&mut self, rhs: U)

impl<T, const N: usize> Add<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: Add<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn add(self, rhs: &Simd<T, N>) -> Self::Output

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

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

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

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

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

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

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

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

impl<T, const N: usize> BitAnd<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: BitAnd<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn bitand(self, rhs: &Simd<T, N>) -> Self::Output

impl<T, const N: usize> BitOr<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: BitOr<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn bitor(self, rhs: &Simd<T, N>) -> Self::Output

impl<T, const N: usize> BitXor<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: BitXor<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn bitxor(self, rhs: &Simd<T, N>) -> Self::Output

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

fn clone(&self) -> Self

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

impl<T, const N: usize> Debug for Simd<T, N> where T: SimdElement + Debug,

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

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

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd::Simd;
# #[cfg(not(feature = "as_crate"))] use core::simd::Simd;
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 T: SimdElement + Default,

fn default() -> Self

impl<T, const N: usize> Div<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: Div<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn div(self, rhs: &Simd<T, N>) -> Self::Output

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

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

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

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

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

impl<T, const N: usize> Mul<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: Mul<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn mul(self, rhs: &Simd<T, N>) -> Self::Output

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

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

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

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

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

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

impl<T, const N: usize> Rem<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: Rem<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn rem(self, rhs: &Simd<T, N>) -> Self::Output

impl<T, const N: usize> Shl<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: Shl<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn shl(self, rhs: &Simd<T, N>) -> Self::Output

impl<T, const N: usize> Shr<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: Shr<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn shr(self, rhs: &Simd<T, N>) -> Self::Output

impl<T, const N: usize> SimdConstPtr for Simd<*const T, N>

type Usize = Simd<usize, N>;
type Isize = Simd<isize, N>;
type CastPtr<U> = Simd<*const U, N>;
type MutPtr = Simd<*mut T, N>;
type Mask = Mask<isize, N>;
fn is_null(self) -> Self::Mask
fn cast<U>(self) -> Self::CastPtr<U>
fn cast_mut(self) -> Self::MutPtr
fn addr(self) -> Self::Usize
fn with_addr(self, addr: Self::Usize) -> Self
fn expose_provenance(self) -> Self::Usize
fn wrapping_offset(self, count: Self::Isize) -> Self
fn wrapping_add(self, count: Self::Usize) -> Self
fn wrapping_sub(self, count: Self::Usize) -> Self

impl<T, const N: usize> SimdMutPtr for Simd<*mut T, N>

type Usize = Simd<usize, N>;
type Isize = Simd<isize, N>;
type CastPtr<U> = Simd<*mut U, N>;
type ConstPtr = Simd<*const T, N>;
type Mask = Mask<isize, N>;
fn is_null(self) -> Self::Mask
fn cast<U>(self) -> Self::CastPtr<U>
fn cast_const(self) -> Self::ConstPtr
fn addr(self) -> Self::Usize
fn with_addr(self, addr: Self::Usize) -> Self
fn expose_provenance(self) -> Self::Usize
fn wrapping_offset(self, count: Self::Isize) -> Self
fn wrapping_add(self, count: Self::Usize) -> Self
fn wrapping_sub(self, count: Self::Usize) -> Self

impl<T, const N: usize> SimdOrd for Simd<*const T, N>

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

impl<T, const N: usize> SimdOrd for Simd<*mut T, N>

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

impl<T, const N: usize> SimdPartialEq for Simd<*const T, N>

type Mask = Mask<isize, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<T, const N: usize> SimdPartialEq for Simd<*mut T, N>

type Mask = Mask<isize, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<T, const N: usize> SimdPartialOrd for Simd<*const T, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<T, const N: usize> SimdPartialOrd for Simd<*mut T, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<T, const N: usize> Sub<&Simd<T, N>> for Simd<T, N> where T: SimdElement, Simd<T, N>: Sub<Simd<T, N>, Output = Simd<T, N>>,

type Output = Simd<T, N>;
fn sub(self, rhs: &Simd<T, N>) -> Self::Output

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

type Error = TryFromSliceError;
fn try_from(slice: &[T]) -> Result<Self, TryFromSliceError>

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

type Error = TryFromSliceError;
fn try_from(slice: &mut [T]) -> Result<Self, TryFromSliceError>

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

type Output = Simd<f16, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<f32, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<f64, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<i16, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<i32, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<i64, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<i8, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<isize, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<u16, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<u32, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<u64, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<usize, N>;
fn add(self, rhs: Self) -> Self::Output

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

type Output = Simd<i16, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<i32, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<i64, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<i8, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<isize, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<u16, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<u32, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<u64, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<usize, N>;
fn bitand(self, rhs: Self) -> Self::Output

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

type Output = Simd<i16, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<i32, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<i64, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<i8, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<isize, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u16, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u32, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u64, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<usize, N>;
fn bitor(self, rhs: Self) -> Self::Output

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

type Output = Simd<i16, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<i32, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<i64, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<i8, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<isize, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u16, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u32, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u64, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<usize, N>;
fn bitxor(self, rhs: Self) -> Self::Output

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

type Output = Simd<f16, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<f32, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<f64, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<i16, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<i32, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<i64, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<i8, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<isize, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<u16, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<u32, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<u64, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn div(self, rhs: Self) -> Self::Output

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

type Output = Simd<usize, N>;
fn div(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<f16, N> where f16: SimdElement,

type Output = Simd<f16, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<f32, N> where f32: SimdElement,

type Output = Simd<f32, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<f64, N> where f64: SimdElement,

type Output = Simd<f64, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<i16, N> where i16: SimdElement,

type Output = Simd<i16, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<i32, N> where i32: SimdElement,

type Output = Simd<i32, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<i64, N> where i64: SimdElement,

type Output = Simd<i64, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<i8, N> where i8: SimdElement,

type Output = Simd<i8, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<isize, N> where isize: SimdElement,

type Output = Simd<isize, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<u16, N> where u16: SimdElement,

type Output = Simd<u16, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<u32, N> where u32: SimdElement,

type Output = Simd<u32, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<u64, N> where u64: SimdElement,

type Output = Simd<u64, N>;
fn mul(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Mul for Simd<usize, N> where usize: SimdElement,

type Output = Simd<usize, N>;
fn mul(self, rhs: Self) -> Self::Output

impl<const N: usize> Neg for Simd<f16, N> where f16: SimdElement,

type Output = Simd<f16, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Neg for Simd<f32, N> where f32: SimdElement,

type Output = Simd<f32, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Neg for Simd<f64, N> where f64: SimdElement,

type Output = Simd<f64, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Neg for Simd<i16, N> where i16: SimdElement,

type Output = Simd<i16, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Neg for Simd<i32, N> where i32: SimdElement,

type Output = Simd<i32, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Neg for Simd<i64, N> where i64: SimdElement,

type Output = Simd<i64, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Neg for Simd<i8, N> where i8: SimdElement,

type Output = Simd<i8, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Neg for Simd<isize, N> where isize: SimdElement,

type Output = Simd<isize, N>;
fn neg(self) -> Self::Output

impl<const N: usize> Not for Simd<i16, N> where i16: SimdElement,

type Output = Simd<i16, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<i32, N> where i32: SimdElement,

type Output = Simd<i32, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<i64, N> where i64: SimdElement,

type Output = Simd<i64, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<i8, N> where i8: SimdElement,

type Output = Simd<i8, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<isize, N> where isize: SimdElement,

type Output = Simd<isize, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<u16, N> where u16: SimdElement,

type Output = Simd<u16, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<u32, N> where u32: SimdElement,

type Output = Simd<u32, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<u64, N> where u64: SimdElement,

type Output = Simd<u64, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<u8, N> where u8: SimdElement,

type Output = Simd<u8, N>;
fn not(self) -> Self::Output

impl<const N: usize> Not for Simd<usize, N> where usize: SimdElement,

type Output = Simd<usize, N>;
fn not(self) -> Self::Output

impl<const N: usize> Product for Simd<f32, N>

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

impl<const N: usize> Product for Simd<f64, N>

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

impl<const N: usize> Product for Simd<i16, N>

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

impl<const N: usize> Product for Simd<i32, N>

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

impl<const N: usize> Product for Simd<i64, N>

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

impl<const N: usize> Product for Simd<i8, N>

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

impl<const N: usize> Product for Simd<isize, N>

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

impl<const N: usize> Product for Simd<u16, N>

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

impl<const N: usize> Product for Simd<u32, N>

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

impl<const N: usize> Product for Simd<u64, N>

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

impl<const N: usize> Product for Simd<u8, N>

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

impl<const N: usize> Product for Simd<usize, N>

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

impl<const N: usize> Rem for Simd<f16, N> where f16: SimdElement,

type Output = Simd<f16, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<f32, N> where f32: SimdElement,

type Output = Simd<f32, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<f64, N> where f64: SimdElement,

type Output = Simd<f64, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<i16, N> where i16: SimdElement,

type Output = Simd<i16, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<i32, N> where i32: SimdElement,

type Output = Simd<i32, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<i64, N> where i64: SimdElement,

type Output = Simd<i64, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<i8, N> where i8: SimdElement,

type Output = Simd<i8, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<isize, N> where isize: SimdElement,

type Output = Simd<isize, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<u16, N> where u16: SimdElement,

type Output = Simd<u16, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<u32, N> where u32: SimdElement,

type Output = Simd<u32, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<u64, N> where u64: SimdElement,

type Output = Simd<u64, N>;
fn rem(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Rem for Simd<usize, N> where usize: SimdElement,

type Output = Simd<usize, N>;
fn rem(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<i16, N> where i16: SimdElement,

type Output = Simd<i16, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<i32, N> where i32: SimdElement,

type Output = Simd<i32, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<i64, N> where i64: SimdElement,

type Output = Simd<i64, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<i8, N> where i8: SimdElement,

type Output = Simd<i8, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<isize, N> where isize: SimdElement,

type Output = Simd<isize, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<u16, N> where u16: SimdElement,

type Output = Simd<u16, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<u32, N> where u32: SimdElement,

type Output = Simd<u32, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<u64, N> where u64: SimdElement,

type Output = Simd<u64, N>;
fn shl(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl for Simd<usize, N> where usize: SimdElement,

type Output = Simd<usize, N>;
fn shl(self, rhs: Self) -> Self::Output

impl<const N: usize> Shl<&i16> for Simd<i16, N>

type Output = Simd<i16, N>;
fn shl(self, rhs: &i16) -> Self::Output

impl<const N: usize> Shl<&i32> for Simd<i32, N>

type Output = Simd<i32, N>;
fn shl(self, rhs: &i32) -> Self::Output

impl<const N: usize> Shl<&i64> for Simd<i64, N>

type Output = Simd<i64, N>;
fn shl(self, rhs: &i64) -> Self::Output

impl<const N: usize> Shl<&i8> for Simd<i8, N>

type Output = Simd<i8, N>;
fn shl(self, rhs: &i8) -> Self::Output

impl<const N: usize> Shl<&isize> for Simd<isize, N>

type Output = Simd<isize, N>;
fn shl(self, rhs: &isize) -> Self::Output

impl<const N: usize> Shl<&u16> for Simd<u16, N>

type Output = Simd<u16, N>;
fn shl(self, rhs: &u16) -> Self::Output

impl<const N: usize> Shl<&u32> for Simd<u32, N>

type Output = Simd<u32, N>;
fn shl(self, rhs: &u32) -> Self::Output

impl<const N: usize> Shl<&u64> for Simd<u64, N>

type Output = Simd<u64, N>;
fn shl(self, rhs: &u64) -> Self::Output

impl<const N: usize> Shl<&u8> for Simd<u8, N>

type Output = Simd<u8, N>;
fn shl(self, rhs: &u8) -> Self::Output

impl<const N: usize> Shl<&usize> for Simd<usize, N>

type Output = Simd<usize, N>;
fn shl(self, rhs: &usize) -> Self::Output

impl<const N: usize> Shl<i16> for Simd<i16, N>

type Output = Simd<i16, N>;
fn shl(self, rhs: i16) -> Self::Output

impl<const N: usize> Shl<i32> for Simd<i32, N>

type Output = Simd<i32, N>;
fn shl(self, rhs: i32) -> Self::Output

impl<const N: usize> Shl<i64> for Simd<i64, N>

type Output = Simd<i64, N>;
fn shl(self, rhs: i64) -> Self::Output

impl<const N: usize> Shl<i8> for Simd<i8, N>

type Output = Simd<i8, N>;
fn shl(self, rhs: i8) -> Self::Output

impl<const N: usize> Shl<isize> for Simd<isize, N>

type Output = Simd<isize, N>;
fn shl(self, rhs: isize) -> Self::Output

impl<const N: usize> Shl<u16> for Simd<u16, N>

type Output = Simd<u16, N>;
fn shl(self, rhs: u16) -> Self::Output

impl<const N: usize> Shl<u32> for Simd<u32, N>

type Output = Simd<u32, N>;
fn shl(self, rhs: u32) -> Self::Output

impl<const N: usize> Shl<u64> for Simd<u64, N>

type Output = Simd<u64, N>;
fn shl(self, rhs: u64) -> Self::Output

impl<const N: usize> Shl<u8> for Simd<u8, N>

type Output = Simd<u8, N>;
fn shl(self, rhs: u8) -> Self::Output

impl<const N: usize> Shl<usize> for Simd<usize, N>

type Output = Simd<usize, N>;
fn shl(self, rhs: usize) -> Self::Output

impl<const N: usize> Shr for Simd<i16, N> where i16: SimdElement,

type Output = Simd<i16, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<i32, N> where i32: SimdElement,

type Output = Simd<i32, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<i64, N> where i64: SimdElement,

type Output = Simd<i64, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<i8, N> where i8: SimdElement,

type Output = Simd<i8, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<isize, N> where isize: SimdElement,

type Output = Simd<isize, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<u16, N> where u16: SimdElement,

type Output = Simd<u16, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<u32, N> where u32: SimdElement,

type Output = Simd<u32, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<u64, N> where u64: SimdElement,

type Output = Simd<u64, N>;
fn shr(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr for Simd<usize, N> where usize: SimdElement,

type Output = Simd<usize, N>;
fn shr(self, rhs: Self) -> Self::Output

impl<const N: usize> Shr<&i16> for Simd<i16, N>

type Output = Simd<i16, N>;
fn shr(self, rhs: &i16) -> Self::Output

impl<const N: usize> Shr<&i32> for Simd<i32, N>

type Output = Simd<i32, N>;
fn shr(self, rhs: &i32) -> Self::Output

impl<const N: usize> Shr<&i64> for Simd<i64, N>

type Output = Simd<i64, N>;
fn shr(self, rhs: &i64) -> Self::Output

impl<const N: usize> Shr<&i8> for Simd<i8, N>

type Output = Simd<i8, N>;
fn shr(self, rhs: &i8) -> Self::Output

impl<const N: usize> Shr<&isize> for Simd<isize, N>

type Output = Simd<isize, N>;
fn shr(self, rhs: &isize) -> Self::Output

impl<const N: usize> Shr<&u16> for Simd<u16, N>

type Output = Simd<u16, N>;
fn shr(self, rhs: &u16) -> Self::Output

impl<const N: usize> Shr<&u32> for Simd<u32, N>

type Output = Simd<u32, N>;
fn shr(self, rhs: &u32) -> Self::Output

impl<const N: usize> Shr<&u64> for Simd<u64, N>

type Output = Simd<u64, N>;
fn shr(self, rhs: &u64) -> Self::Output

impl<const N: usize> Shr<&u8> for Simd<u8, N>

type Output = Simd<u8, N>;
fn shr(self, rhs: &u8) -> Self::Output

impl<const N: usize> Shr<&usize> for Simd<usize, N>

type Output = Simd<usize, N>;
fn shr(self, rhs: &usize) -> Self::Output

impl<const N: usize> Shr<i16> for Simd<i16, N>

type Output = Simd<i16, N>;
fn shr(self, rhs: i16) -> Self::Output

impl<const N: usize> Shr<i32> for Simd<i32, N>

type Output = Simd<i32, N>;
fn shr(self, rhs: i32) -> Self::Output

impl<const N: usize> Shr<i64> for Simd<i64, N>

type Output = Simd<i64, N>;
fn shr(self, rhs: i64) -> Self::Output

impl<const N: usize> Shr<i8> for Simd<i8, N>

type Output = Simd<i8, N>;
fn shr(self, rhs: i8) -> Self::Output

impl<const N: usize> Shr<isize> for Simd<isize, N>

type Output = Simd<isize, N>;
fn shr(self, rhs: isize) -> Self::Output

impl<const N: usize> Shr<u16> for Simd<u16, N>

type Output = Simd<u16, N>;
fn shr(self, rhs: u16) -> Self::Output

impl<const N: usize> Shr<u32> for Simd<u32, N>

type Output = Simd<u32, N>;
fn shr(self, rhs: u32) -> Self::Output

impl<const N: usize> Shr<u64> for Simd<u64, N>

type Output = Simd<u64, N>;
fn shr(self, rhs: u64) -> Self::Output

impl<const N: usize> Shr<u8> for Simd<u8, N>

type Output = Simd<u8, N>;
fn shr(self, rhs: u8) -> Self::Output

impl<const N: usize> Shr<usize> for Simd<usize, N>

type Output = Simd<usize, N>;
fn shr(self, rhs: usize) -> Self::Output

impl<const N: usize> SimdFloat for Simd<f16, N>

type Mask = Mask<<i16 as SimdElement>::Mask, N>;
type Scalar = f16;
type Bits = Simd<u16, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
unsafe fn to_int_unchecked<I: SimdCast>(self) -> Self::Cast<I>
where
    Self::Scalar: FloatToInt<I>,
fn to_bits(self) -> Simd<u16, N>
fn from_bits(bits: Simd<u16, N>) -> Self
fn abs(self) -> Self
fn recip(self) -> Self
fn to_degrees(self) -> Self
fn to_radians(self) -> Self
fn is_sign_positive(self) -> Self::Mask
fn is_sign_negative(self) -> Self::Mask
fn is_nan(self) -> Self::Mask
fn is_infinite(self) -> Self::Mask
fn is_finite(self) -> Self::Mask
fn is_subnormal(self) -> Self::Mask
fn is_normal(self) -> Self::Mask
fn signum(self) -> Self
fn copysign(self, sign: Self) -> Self
fn simd_min(self, other: Self) -> Self
fn simd_max(self, other: Self) -> Self
fn simd_clamp(self, min: Self, max: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar

impl<const N: usize> SimdFloat for Simd<f32, N>

type Mask = Mask<<i32 as SimdElement>::Mask, N>;
type Scalar = f32;
type Bits = Simd<u32, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
unsafe fn to_int_unchecked<I: SimdCast>(self) -> Self::Cast<I>
where
    Self::Scalar: FloatToInt<I>,
fn to_bits(self) -> Simd<u32, N>
fn from_bits(bits: Simd<u32, N>) -> Self
fn abs(self) -> Self
fn recip(self) -> Self
fn to_degrees(self) -> Self
fn to_radians(self) -> Self
fn is_sign_positive(self) -> Self::Mask
fn is_sign_negative(self) -> Self::Mask
fn is_nan(self) -> Self::Mask
fn is_infinite(self) -> Self::Mask
fn is_finite(self) -> Self::Mask
fn is_subnormal(self) -> Self::Mask
fn is_normal(self) -> Self::Mask
fn signum(self) -> Self
fn copysign(self, sign: Self) -> Self
fn simd_min(self, other: Self) -> Self
fn simd_max(self, other: Self) -> Self
fn simd_clamp(self, min: Self, max: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar

impl<const N: usize> SimdFloat for Simd<f64, N>

type Mask = Mask<<i64 as SimdElement>::Mask, N>;
type Scalar = f64;
type Bits = Simd<u64, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
unsafe fn to_int_unchecked<I: SimdCast>(self) -> Self::Cast<I>
where
    Self::Scalar: FloatToInt<I>,
fn to_bits(self) -> Simd<u64, N>
fn from_bits(bits: Simd<u64, N>) -> Self
fn abs(self) -> Self
fn recip(self) -> Self
fn to_degrees(self) -> Self
fn to_radians(self) -> Self
fn is_sign_positive(self) -> Self::Mask
fn is_sign_negative(self) -> Self::Mask
fn is_nan(self) -> Self::Mask
fn is_infinite(self) -> Self::Mask
fn is_finite(self) -> Self::Mask
fn is_subnormal(self) -> Self::Mask
fn is_normal(self) -> Self::Mask
fn signum(self) -> Self
fn copysign(self, sign: Self) -> Self
fn simd_min(self, other: Self) -> Self
fn simd_max(self, other: Self) -> Self
fn simd_clamp(self, min: Self, max: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar

impl<const N: usize> SimdInt for Simd<i16, N>

type Mask = Mask<<i16 as SimdElement>::Mask, N>;
type Scalar = i16;
type Unsigned = Simd<u16, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs(self) -> Self
fn abs_diff(self, second: Self) -> Self::Unsigned
fn saturating_abs(self) -> Self
fn saturating_neg(self) -> Self
fn is_positive(self) -> Self::Mask
fn is_negative(self) -> Self::Mask
fn signum(self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self::Unsigned
fn count_zeros(self) -> Self::Unsigned
fn leading_zeros(self) -> Self::Unsigned
fn trailing_zeros(self) -> Self::Unsigned
fn leading_ones(self) -> Self::Unsigned
fn trailing_ones(self) -> Self::Unsigned

impl<const N: usize> SimdInt for Simd<i32, N>

type Mask = Mask<<i32 as SimdElement>::Mask, N>;
type Scalar = i32;
type Unsigned = Simd<u32, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs(self) -> Self
fn abs_diff(self, second: Self) -> Self::Unsigned
fn saturating_abs(self) -> Self
fn saturating_neg(self) -> Self
fn is_positive(self) -> Self::Mask
fn is_negative(self) -> Self::Mask
fn signum(self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self::Unsigned
fn count_zeros(self) -> Self::Unsigned
fn leading_zeros(self) -> Self::Unsigned
fn trailing_zeros(self) -> Self::Unsigned
fn leading_ones(self) -> Self::Unsigned
fn trailing_ones(self) -> Self::Unsigned

impl<const N: usize> SimdInt for Simd<i64, N>

type Mask = Mask<<i64 as SimdElement>::Mask, N>;
type Scalar = i64;
type Unsigned = Simd<u64, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs(self) -> Self
fn abs_diff(self, second: Self) -> Self::Unsigned
fn saturating_abs(self) -> Self
fn saturating_neg(self) -> Self
fn is_positive(self) -> Self::Mask
fn is_negative(self) -> Self::Mask
fn signum(self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self::Unsigned
fn count_zeros(self) -> Self::Unsigned
fn leading_zeros(self) -> Self::Unsigned
fn trailing_zeros(self) -> Self::Unsigned
fn leading_ones(self) -> Self::Unsigned
fn trailing_ones(self) -> Self::Unsigned

impl<const N: usize> SimdInt for Simd<i8, N>

type Mask = Mask<<i8 as SimdElement>::Mask, N>;
type Scalar = i8;
type Unsigned = Simd<u8, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs(self) -> Self
fn abs_diff(self, second: Self) -> Self::Unsigned
fn saturating_abs(self) -> Self
fn saturating_neg(self) -> Self
fn is_positive(self) -> Self::Mask
fn is_negative(self) -> Self::Mask
fn signum(self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self::Unsigned
fn count_zeros(self) -> Self::Unsigned
fn leading_zeros(self) -> Self::Unsigned
fn trailing_zeros(self) -> Self::Unsigned
fn leading_ones(self) -> Self::Unsigned
fn trailing_ones(self) -> Self::Unsigned

impl<const N: usize> SimdInt for Simd<isize, N>

type Mask = Mask<<isize as SimdElement>::Mask, N>;
type Scalar = isize;
type Unsigned = Simd<usize, N>;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs(self) -> Self
fn abs_diff(self, second: Self) -> Self::Unsigned
fn saturating_abs(self) -> Self
fn saturating_neg(self) -> Self
fn is_positive(self) -> Self::Mask
fn is_negative(self) -> Self::Mask
fn signum(self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self::Unsigned
fn count_zeros(self) -> Self::Unsigned
fn leading_zeros(self) -> Self::Unsigned
fn trailing_zeros(self) -> Self::Unsigned
fn leading_ones(self) -> Self::Unsigned
fn trailing_ones(self) -> Self::Unsigned

impl<const N: usize> SimdOrd for Simd<i16, N>

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

impl<const N: usize> SimdOrd for Simd<i32, N>

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

impl<const N: usize> SimdOrd for Simd<i64, N>

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

impl<const N: usize> SimdOrd for Simd<i8, N>

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

impl<const N: usize> SimdOrd for Simd<isize, N>

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

impl<const N: usize> SimdOrd for Simd<u16, N>

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

impl<const N: usize> SimdOrd for Simd<u32, N>

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

impl<const N: usize> SimdOrd for Simd<u64, N>

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

impl<const N: usize> SimdOrd for Simd<u8, N>

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

impl<const N: usize> SimdOrd for Simd<usize, N>

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

impl<const N: usize> SimdPartialEq for Simd<f16, N>

type Mask = Mask<<f16 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<f32, N>

type Mask = Mask<<f32 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<f64, N>

type Mask = Mask<<f64 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<i16, N>

type Mask = Mask<<i16 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<i32, N>

type Mask = Mask<<i32 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<i64, N>

type Mask = Mask<<i64 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<i8, N>

type Mask = Mask<<i8 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<isize, N>

type Mask = Mask<<isize as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<u16, N>

type Mask = Mask<<u16 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<u32, N>

type Mask = Mask<<u32 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<u64, N>

type Mask = Mask<<u64 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<u8, N>

type Mask = Mask<<u8 as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialEq for Simd<usize, N>

type Mask = Mask<<usize as SimdElement>::Mask, N>;
fn simd_eq(self, other: Self) -> Self::Mask
fn simd_ne(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<f16, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<f32, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<f64, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<i16, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<i32, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<i64, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<i8, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<isize, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<u16, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<u32, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<u64, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<u8, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdPartialOrd for Simd<usize, N>

fn simd_lt(self, other: Self) -> Self::Mask
fn simd_le(self, other: Self) -> Self::Mask
fn simd_gt(self, other: Self) -> Self::Mask
fn simd_ge(self, other: Self) -> Self::Mask

impl<const N: usize> SimdUint for Simd<u16, N>

type Scalar = u16;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn wrapping_neg(self) -> Self
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs_diff(self, second: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self
fn count_zeros(self) -> Self
fn leading_zeros(self) -> Self
fn trailing_zeros(self) -> Self
fn leading_ones(self) -> Self
fn trailing_ones(self) -> Self

impl<const N: usize> SimdUint for Simd<u32, N>

type Scalar = u32;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn wrapping_neg(self) -> Self
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs_diff(self, second: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self
fn count_zeros(self) -> Self
fn leading_zeros(self) -> Self
fn trailing_zeros(self) -> Self
fn leading_ones(self) -> Self
fn trailing_ones(self) -> Self

impl<const N: usize> SimdUint for Simd<u64, N>

type Scalar = u64;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn wrapping_neg(self) -> Self
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs_diff(self, second: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self
fn count_zeros(self) -> Self
fn leading_zeros(self) -> Self
fn trailing_zeros(self) -> Self
fn leading_ones(self) -> Self
fn trailing_ones(self) -> Self

impl<const N: usize> SimdUint for Simd<u8, N>

type Scalar = u8;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn wrapping_neg(self) -> Self
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs_diff(self, second: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self
fn count_zeros(self) -> Self
fn leading_zeros(self) -> Self
fn trailing_zeros(self) -> Self
fn leading_ones(self) -> Self
fn trailing_ones(self) -> Self

impl<const N: usize> SimdUint for Simd<usize, N>

type Scalar = usize;
type Cast<T: SimdElement> = Simd<T, N>;
fn cast<T: SimdCast>(self) -> Self::Cast<T>
fn wrapping_neg(self) -> Self
fn saturating_add(self, second: Self) -> Self
fn saturating_sub(self, second: Self) -> Self
fn abs_diff(self, second: Self) -> Self
fn reduce_sum(self) -> Self::Scalar
fn reduce_product(self) -> Self::Scalar
fn reduce_max(self) -> Self::Scalar
fn reduce_min(self) -> Self::Scalar
fn reduce_and(self) -> Self::Scalar
fn reduce_or(self) -> Self::Scalar
fn reduce_xor(self) -> Self::Scalar
fn swap_bytes(self) -> Self
fn reverse_bits(self) -> Self
fn count_ones(self) -> Self
fn count_zeros(self) -> Self
fn leading_zeros(self) -> Self
fn trailing_zeros(self) -> Self
fn leading_ones(self) -> Self
fn trailing_ones(self) -> Self

impl<const N: usize> Sub for Simd<f16, N> where f16: SimdElement,

type Output = Simd<f16, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<f32, N> where f32: SimdElement,

type Output = Simd<f32, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<f64, N> where f64: SimdElement,

type Output = Simd<f64, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<i16, N> where i16: SimdElement,

type Output = Simd<i16, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<i32, N> where i32: SimdElement,

type Output = Simd<i32, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<i64, N> where i64: SimdElement,

type Output = Simd<i64, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<i8, N> where i8: SimdElement,

type Output = Simd<i8, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<isize, N> where isize: SimdElement,

type Output = Simd<isize, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<u16, N> where u16: SimdElement,

type Output = Simd<u16, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<u32, N> where u32: SimdElement,

type Output = Simd<u32, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<u64, N> where u64: SimdElement,

type Output = Simd<u64, N>;
fn sub(self, rhs: Self) -> Self::Output

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

type Output = Simd<u8, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sub for Simd<usize, N> where usize: SimdElement,

type Output = Simd<usize, N>;
fn sub(self, rhs: Self) -> Self::Output

impl<const N: usize> Sum for Simd<f32, N>

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

impl<const N: usize> Sum for Simd<f64, N>

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

impl<const N: usize> Sum for Simd<i16, N>

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

impl<const N: usize> Sum for Simd<i32, N>

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

impl<const N: usize> Sum for Simd<i64, N>

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

impl<const N: usize> Sum for Simd<i8, N>

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

impl<const N: usize> Sum for Simd<isize, N>

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

impl<const N: usize> Sum for Simd<u16, N>

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

impl<const N: usize> Sum for Simd<u32, N>

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

impl<const N: usize> Sum for Simd<u64, N>

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

impl<const N: usize> Sum for Simd<u8, N>

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

impl<const N: usize> Sum for Simd<usize, N>

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

Auto Trait Implementations

impl<T, const N: usize> Freeze for Simd<T, N> where [T; N]: Freeze,

impl<T, const N: usize> RefUnwindSafe for Simd<T, N> where [T; N]: RefUnwindSafe,

impl<T, const N: usize> Send for Simd<T, N> where [T; N]: Send,

impl<T, const N: usize> Sync for Simd<T, N> where [T; N]: Sync,

impl<T, const N: usize> Unpin for Simd<T, N> where [T; N]: Unpin,

impl<T, const N: usize> UnsafeUnpin for Simd<T, N> where [T; N]: UnsafeUnpin,

impl<T, const N: usize> UnwindSafe for Simd<T, N> where [T; N]: UnwindSafe,

Blanket Implementations

impl<T> Any for Simd<T, N> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Simd<T, N> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Simd<T, N> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for Simd<T, N> where T: Clone,

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

impl<T> From<T> for Simd<T, N>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Printable for Simd<T, N> where T: Copy + Debug,

impl<T> SizeHint for Simd<T, N> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for Simd<T, N>

impl<T, U> Into<U> for Simd<T, N> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for Simd<T, N> where U: Into<T>,

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Simd<T, N> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>