#[repr(simd)]pub struct Simd<T, const N: usize>(/* private fields */)
where
LaneCount<N>: SupportedLaneCount,
T: SimdElement;
portable_simd
#86656)Expand description
A SIMD vector with the shape of [T; N]
but the operations of T
.
Simd<T, N>
supports the operators (+, *, etc.) that T
does in “elementwise” fashion.
These take the element at each index from the left-hand side and right-hand side,
perform the operation, then return the result in the same index in a vector of equal size.
However, Simd
differs from normal iteration and normal arrays:
Simd<T, N>
executesN
operations in a single step with nobreak
sSimd<T, N>
can have an alignment greater thanT
, for better mechanical sympathy
By always imposing these constraints on Simd
, it is easier to compile elementwise operations
into machine instructions that can themselves be executed in parallel.
let a: [i32; 4] = [-2, 0, 2, 4];
let b = [10, 9, 8, 7];
let sum = array::from_fn(|i| a[i] + b[i]);
let prod = array::from_fn(|i| a[i] * b[i]);
// `Simd<T, N>` implements `From<[T; N]>`
let (v, w) = (Simd::from(a), Simd::from(b));
// Which means arrays implement `Into<Simd<T, N>>`.
assert_eq!(v + w, sum.into());
assert_eq!(v * w, prod.into());
RunSimd
with integer elements treats operators as wrapping, as if T
was Wrapping<T>
.
Thus, Simd
does not implement wrapping_add
, because that is the default behavior.
This means there is no warning on overflows, even in “debug” builds.
For most applications where Simd
is appropriate, it is “not a bug” to wrap,
and even “debug builds” are unlikely to tolerate the loss of performance.
You may want to consider using explicitly checked arithmetic if such is required.
Division by zero on integers still causes a panic, so
you may want to consider using f32
or f64
if that is unacceptable.
§Layout
Simd<T, N>
has a layout similar to [T; N]
(identical “shapes”), with a greater alignment.
[T; N]
is aligned to T
, but Simd<T, N>
will have an alignment based on both T
and N
.
Thus it is sound to transmute
Simd<T, N>
to [T; N]
and should optimize to “zero cost”,
but the reverse transmutation may require a copy the compiler cannot simply elide.
§ABI “Features”
Due to Rust’s safety guarantees, Simd<T, N>
is currently passed and returned via memory,
not SIMD registers, except as an optimization. Using #[inline]
on functions that accept
Simd<T, N>
or return it is recommended, at the cost of code generation time, as
inlining SIMD-using functions can omit a large function prolog or epilog and thus
improve both speed and code size. The need for this may be corrected in the future.
Using #[inline(always)]
still requires additional care.
§Safe SIMD with Unsafe Rust
Operations with Simd
are typically safe, but there are many reasons to want to combine SIMD with unsafe
code.
Care must be taken to respect differences between Simd
and other types it may be transformed into or derived from.
In particular, the layout of Simd<T, N>
may be similar to [T; N]
, and may allow some transmutations,
but references to [T; N]
are not interchangeable with those to Simd<T, N>
.
Thus, when using unsafe
Rust to read and write Simd<T, N>
through raw pointers, it is a good idea to first try with
read_unaligned
and write_unaligned
. This is because:
read
andwrite
require full alignment (in this case,Simd<T, N>
’s alignment)Simd<T, N>
is often read from or written to[T]
and other types aligned toT
- combining these actions violates the
unsafe
contract and explodes the program into a puff of undefined behavior - the compiler can implicitly adjust layouts to make unaligned reads or writes fully aligned if it sees the optimization
- most contemporary processors with “aligned” and “unaligned” read and write instructions exhibit no performance difference if the “unaligned” variant is aligned at runtime
Less obligations mean unaligned reads and writes are less likely to make the program unsound,
and may be just as fast as stricter alternatives.
When trying to guarantee alignment, [T]::as_simd
is an option for
converting [T]
to [Simd<T, N>]
, and allows soundly operating on an aligned SIMD body,
but it may cost more time when handling the scalar head and tail.
If these are not enough, it is most ideal to design data structures to be already aligned
to mem::align_of::<Simd<T, N>>()
before using unsafe
Rust to read or write.
Other ways to compensate for these facts, like materializing Simd
to or from an array first,
are handled by safe methods like Simd::from_array
and Simd::from_slice
.
Implementations§
source§impl<T, const N: usize> Simd<T, N>
impl<T, const N: usize> Simd<T, N>
sourcepub fn reverse(self) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn reverse(self) -> Simd<T, N>
portable_simd
#86656)Reverse the order of the elements in the vector.
sourcepub fn rotate_elements_left<const OFFSET: usize>(self) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn rotate_elements_left<const OFFSET: usize>(self) -> Simd<T, N>
portable_simd
#86656)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.
sourcepub fn rotate_elements_right<const OFFSET: usize>(self) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn rotate_elements_right<const OFFSET: usize>(self) -> Simd<T, N>
portable_simd
#86656)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.
sourcepub fn interleave(self, other: Simd<T, N>) -> (Simd<T, N>, Simd<T, N>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn interleave(self, other: Simd<T, N>) -> (Simd<T, N>, Simd<T, N>)
portable_simd
#86656)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
.
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]);
Runsourcepub fn deinterleave(self, other: Simd<T, N>) -> (Simd<T, N>, Simd<T, N>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn deinterleave(self, other: Simd<T, N>) -> (Simd<T, N>, Simd<T, N>)
portable_simd
#86656)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
.
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]);
Runsourcepub fn resize<const M: usize>(self, value: T) -> Simd<T, M>where
LaneCount<M>: SupportedLaneCount,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn resize<const M: usize>(self, value: T) -> Simd<T, M>where
LaneCount<M>: SupportedLaneCount,
portable_simd
#86656)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.
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]);
Runsource§impl<const N: usize> Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
sourcepub fn swizzle_dyn(self, idxs: Simd<u8, N>) -> Simd<u8, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn swizzle_dyn(self, idxs: Simd<u8, N>) -> Simd<u8, N>
portable_simd
#86656)Swizzle a vector of bytes according to the index vector. Indices within range select the appropriate byte. Indices “out of bounds” instead select 0.
Note that the current implementation is selected during build-time
of the standard library, so cargo build -Zbuild-std
may be necessary
to unlock better performance, especially for larger vectors.
A planned compiler improvement will enable using #[target_feature]
instead.
source§impl<T, const N: usize> Simd<T, N>
impl<T, const N: usize> Simd<T, N>
sourcepub const LEN: usize = N
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const LEN: usize = N
portable_simd
#86656)Number of elements in this vector.
sourcepub const fn len(&self) -> usize
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn len(&self) -> usize
portable_simd
#86656)sourcepub fn splat(value: T) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn splat(value: T) -> Simd<T, N>
portable_simd
#86656)sourcepub const fn as_array(&self) -> &[T; N]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn as_array(&self) -> &[T; N]
portable_simd
#86656)sourcepub fn as_mut_array(&mut self) -> &mut [T; N]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn as_mut_array(&mut self) -> &mut [T; N]
portable_simd
#86656)Returns a mutable array reference containing the entire SIMD vector.
sourcepub const fn from_array(array: [T; N]) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn from_array(array: [T; N]) -> Simd<T, N>
portable_simd
#86656)Converts an array to a SIMD vector.
sourcepub const fn to_array(self) -> [T; N]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn to_array(self) -> [T; N]
portable_simd
#86656)Converts a SIMD vector to an array.
sourcepub const fn from_slice(slice: &[T]) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn from_slice(slice: &[T]) -> Simd<T, N>
portable_simd
#86656)sourcepub fn copy_to_slice(self, slice: &mut [T])
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn copy_to_slice(self, slice: &mut [T])
portable_simd
#86656)sourcepub fn gather_or(
slice: &[T],
idxs: Simd<usize, N>,
or: Simd<T, N>
) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn gather_or( slice: &[T], idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>
portable_simd
#86656)Reads from potentially discontiguous indices in slice
to construct a SIMD vector.
If an index is out-of-bounds, the element is instead selected from the or
vector.
§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]); // Note the index that is out-of-bounds
let alt = Simd::from_array([-5, -4, -3, -2]);
let result = Simd::gather_or(&vec, idxs, alt);
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));
Runsourcepub fn gather_or_default(slice: &[T], idxs: Simd<usize, N>) -> Simd<T, N>where
T: Default,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn gather_or_default(slice: &[T], idxs: Simd<usize, N>) -> Simd<T, N>where
T: Default,
portable_simd
#86656)Reads from indices in slice
to construct a SIMD vector.
If an index is out-of-bounds, the element is set to the default given by T: Default
.
§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]); // Note the index that is out-of-bounds
let result = Simd::gather_or_default(&vec, idxs);
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));
Runsourcepub fn gather_select(
slice: &[T],
enable: Mask<isize, N>,
idxs: Simd<usize, N>,
or: Simd<T, N>
) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn gather_select( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>
portable_simd
#86656)Reads from indices in slice
to construct a SIMD vector.
The mask enable
s all true
indices and disables all false
indices.
If an index is disabled or is out-of-bounds, the element is selected from the or
vector.
§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]); // Includes an out-of-bounds index
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Includes a masked element
let result = Simd::gather_select(&vec, enable, idxs, alt);
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
Runsourcepub unsafe fn gather_select_unchecked(
slice: &[T],
enable: Mask<isize, N>,
idxs: Simd<usize, N>,
or: Simd<T, N>
) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn gather_select_unchecked( slice: &[T], enable: Mask<isize, N>, idxs: Simd<usize, N>, or: Simd<T, N> ) -> Simd<T, N>
portable_simd
#86656)Reads from indices in slice
to construct a SIMD vector.
The mask enable
s all true
indices and disables all false
indices.
If an index is disabled, the element is selected from the or
vector.
§Safety
Calling this function with an enable
d out-of-bounds index is undefined behavior
even if the resulting value is not used.
§Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]); // Includes an out-of-bounds index
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Includes a masked element
// If this mask was used to gather, it would be unsound. Let's fix that.
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));
// The out-of-bounds index has been masked, so it's safe to gather now.
let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
Runsourcepub unsafe fn gather_ptr(source: Simd<*const T, N>) -> Simd<T, N>where
T: Default,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn gather_ptr(source: Simd<*const T, N>) -> Simd<T, N>where
T: Default,
portable_simd
#86656)Read elementwise from pointers into a SIMD vector.
§Safety
Each read must satisfy the same conditions as core::ptr::read
.
§Example
let values = [6, 2, 4, 9];
let offsets = Simd::from_array([1, 0, 0, 3]);
let source = Simd::splat(values.as_ptr()).wrapping_add(offsets);
let gathered = unsafe { Simd::gather_ptr(source) };
assert_eq!(gathered, Simd::from_array([2, 6, 6, 9]));
Runsourcepub unsafe fn gather_select_ptr(
source: Simd<*const T, N>,
enable: Mask<isize, N>,
or: Simd<T, N>
) -> Simd<T, N>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn gather_select_ptr( source: Simd<*const T, N>, enable: Mask<isize, N>, or: Simd<T, N> ) -> Simd<T, N>
portable_simd
#86656)Conditionally read elementwise from pointers into a SIMD vector.
The mask enable
s all true
pointers and disables all false
pointers.
If a pointer is disabled, the element is selected from the or
vector,
and no read is performed.
§Safety
Enabled elements must satisfy the same conditions as core::ptr::read
.
§Example
let values = [6, 2, 4, 9];
let enable = Mask::from_array([true, true, false, true]);
let offsets = Simd::from_array([1, 0, 0, 3]);
let source = Simd::splat(values.as_ptr()).wrapping_add(offsets);
let gathered = unsafe { Simd::gather_select_ptr(source, enable, Simd::splat(0)) };
assert_eq!(gathered, Simd::from_array([2, 6, 0, 9]));
Runsourcepub fn scatter(self, slice: &mut [T], idxs: Simd<usize, N>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn scatter(self, slice: &mut [T], idxs: Simd<usize, N>)
portable_simd
#86656)Writes the values in a SIMD vector to potentially discontiguous indices in slice
.
If an index is out-of-bounds, the write is suppressed without panicking.
If two elements in the scattered vector would write to the same index
only the last element is guaranteed to actually be written.
§Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]); // Note the duplicate index.
let vals = Simd::from_array([-27, 82, -41, 124]);
vals.scatter(&mut vec, idxs); // two logical writes means the last wins.
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);
Runsourcepub fn scatter_select(
self,
slice: &mut [T],
enable: Mask<isize, N>,
idxs: Simd<usize, N>
)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn scatter_select( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N> )
portable_simd
#86656)Writes values from a SIMD vector to multiple potentially discontiguous indices in slice
.
The mask enable
s all true
indices and disables all false
indices.
If an enabled index is out-of-bounds, the write is suppressed without panicking.
If two enabled elements in the scattered vector would write to the same index,
only the last element is guaranteed to actually be written.
§Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]); // Includes an out-of-bounds index
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Includes a masked element
vals.scatter_select(&mut vec, enable, idxs); // The last write is masked, thus omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);
Runsourcepub unsafe fn scatter_select_unchecked(
self,
slice: &mut [T],
enable: Mask<isize, N>,
idxs: Simd<usize, N>
)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn scatter_select_unchecked( self, slice: &mut [T], enable: Mask<isize, N>, idxs: Simd<usize, N> )
portable_simd
#86656)Writes values from a SIMD vector to multiple potentially discontiguous indices in slice
.
The mask enable
s all true
indices and disables all false
indices.
If two enabled elements in the scattered vector would write to the same index,
only the last element is guaranteed to actually be written.
§Safety
Calling this function with an enabled out-of-bounds index is undefined behavior, and may lead to memory corruption.
§Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Masks the final index
// If this mask was used to scatter, it would be unsound. Let's fix that.
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));
// We have masked the OOB index, so it's safe to scatter now.
unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }
// The second write to index 0 was masked, thus omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);
Runsourcepub unsafe fn scatter_ptr(self, dest: Simd<*mut T, N>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn scatter_ptr(self, dest: Simd<*mut T, N>)
portable_simd
#86656)Write pointers elementwise into a SIMD vector.
§Safety
Each write must satisfy the same conditions as core::ptr::write
.
§Example
let mut values = [0; 4];
let offset = Simd::from_array([3, 2, 1, 0]);
let ptrs = Simd::splat(values.as_mut_ptr()).wrapping_add(offset);
unsafe { Simd::from_array([6, 3, 5, 7]).scatter_ptr(ptrs); }
assert_eq!(values, [7, 5, 3, 6]);
Runsourcepub unsafe fn scatter_select_ptr(
self,
dest: Simd<*mut T, N>,
enable: Mask<isize, N>
)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn scatter_select_ptr( self, dest: Simd<*mut T, N>, enable: Mask<isize, N> )
portable_simd
#86656)Conditionally write pointers elementwise into a SIMD vector.
The mask enable
s all true
pointers and disables all false
pointers.
If a pointer is disabled, the write to its pointee is skipped.
§Safety
Enabled pointers must satisfy the same conditions as core::ptr::write
.
§Example
let mut values = [0; 4];
let offset = Simd::from_array([3, 2, 1, 0]);
let ptrs = Simd::splat(values.as_mut_ptr()).wrapping_add(offset);
let enable = Mask::from_array([true, true, false, false]);
unsafe { Simd::from_array([6, 3, 5, 7]).scatter_select_ptr(ptrs, enable); }
assert_eq!(values, [0, 0, 3, 6]);
RunTrait Implementations§
source§impl<T, U, const N: usize> AddAssign<U> for Simd<T, N>
impl<T, U, const N: usize> AddAssign<U> for Simd<T, N>
source§fn add_assign(&mut self, rhs: U)
fn add_assign(&mut self, rhs: U)
+=
operation. Read moresource§impl<T, U, const N: usize> BitAndAssign<U> for Simd<T, N>
impl<T, U, const N: usize> BitAndAssign<U> for Simd<T, N>
source§fn bitand_assign(&mut self, rhs: U)
fn bitand_assign(&mut self, rhs: U)
&=
operation. Read moresource§impl<T, U, const N: usize> BitOrAssign<U> for Simd<T, N>
impl<T, U, const N: usize> BitOrAssign<U> for Simd<T, N>
source§fn bitor_assign(&mut self, rhs: U)
fn bitor_assign(&mut self, rhs: U)
|=
operation. Read moresource§impl<T, U, const N: usize> BitXorAssign<U> for Simd<T, N>
impl<T, U, const N: usize> BitXorAssign<U> for Simd<T, N>
source§fn bitxor_assign(&mut self, rhs: U)
fn bitxor_assign(&mut self, rhs: U)
^=
operation. Read moresource§impl<T, U, const N: usize> DivAssign<U> for Simd<T, N>
impl<T, U, const N: usize> DivAssign<U> for Simd<T, N>
source§fn div_assign(&mut self, rhs: U)
fn div_assign(&mut self, rhs: U)
/=
operation. Read moresource§impl<T, U, const N: usize> MulAssign<U> for Simd<T, N>
impl<T, U, const N: usize> MulAssign<U> for Simd<T, N>
source§fn mul_assign(&mut self, rhs: U)
fn mul_assign(&mut self, rhs: U)
*=
operation. Read moresource§impl<T, const N: usize> Ord for Simd<T, N>
impl<T, const N: usize> Ord for Simd<T, N>
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
source§impl<T, const N: usize> PartialEq for Simd<T, N>
impl<T, const N: usize> PartialEq for Simd<T, N>
source§impl<T, const N: usize> PartialOrd for Simd<T, N>
impl<T, const N: usize> PartialOrd for Simd<T, N>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, const N: usize> Product<&'a Simd<f32, N>> for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<f32, N>> for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<f64, N>> for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<f64, N>> for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<i16, N>> for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<i16, N>> for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<i32, N>> for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<i32, N>> for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<i64, N>> for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<i64, N>> for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<i8, N>> for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<i8, N>> for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<isize, N>> for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<isize, N>> for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<u16, N>> for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<u16, N>> for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<u32, N>> for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<u32, N>> for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<u64, N>> for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<u64, N>> for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<u8, N>> for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<u8, N>> for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Product<&'a Simd<usize, N>> for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Product<&'a Simd<usize, N>> for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<T, U, const N: usize> RemAssign<U> for Simd<T, N>
impl<T, U, const N: usize> RemAssign<U> for Simd<T, N>
source§fn rem_assign(&mut self, rhs: U)
fn rem_assign(&mut self, rhs: U)
%=
operation. Read moresource§impl<'lhs, const N: usize> Shl<&i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<&usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<&usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shl<usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shl<usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<T, U, const N: usize> ShlAssign<U> for Simd<T, N>
impl<T, U, const N: usize> ShlAssign<U> for Simd<T, N>
source§fn shl_assign(&mut self, rhs: U)
fn shl_assign(&mut self, rhs: U)
<<=
operation. Read moresource§impl<'lhs, const N: usize> Shr<&i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<&usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<&usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<i16> for &'lhs Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<i32> for &'lhs Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<i64> for &'lhs Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<i8> for &'lhs Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<isize> for &'lhs Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<u16> for &'lhs Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<u32> for &'lhs Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<u64> for &'lhs Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<u8> for &'lhs Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'lhs, const N: usize> Shr<usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'lhs, const N: usize> Shr<usize> for &'lhs Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<T, U, const N: usize> ShrAssign<U> for Simd<T, N>
impl<T, U, const N: usize> ShrAssign<U> for Simd<T, N>
source§fn shr_assign(&mut self, rhs: U)
fn shr_assign(&mut self, rhs: U)
>>=
operation. Read moresource§impl<T, const N: usize> SimdConstPtr for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdConstPtr for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
§type Usize = Simd<usize, N>
type Usize = Simd<usize, N>
portable_simd
#86656)usize
with the same number of elements.§type Isize = Simd<isize, N>
type Isize = Simd<isize, N>
portable_simd
#86656)isize
with the same number of elements.§type CastPtr<U> = Simd<*const U, N>
type CastPtr<U> = Simd<*const U, N>
portable_simd
#86656)§type MutPtr = Simd<*mut T, N>
type MutPtr = Simd<*mut T, N>
portable_simd
#86656)§type Mask = Mask<isize, N>
type Mask = Mask<isize, N>
portable_simd
#86656)source§fn is_null(self) -> <Simd<*const T, N> as SimdConstPtr>::Mask
fn is_null(self) -> <Simd<*const T, N> as SimdConstPtr>::Mask
portable_simd
#86656)true
for each element that is null.source§fn cast<U>(self) -> <Simd<*const T, N> as SimdConstPtr>::CastPtr<U>
fn cast<U>(self) -> <Simd<*const T, N> as SimdConstPtr>::CastPtr<U>
portable_simd
#86656)source§fn cast_mut(self) -> <Simd<*const T, N> as SimdConstPtr>::MutPtr
fn cast_mut(self) -> <Simd<*const T, N> as SimdConstPtr>::MutPtr
portable_simd
#86656)source§fn addr(self) -> <Simd<*const T, N> as SimdConstPtr>::Usize
fn addr(self) -> <Simd<*const T, N> as SimdConstPtr>::Usize
portable_simd
#86656)source§fn with_addr(
self,
addr: <Simd<*const T, N> as SimdConstPtr>::Usize
) -> Simd<*const T, N>
fn with_addr( self, addr: <Simd<*const T, N> as SimdConstPtr>::Usize ) -> Simd<*const T, N>
portable_simd
#86656)source§fn expose_addr(self) -> <Simd<*const T, N> as SimdConstPtr>::Usize
fn expose_addr(self) -> <Simd<*const T, N> as SimdConstPtr>::Usize
portable_simd
#86656)Self::from_exposed_addr
.source§fn from_exposed_addr(
addr: <Simd<*const T, N> as SimdConstPtr>::Usize
) -> Simd<*const T, N>
fn from_exposed_addr( addr: <Simd<*const T, N> as SimdConstPtr>::Usize ) -> Simd<*const T, N>
portable_simd
#86656)source§fn wrapping_offset(
self,
count: <Simd<*const T, N> as SimdConstPtr>::Isize
) -> Simd<*const T, N>
fn wrapping_offset( self, count: <Simd<*const T, N> as SimdConstPtr>::Isize ) -> Simd<*const T, N>
portable_simd
#86656)source§impl<const N: usize> SimdFloat for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdFloat for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i32 as SimdElement>::Mask, N>
type Mask = Mask<<i32 as SimdElement>::Mask, N>
portable_simd
#86656)§type Scalar = f32
type Scalar = f32
portable_simd
#86656)§type Bits = Simd<u32, N>
type Bits = Simd<u32, N>
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<f32, N> as SimdFloat>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<f32, N> as SimdFloat>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§unsafe fn to_int_unchecked<I>(self) -> <Simd<f32, N> as SimdFloat>::Cast<I>
unsafe fn to_int_unchecked<I>(self) -> <Simd<f32, N> as SimdFloat>::Cast<I>
portable_simd
#86656)source§fn to_bits(self) -> Simd<u32, N>
fn to_bits(self) -> Simd<u32, N>
portable_simd
#86656)source§fn from_bits(bits: Simd<u32, N>) -> Simd<f32, N>
fn from_bits(bits: Simd<u32, N>) -> Simd<f32, N>
portable_simd
#86656)source§fn abs(self) -> Simd<f32, N>
fn abs(self) -> Simd<f32, N>
portable_simd
#86656)self
.source§fn recip(self) -> Simd<f32, N>
fn recip(self) -> Simd<f32, N>
portable_simd
#86656)1/x
.source§fn to_degrees(self) -> Simd<f32, N>
fn to_degrees(self) -> Simd<f32, N>
portable_simd
#86656)source§fn to_radians(self) -> Simd<f32, N>
fn to_radians(self) -> Simd<f32, N>
portable_simd
#86656)source§fn is_sign_positive(self) -> <Simd<f32, N> as SimdFloat>::Mask
fn is_sign_positive(self) -> <Simd<f32, N> as SimdFloat>::Mask
portable_simd
#86656)+0.0
, NaN
s with positive sign bit and positive infinity.source§fn is_sign_negative(self) -> <Simd<f32, N> as SimdFloat>::Mask
fn is_sign_negative(self) -> <Simd<f32, N> as SimdFloat>::Mask
portable_simd
#86656)-0.0
, NaN
s with negative sign bit and negative infinity.source§fn is_nan(self) -> <Simd<f32, N> as SimdFloat>::Mask
fn is_nan(self) -> <Simd<f32, N> as SimdFloat>::Mask
portable_simd
#86656)NaN
.source§fn is_infinite(self) -> <Simd<f32, N> as SimdFloat>::Mask
fn is_infinite(self) -> <Simd<f32, N> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_finite(self) -> <Simd<f32, N> as SimdFloat>::Mask
fn is_finite(self) -> <Simd<f32, N> as SimdFloat>::Mask
portable_simd
#86656)NaN
.source§fn is_subnormal(self) -> <Simd<f32, N> as SimdFloat>::Mask
fn is_subnormal(self) -> <Simd<f32, N> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_normal(self) -> <Simd<f32, N> as SimdFloat>::Mask
fn is_normal(self) -> <Simd<f32, N> as SimdFloat>::Mask
portable_simd
#86656)NaN
.source§fn signum(self) -> Simd<f32, N>
fn signum(self) -> Simd<f32, N>
portable_simd
#86656)source§fn copysign(self, sign: Simd<f32, N>) -> Simd<f32, N>
fn copysign(self, sign: Simd<f32, N>) -> Simd<f32, N>
portable_simd
#86656)source§fn simd_min(self, other: Simd<f32, N>) -> Simd<f32, N>
fn simd_min(self, other: Simd<f32, N>) -> Simd<f32, N>
portable_simd
#86656)source§fn simd_max(self, other: Simd<f32, N>) -> Simd<f32, N>
fn simd_max(self, other: Simd<f32, N>) -> Simd<f32, N>
portable_simd
#86656)source§fn simd_clamp(self, min: Simd<f32, N>, max: Simd<f32, N>) -> Simd<f32, N>
fn simd_clamp(self, min: Simd<f32, N>, max: Simd<f32, N>) -> Simd<f32, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<f32, N> as SimdFloat>::Scalar
fn reduce_sum(self) -> <Simd<f32, N> as SimdFloat>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<f32, N> as SimdFloat>::Scalar
fn reduce_product(self) -> <Simd<f32, N> as SimdFloat>::Scalar
portable_simd
#86656)source§impl<const N: usize> SimdFloat for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdFloat for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i64 as SimdElement>::Mask, N>
type Mask = Mask<<i64 as SimdElement>::Mask, N>
portable_simd
#86656)§type Scalar = f64
type Scalar = f64
portable_simd
#86656)§type Bits = Simd<u64, N>
type Bits = Simd<u64, N>
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<f64, N> as SimdFloat>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<f64, N> as SimdFloat>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§unsafe fn to_int_unchecked<I>(self) -> <Simd<f64, N> as SimdFloat>::Cast<I>
unsafe fn to_int_unchecked<I>(self) -> <Simd<f64, N> as SimdFloat>::Cast<I>
portable_simd
#86656)source§fn to_bits(self) -> Simd<u64, N>
fn to_bits(self) -> Simd<u64, N>
portable_simd
#86656)source§fn from_bits(bits: Simd<u64, N>) -> Simd<f64, N>
fn from_bits(bits: Simd<u64, N>) -> Simd<f64, N>
portable_simd
#86656)source§fn abs(self) -> Simd<f64, N>
fn abs(self) -> Simd<f64, N>
portable_simd
#86656)self
.source§fn recip(self) -> Simd<f64, N>
fn recip(self) -> Simd<f64, N>
portable_simd
#86656)1/x
.source§fn to_degrees(self) -> Simd<f64, N>
fn to_degrees(self) -> Simd<f64, N>
portable_simd
#86656)source§fn to_radians(self) -> Simd<f64, N>
fn to_radians(self) -> Simd<f64, N>
portable_simd
#86656)source§fn is_sign_positive(self) -> <Simd<f64, N> as SimdFloat>::Mask
fn is_sign_positive(self) -> <Simd<f64, N> as SimdFloat>::Mask
portable_simd
#86656)+0.0
, NaN
s with positive sign bit and positive infinity.source§fn is_sign_negative(self) -> <Simd<f64, N> as SimdFloat>::Mask
fn is_sign_negative(self) -> <Simd<f64, N> as SimdFloat>::Mask
portable_simd
#86656)-0.0
, NaN
s with negative sign bit and negative infinity.source§fn is_nan(self) -> <Simd<f64, N> as SimdFloat>::Mask
fn is_nan(self) -> <Simd<f64, N> as SimdFloat>::Mask
portable_simd
#86656)NaN
.source§fn is_infinite(self) -> <Simd<f64, N> as SimdFloat>::Mask
fn is_infinite(self) -> <Simd<f64, N> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_finite(self) -> <Simd<f64, N> as SimdFloat>::Mask
fn is_finite(self) -> <Simd<f64, N> as SimdFloat>::Mask
portable_simd
#86656)NaN
.source§fn is_subnormal(self) -> <Simd<f64, N> as SimdFloat>::Mask
fn is_subnormal(self) -> <Simd<f64, N> as SimdFloat>::Mask
portable_simd
#86656)source§fn is_normal(self) -> <Simd<f64, N> as SimdFloat>::Mask
fn is_normal(self) -> <Simd<f64, N> as SimdFloat>::Mask
portable_simd
#86656)NaN
.source§fn signum(self) -> Simd<f64, N>
fn signum(self) -> Simd<f64, N>
portable_simd
#86656)source§fn copysign(self, sign: Simd<f64, N>) -> Simd<f64, N>
fn copysign(self, sign: Simd<f64, N>) -> Simd<f64, N>
portable_simd
#86656)source§fn simd_min(self, other: Simd<f64, N>) -> Simd<f64, N>
fn simd_min(self, other: Simd<f64, N>) -> Simd<f64, N>
portable_simd
#86656)source§fn simd_max(self, other: Simd<f64, N>) -> Simd<f64, N>
fn simd_max(self, other: Simd<f64, N>) -> Simd<f64, N>
portable_simd
#86656)source§fn simd_clamp(self, min: Simd<f64, N>, max: Simd<f64, N>) -> Simd<f64, N>
fn simd_clamp(self, min: Simd<f64, N>, max: Simd<f64, N>) -> Simd<f64, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<f64, N> as SimdFloat>::Scalar
fn reduce_sum(self) -> <Simd<f64, N> as SimdFloat>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<f64, N> as SimdFloat>::Scalar
fn reduce_product(self) -> <Simd<f64, N> as SimdFloat>::Scalar
portable_simd
#86656)source§impl<const N: usize> SimdInt for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdInt for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i16 as SimdElement>::Mask, N>
type Mask = Mask<<i16 as SimdElement>::Mask, N>
portable_simd
#86656)§type Scalar = i16
type Scalar = i16
portable_simd
#86656)§type Unsigned = Simd<u16, N>
type Unsigned = Simd<u16, N>
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<i16, N> as SimdInt>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<i16, N> as SimdInt>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i16, N>) -> Simd<i16, N>
fn saturating_add(self, second: Simd<i16, N>) -> Simd<i16, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i16, N>) -> Simd<i16, N>
fn saturating_sub(self, second: Simd<i16, N>) -> Simd<i16, N>
portable_simd
#86656)source§fn abs(self) -> Simd<i16, N>
fn abs(self) -> Simd<i16, N>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i16, N>
fn saturating_abs(self) -> Simd<i16, N>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i16, N>
fn saturating_neg(self) -> Simd<i16, N>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i16, N> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i16, N> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i16, N> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i16, N> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i16, N>
fn signum(self) -> Simd<i16, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i16, N> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i16, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i16, N> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i16, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i16, N> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i16, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i16, N> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i16, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i16, N> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i16, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<i16, N> as SimdInt>::Scalar
fn reduce_or(self) -> <Simd<i16, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<i16, N> as SimdInt>::Scalar
fn reduce_xor(self) -> <Simd<i16, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<i16, N>
fn swap_bytes(self) -> Simd<i16, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<i16, N>
fn reverse_bits(self) -> Simd<i16, N>
portable_simd
#86656)source§fn leading_zeros(self) -> <Simd<i16, N> as SimdInt>::Unsigned
fn leading_zeros(self) -> <Simd<i16, N> as SimdInt>::Unsigned
portable_simd
#86656)source§fn trailing_zeros(self) -> <Simd<i16, N> as SimdInt>::Unsigned
fn trailing_zeros(self) -> <Simd<i16, N> as SimdInt>::Unsigned
portable_simd
#86656)source§impl<const N: usize> SimdInt for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdInt for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i32 as SimdElement>::Mask, N>
type Mask = Mask<<i32 as SimdElement>::Mask, N>
portable_simd
#86656)§type Scalar = i32
type Scalar = i32
portable_simd
#86656)§type Unsigned = Simd<u32, N>
type Unsigned = Simd<u32, N>
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<i32, N> as SimdInt>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<i32, N> as SimdInt>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i32, N>) -> Simd<i32, N>
fn saturating_add(self, second: Simd<i32, N>) -> Simd<i32, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i32, N>) -> Simd<i32, N>
fn saturating_sub(self, second: Simd<i32, N>) -> Simd<i32, N>
portable_simd
#86656)source§fn abs(self) -> Simd<i32, N>
fn abs(self) -> Simd<i32, N>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i32, N>
fn saturating_abs(self) -> Simd<i32, N>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i32, N>
fn saturating_neg(self) -> Simd<i32, N>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i32, N> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i32, N> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i32, N> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i32, N> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i32, N>
fn signum(self) -> Simd<i32, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i32, N> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i32, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i32, N> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i32, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i32, N> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i32, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i32, N> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i32, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i32, N> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i32, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<i32, N> as SimdInt>::Scalar
fn reduce_or(self) -> <Simd<i32, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<i32, N> as SimdInt>::Scalar
fn reduce_xor(self) -> <Simd<i32, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<i32, N>
fn swap_bytes(self) -> Simd<i32, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<i32, N>
fn reverse_bits(self) -> Simd<i32, N>
portable_simd
#86656)source§fn leading_zeros(self) -> <Simd<i32, N> as SimdInt>::Unsigned
fn leading_zeros(self) -> <Simd<i32, N> as SimdInt>::Unsigned
portable_simd
#86656)source§fn trailing_zeros(self) -> <Simd<i32, N> as SimdInt>::Unsigned
fn trailing_zeros(self) -> <Simd<i32, N> as SimdInt>::Unsigned
portable_simd
#86656)source§impl<const N: usize> SimdInt for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdInt for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i64 as SimdElement>::Mask, N>
type Mask = Mask<<i64 as SimdElement>::Mask, N>
portable_simd
#86656)§type Scalar = i64
type Scalar = i64
portable_simd
#86656)§type Unsigned = Simd<u64, N>
type Unsigned = Simd<u64, N>
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<i64, N> as SimdInt>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<i64, N> as SimdInt>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i64, N>) -> Simd<i64, N>
fn saturating_add(self, second: Simd<i64, N>) -> Simd<i64, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i64, N>) -> Simd<i64, N>
fn saturating_sub(self, second: Simd<i64, N>) -> Simd<i64, N>
portable_simd
#86656)source§fn abs(self) -> Simd<i64, N>
fn abs(self) -> Simd<i64, N>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i64, N>
fn saturating_abs(self) -> Simd<i64, N>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i64, N>
fn saturating_neg(self) -> Simd<i64, N>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i64, N> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i64, N> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i64, N> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i64, N> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i64, N>
fn signum(self) -> Simd<i64, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i64, N> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i64, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i64, N> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i64, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i64, N> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i64, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i64, N> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i64, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i64, N> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i64, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<i64, N> as SimdInt>::Scalar
fn reduce_or(self) -> <Simd<i64, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<i64, N> as SimdInt>::Scalar
fn reduce_xor(self) -> <Simd<i64, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<i64, N>
fn swap_bytes(self) -> Simd<i64, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<i64, N>
fn reverse_bits(self) -> Simd<i64, N>
portable_simd
#86656)source§fn leading_zeros(self) -> <Simd<i64, N> as SimdInt>::Unsigned
fn leading_zeros(self) -> <Simd<i64, N> as SimdInt>::Unsigned
portable_simd
#86656)source§fn trailing_zeros(self) -> <Simd<i64, N> as SimdInt>::Unsigned
fn trailing_zeros(self) -> <Simd<i64, N> as SimdInt>::Unsigned
portable_simd
#86656)source§impl<const N: usize> SimdInt for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdInt for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i8 as SimdElement>::Mask, N>
type Mask = Mask<<i8 as SimdElement>::Mask, N>
portable_simd
#86656)§type Scalar = i8
type Scalar = i8
portable_simd
#86656)§type Unsigned = Simd<u8, N>
type Unsigned = Simd<u8, N>
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<i8, N> as SimdInt>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<i8, N> as SimdInt>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn saturating_add(self, second: Simd<i8, N>) -> Simd<i8, N>
fn saturating_add(self, second: Simd<i8, N>) -> Simd<i8, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<i8, N>) -> Simd<i8, N>
fn saturating_sub(self, second: Simd<i8, N>) -> Simd<i8, N>
portable_simd
#86656)source§fn abs(self) -> Simd<i8, N>
fn abs(self) -> Simd<i8, N>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<i8, N>
fn saturating_abs(self) -> Simd<i8, N>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<i8, N>
fn saturating_neg(self) -> Simd<i8, N>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<i8, N> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i8, N> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<i8, N> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i8, N> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<i8, N>
fn signum(self) -> Simd<i8, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<i8, N> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i8, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<i8, N> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i8, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<i8, N> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i8, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<i8, N> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i8, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<i8, N> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i8, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<i8, N> as SimdInt>::Scalar
fn reduce_or(self) -> <Simd<i8, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<i8, N> as SimdInt>::Scalar
fn reduce_xor(self) -> <Simd<i8, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<i8, N>
fn swap_bytes(self) -> Simd<i8, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<i8, N>
fn reverse_bits(self) -> Simd<i8, N>
portable_simd
#86656)source§fn leading_zeros(self) -> <Simd<i8, N> as SimdInt>::Unsigned
fn leading_zeros(self) -> <Simd<i8, N> as SimdInt>::Unsigned
portable_simd
#86656)source§fn trailing_zeros(self) -> <Simd<i8, N> as SimdInt>::Unsigned
fn trailing_zeros(self) -> <Simd<i8, N> as SimdInt>::Unsigned
portable_simd
#86656)source§impl<const N: usize> SimdInt for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdInt for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<isize as SimdElement>::Mask, N>
type Mask = Mask<<isize as SimdElement>::Mask, N>
portable_simd
#86656)§type Scalar = isize
type Scalar = isize
portable_simd
#86656)§type Unsigned = Simd<usize, N>
type Unsigned = Simd<usize, N>
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<isize, N> as SimdInt>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<isize, N> as SimdInt>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn saturating_add(self, second: Simd<isize, N>) -> Simd<isize, N>
fn saturating_add(self, second: Simd<isize, N>) -> Simd<isize, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<isize, N>) -> Simd<isize, N>
fn saturating_sub(self, second: Simd<isize, N>) -> Simd<isize, N>
portable_simd
#86656)source§fn abs(self) -> Simd<isize, N>
fn abs(self) -> Simd<isize, N>
portable_simd
#86656)source§fn saturating_abs(self) -> Simd<isize, N>
fn saturating_abs(self) -> Simd<isize, N>
portable_simd
#86656)source§fn saturating_neg(self) -> Simd<isize, N>
fn saturating_neg(self) -> Simd<isize, N>
portable_simd
#86656)source§fn is_positive(self) -> <Simd<isize, N> as SimdInt>::Mask
fn is_positive(self) -> <Simd<isize, N> as SimdInt>::Mask
portable_simd
#86656)source§fn is_negative(self) -> <Simd<isize, N> as SimdInt>::Mask
fn is_negative(self) -> <Simd<isize, N> as SimdInt>::Mask
portable_simd
#86656)source§fn signum(self) -> Simd<isize, N>
fn signum(self) -> Simd<isize, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<isize, N> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<isize, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<isize, N> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<isize, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<isize, N> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<isize, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<isize, N> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<isize, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<isize, N> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<isize, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<isize, N> as SimdInt>::Scalar
fn reduce_or(self) -> <Simd<isize, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<isize, N> as SimdInt>::Scalar
fn reduce_xor(self) -> <Simd<isize, N> as SimdInt>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<isize, N>
fn swap_bytes(self) -> Simd<isize, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<isize, N>
fn reverse_bits(self) -> Simd<isize, N>
portable_simd
#86656)source§fn leading_zeros(self) -> <Simd<isize, N> as SimdInt>::Unsigned
fn leading_zeros(self) -> <Simd<isize, N> as SimdInt>::Unsigned
portable_simd
#86656)source§fn trailing_zeros(self) -> <Simd<isize, N> as SimdInt>::Unsigned
fn trailing_zeros(self) -> <Simd<isize, N> as SimdInt>::Unsigned
portable_simd
#86656)source§impl<T, const N: usize> SimdMutPtr for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdMutPtr for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
§type Usize = Simd<usize, N>
type Usize = Simd<usize, N>
portable_simd
#86656)usize
with the same number of elements.§type Isize = Simd<isize, N>
type Isize = Simd<isize, N>
portable_simd
#86656)isize
with the same number of elements.§type CastPtr<U> = Simd<*mut U, N>
type CastPtr<U> = Simd<*mut U, N>
portable_simd
#86656)§type ConstPtr = Simd<*const T, N>
type ConstPtr = Simd<*const T, N>
portable_simd
#86656)§type Mask = Mask<isize, N>
type Mask = Mask<isize, N>
portable_simd
#86656)source§fn is_null(self) -> <Simd<*mut T, N> as SimdMutPtr>::Mask
fn is_null(self) -> <Simd<*mut T, N> as SimdMutPtr>::Mask
portable_simd
#86656)true
for each element that is null.source§fn cast<U>(self) -> <Simd<*mut T, N> as SimdMutPtr>::CastPtr<U>
fn cast<U>(self) -> <Simd<*mut T, N> as SimdMutPtr>::CastPtr<U>
portable_simd
#86656)source§fn cast_const(self) -> <Simd<*mut T, N> as SimdMutPtr>::ConstPtr
fn cast_const(self) -> <Simd<*mut T, N> as SimdMutPtr>::ConstPtr
portable_simd
#86656)source§fn addr(self) -> <Simd<*mut T, N> as SimdMutPtr>::Usize
fn addr(self) -> <Simd<*mut T, N> as SimdMutPtr>::Usize
portable_simd
#86656)source§fn with_addr(
self,
addr: <Simd<*mut T, N> as SimdMutPtr>::Usize
) -> Simd<*mut T, N>
fn with_addr( self, addr: <Simd<*mut T, N> as SimdMutPtr>::Usize ) -> Simd<*mut T, N>
portable_simd
#86656)source§fn expose_addr(self) -> <Simd<*mut T, N> as SimdMutPtr>::Usize
fn expose_addr(self) -> <Simd<*mut T, N> as SimdMutPtr>::Usize
portable_simd
#86656)Self::from_exposed_addr
.source§fn from_exposed_addr(
addr: <Simd<*mut T, N> as SimdMutPtr>::Usize
) -> Simd<*mut T, N>
fn from_exposed_addr( addr: <Simd<*mut T, N> as SimdMutPtr>::Usize ) -> Simd<*mut T, N>
portable_simd
#86656)source§fn wrapping_offset(
self,
count: <Simd<*mut T, N> as SimdMutPtr>::Isize
) -> Simd<*mut T, N>
fn wrapping_offset( self, count: <Simd<*mut T, N> as SimdMutPtr>::Isize ) -> Simd<*mut T, N>
portable_simd
#86656)source§impl<T, const N: usize> SimdOrd for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdOrd for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<*const T, N>) -> Simd<*const T, N>
fn simd_max(self, other: Simd<*const T, N>) -> Simd<*const T, N>
portable_simd
#86656)other
.source§impl<T, const N: usize> SimdOrd for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdOrd for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<*mut T, N>) -> Simd<*mut T, N>
fn simd_max(self, other: Simd<*mut T, N>) -> Simd<*mut T, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<i16, N>) -> Simd<i16, N>
fn simd_max(self, other: Simd<i16, N>) -> Simd<i16, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<i32, N>) -> Simd<i32, N>
fn simd_max(self, other: Simd<i32, N>) -> Simd<i32, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<i64, N>) -> Simd<i64, N>
fn simd_max(self, other: Simd<i64, N>) -> Simd<i64, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<i8, N>) -> Simd<i8, N>
fn simd_max(self, other: Simd<i8, N>) -> Simd<i8, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<isize, N>) -> Simd<isize, N>
fn simd_max(self, other: Simd<isize, N>) -> Simd<isize, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<u16, N>) -> Simd<u16, N>
fn simd_max(self, other: Simd<u16, N>) -> Simd<u16, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<u32, N>) -> Simd<u32, N>
fn simd_max(self, other: Simd<u32, N>) -> Simd<u32, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<u64, N>) -> Simd<u64, N>
fn simd_max(self, other: Simd<u64, N>) -> Simd<u64, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<u8, N>) -> Simd<u8, N>
fn simd_max(self, other: Simd<u8, N>) -> Simd<u8, N>
portable_simd
#86656)other
.source§impl<const N: usize> SimdOrd for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdOrd for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_max(self, other: Simd<usize, N>) -> Simd<usize, N>
fn simd_max(self, other: Simd<usize, N>) -> Simd<usize, N>
portable_simd
#86656)other
.source§impl<T, const N: usize> SimdPartialEq for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdPartialEq for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<isize, N>
type Mask = Mask<isize, N>
portable_simd
#86656)source§impl<T, const N: usize> SimdPartialEq for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdPartialEq for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<isize, N>
type Mask = Mask<isize, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<f32 as SimdElement>::Mask, N>
type Mask = Mask<<f32 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<f64 as SimdElement>::Mask, N>
type Mask = Mask<<f64 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i16 as SimdElement>::Mask, N>
type Mask = Mask<<i16 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i32 as SimdElement>::Mask, N>
type Mask = Mask<<i32 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i64 as SimdElement>::Mask, N>
type Mask = Mask<<i64 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<i8 as SimdElement>::Mask, N>
type Mask = Mask<<i8 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<isize as SimdElement>::Mask, N>
type Mask = Mask<<isize as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<u16 as SimdElement>::Mask, N>
type Mask = Mask<<u16 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<u32 as SimdElement>::Mask, N>
type Mask = Mask<<u32 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<u64 as SimdElement>::Mask, N>
type Mask = Mask<<u64 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<u8 as SimdElement>::Mask, N>
type Mask = Mask<<u8 as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<const N: usize> SimdPartialEq for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialEq for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
§type Mask = Mask<<usize as SimdElement>::Mask, N>
type Mask = Mask<<usize as SimdElement>::Mask, N>
portable_simd
#86656)source§impl<T, const N: usize> SimdPartialOrd for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdPartialOrd for Simd<*const T, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(
self,
other: Simd<*const T, N>
) -> <Simd<*const T, N> as SimdPartialEq>::Mask
fn simd_lt( self, other: Simd<*const T, N> ) -> <Simd<*const T, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(
self,
other: Simd<*const T, N>
) -> <Simd<*const T, N> as SimdPartialEq>::Mask
fn simd_le( self, other: Simd<*const T, N> ) -> <Simd<*const T, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<T, const N: usize> SimdPartialOrd for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
impl<T, const N: usize> SimdPartialOrd for Simd<*mut T, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(
self,
other: Simd<*mut T, N>
) -> <Simd<*mut T, N> as SimdPartialEq>::Mask
fn simd_lt( self, other: Simd<*mut T, N> ) -> <Simd<*mut T, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(
self,
other: Simd<*mut T, N>
) -> <Simd<*mut T, N> as SimdPartialEq>::Mask
fn simd_le( self, other: Simd<*mut T, N> ) -> <Simd<*mut T, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<f32, N>) -> <Simd<f32, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<f32, N>) -> <Simd<f32, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<f32, N>) -> <Simd<f32, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<f32, N>) -> <Simd<f32, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<f64, N>) -> <Simd<f64, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<i16, N>) -> <Simd<i16, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<i16, N>) -> <Simd<i16, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<i16, N>) -> <Simd<i16, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<i16, N>) -> <Simd<i16, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<i32, N>) -> <Simd<i32, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<i32, N>) -> <Simd<i32, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<i32, N>) -> <Simd<i32, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<i32, N>) -> <Simd<i32, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<i64, N>) -> <Simd<i64, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<i64, N>) -> <Simd<i64, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<i64, N>) -> <Simd<i64, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<i64, N>) -> <Simd<i64, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<i8, N>) -> <Simd<i8, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<i8, N>) -> <Simd<i8, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<i8, N>) -> <Simd<i8, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<i8, N>) -> <Simd<i8, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(
self,
other: Simd<isize, N>
) -> <Simd<isize, N> as SimdPartialEq>::Mask
fn simd_lt( self, other: Simd<isize, N> ) -> <Simd<isize, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(
self,
other: Simd<isize, N>
) -> <Simd<isize, N> as SimdPartialEq>::Mask
fn simd_le( self, other: Simd<isize, N> ) -> <Simd<isize, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<u16, N>) -> <Simd<u16, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<u16, N>) -> <Simd<u16, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<u16, N>) -> <Simd<u16, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<u16, N>) -> <Simd<u16, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<u32, N>) -> <Simd<u32, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<u32, N>) -> <Simd<u32, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<u32, N>) -> <Simd<u32, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<u32, N>) -> <Simd<u32, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<u64, N>) -> <Simd<u64, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<u64, N>) -> <Simd<u64, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<u64, N>) -> <Simd<u64, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<u64, N>) -> <Simd<u64, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(self, other: Simd<u8, N>) -> <Simd<u8, N> as SimdPartialEq>::Mask
fn simd_lt(self, other: Simd<u8, N>) -> <Simd<u8, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(self, other: Simd<u8, N>) -> <Simd<u8, N> as SimdPartialEq>::Mask
fn simd_le(self, other: Simd<u8, N>) -> <Simd<u8, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdPartialOrd for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdPartialOrd for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§fn simd_lt(
self,
other: Simd<usize, N>
) -> <Simd<usize, N> as SimdPartialEq>::Mask
fn simd_lt( self, other: Simd<usize, N> ) -> <Simd<usize, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§fn simd_le(
self,
other: Simd<usize, N>
) -> <Simd<usize, N> as SimdPartialEq>::Mask
fn simd_le( self, other: Simd<usize, N> ) -> <Simd<usize, N> as SimdPartialEq>::Mask
portable_simd
#86656)other
.source§impl<const N: usize> SimdUint for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdUint for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
§type Scalar = u16
type Scalar = u16
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<u16, N> as SimdUint>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<u16, N> as SimdUint>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn wrapping_neg(self) -> Simd<u16, N>
fn wrapping_neg(self) -> Simd<u16, N>
portable_simd
#86656)source§fn saturating_add(self, second: Simd<u16, N>) -> Simd<u16, N>
fn saturating_add(self, second: Simd<u16, N>) -> Simd<u16, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<u16, N>) -> Simd<u16, N>
fn saturating_sub(self, second: Simd<u16, N>) -> Simd<u16, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<u16, N> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u16, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<u16, N> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u16, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<u16, N> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u16, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<u16, N> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u16, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<u16, N> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u16, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<u16, N> as SimdUint>::Scalar
fn reduce_or(self) -> <Simd<u16, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<u16, N> as SimdUint>::Scalar
fn reduce_xor(self) -> <Simd<u16, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<u16, N>
fn swap_bytes(self) -> Simd<u16, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<u16, N>
fn reverse_bits(self) -> Simd<u16, N>
portable_simd
#86656)source§fn leading_zeros(self) -> Simd<u16, N>
fn leading_zeros(self) -> Simd<u16, N>
portable_simd
#86656)source§fn trailing_zeros(self) -> Simd<u16, N>
fn trailing_zeros(self) -> Simd<u16, N>
portable_simd
#86656)source§impl<const N: usize> SimdUint for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdUint for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
§type Scalar = u32
type Scalar = u32
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<u32, N> as SimdUint>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<u32, N> as SimdUint>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn wrapping_neg(self) -> Simd<u32, N>
fn wrapping_neg(self) -> Simd<u32, N>
portable_simd
#86656)source§fn saturating_add(self, second: Simd<u32, N>) -> Simd<u32, N>
fn saturating_add(self, second: Simd<u32, N>) -> Simd<u32, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<u32, N>) -> Simd<u32, N>
fn saturating_sub(self, second: Simd<u32, N>) -> Simd<u32, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<u32, N> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u32, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<u32, N> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u32, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<u32, N> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u32, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<u32, N> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u32, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<u32, N> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u32, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<u32, N> as SimdUint>::Scalar
fn reduce_or(self) -> <Simd<u32, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<u32, N> as SimdUint>::Scalar
fn reduce_xor(self) -> <Simd<u32, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<u32, N>
fn swap_bytes(self) -> Simd<u32, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<u32, N>
fn reverse_bits(self) -> Simd<u32, N>
portable_simd
#86656)source§fn leading_zeros(self) -> Simd<u32, N>
fn leading_zeros(self) -> Simd<u32, N>
portable_simd
#86656)source§fn trailing_zeros(self) -> Simd<u32, N>
fn trailing_zeros(self) -> Simd<u32, N>
portable_simd
#86656)source§impl<const N: usize> SimdUint for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdUint for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
§type Scalar = u64
type Scalar = u64
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<u64, N> as SimdUint>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<u64, N> as SimdUint>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn wrapping_neg(self) -> Simd<u64, N>
fn wrapping_neg(self) -> Simd<u64, N>
portable_simd
#86656)source§fn saturating_add(self, second: Simd<u64, N>) -> Simd<u64, N>
fn saturating_add(self, second: Simd<u64, N>) -> Simd<u64, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<u64, N>) -> Simd<u64, N>
fn saturating_sub(self, second: Simd<u64, N>) -> Simd<u64, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<u64, N> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u64, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<u64, N> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u64, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<u64, N> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u64, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<u64, N> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u64, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<u64, N> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u64, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<u64, N> as SimdUint>::Scalar
fn reduce_or(self) -> <Simd<u64, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<u64, N> as SimdUint>::Scalar
fn reduce_xor(self) -> <Simd<u64, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<u64, N>
fn swap_bytes(self) -> Simd<u64, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<u64, N>
fn reverse_bits(self) -> Simd<u64, N>
portable_simd
#86656)source§fn leading_zeros(self) -> Simd<u64, N>
fn leading_zeros(self) -> Simd<u64, N>
portable_simd
#86656)source§fn trailing_zeros(self) -> Simd<u64, N>
fn trailing_zeros(self) -> Simd<u64, N>
portable_simd
#86656)source§impl<const N: usize> SimdUint for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdUint for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
§type Scalar = u8
type Scalar = u8
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<u8, N> as SimdUint>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<u8, N> as SimdUint>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn wrapping_neg(self) -> Simd<u8, N>
fn wrapping_neg(self) -> Simd<u8, N>
portable_simd
#86656)source§fn saturating_add(self, second: Simd<u8, N>) -> Simd<u8, N>
fn saturating_add(self, second: Simd<u8, N>) -> Simd<u8, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<u8, N>) -> Simd<u8, N>
fn saturating_sub(self, second: Simd<u8, N>) -> Simd<u8, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<u8, N> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u8, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<u8, N> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u8, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<u8, N> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u8, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<u8, N> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u8, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<u8, N> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u8, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<u8, N> as SimdUint>::Scalar
fn reduce_or(self) -> <Simd<u8, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<u8, N> as SimdUint>::Scalar
fn reduce_xor(self) -> <Simd<u8, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<u8, N>
fn swap_bytes(self) -> Simd<u8, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<u8, N>
fn reverse_bits(self) -> Simd<u8, N>
portable_simd
#86656)source§fn leading_zeros(self) -> Simd<u8, N>
fn leading_zeros(self) -> Simd<u8, N>
portable_simd
#86656)source§fn trailing_zeros(self) -> Simd<u8, N>
fn trailing_zeros(self) -> Simd<u8, N>
portable_simd
#86656)source§impl<const N: usize> SimdUint for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> SimdUint for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
§type Scalar = usize
type Scalar = usize
portable_simd
#86656)§type Cast<T: SimdElement> = Simd<T, N>
type Cast<T: SimdElement> = Simd<T, N>
portable_simd
#86656)source§fn cast<T>(self) -> <Simd<usize, N> as SimdUint>::Cast<T>where
T: SimdCast,
fn cast<T>(self) -> <Simd<usize, N> as SimdUint>::Cast<T>where
T: SimdCast,
portable_simd
#86656)source§fn wrapping_neg(self) -> Simd<usize, N>
fn wrapping_neg(self) -> Simd<usize, N>
portable_simd
#86656)source§fn saturating_add(self, second: Simd<usize, N>) -> Simd<usize, N>
fn saturating_add(self, second: Simd<usize, N>) -> Simd<usize, N>
portable_simd
#86656)source§fn saturating_sub(self, second: Simd<usize, N>) -> Simd<usize, N>
fn saturating_sub(self, second: Simd<usize, N>) -> Simd<usize, N>
portable_simd
#86656)source§fn reduce_sum(self) -> <Simd<usize, N> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<usize, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_product(self) -> <Simd<usize, N> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<usize, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_max(self) -> <Simd<usize, N> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<usize, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_min(self) -> <Simd<usize, N> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<usize, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_and(self) -> <Simd<usize, N> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<usize, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_or(self) -> <Simd<usize, N> as SimdUint>::Scalar
fn reduce_or(self) -> <Simd<usize, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn reduce_xor(self) -> <Simd<usize, N> as SimdUint>::Scalar
fn reduce_xor(self) -> <Simd<usize, N> as SimdUint>::Scalar
portable_simd
#86656)source§fn swap_bytes(self) -> Simd<usize, N>
fn swap_bytes(self) -> Simd<usize, N>
portable_simd
#86656)source§fn reverse_bits(self) -> Simd<usize, N>
fn reverse_bits(self) -> Simd<usize, N>
portable_simd
#86656)source§fn leading_zeros(self) -> Simd<usize, N>
fn leading_zeros(self) -> Simd<usize, N>
portable_simd
#86656)source§fn trailing_zeros(self) -> Simd<usize, N>
fn trailing_zeros(self) -> Simd<usize, N>
portable_simd
#86656)source§impl<const N: usize> StdFloat for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> StdFloat for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
source§fn fract(self) -> Self
🔬This is a nightly-only experimental API. (portable_simd
#86656)
fn fract(self) -> Self
portable_simd
#86656)Returns the floating point’s fractional value, with its integer part removed.
source§fn mul_add(self, a: Self, b: Self) -> Self
fn mul_add(self, a: Self, b: Self) -> Self
portable_simd
#86656)(self * a) + b
with only one rounding error,
yielding a more accurate result than an unfused multiply-add. Read moresource§fn sqrt(self) -> Self
fn sqrt(self) -> Self
portable_simd
#86656)self
source§fn ceil(self) -> Self
fn ceil(self) -> Self
portable_simd
#86656)source§fn floor(self) -> Self
fn floor(self) -> Self
portable_simd
#86656)source§impl<const N: usize> StdFloat for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> StdFloat for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
source§fn fract(self) -> Self
🔬This is a nightly-only experimental API. (portable_simd
#86656)
fn fract(self) -> Self
portable_simd
#86656)Returns the floating point’s fractional value, with its integer part removed.
source§fn mul_add(self, a: Self, b: Self) -> Self
fn mul_add(self, a: Self, b: Self) -> Self
portable_simd
#86656)(self * a) + b
with only one rounding error,
yielding a more accurate result than an unfused multiply-add. Read moresource§fn sqrt(self) -> Self
fn sqrt(self) -> Self
portable_simd
#86656)self
source§fn ceil(self) -> Self
fn ceil(self) -> Self
portable_simd
#86656)source§fn floor(self) -> Self
fn floor(self) -> Self
portable_simd
#86656)source§impl<T, U, const N: usize> SubAssign<U> for Simd<T, N>
impl<T, U, const N: usize> SubAssign<U> for Simd<T, N>
source§fn sub_assign(&mut self, rhs: U)
fn sub_assign(&mut self, rhs: U)
-=
operation. Read moresource§impl<'a, const N: usize> Sum<&'a Simd<f32, N>> for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<f32, N>> for Simd<f32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<f64, N>> for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<f64, N>> for Simd<f64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<i16, N>> for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<i16, N>> for Simd<i16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<i32, N>> for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<i32, N>> for Simd<i32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<i64, N>> for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<i64, N>> for Simd<i64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<i8, N>> for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<i8, N>> for Simd<i8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<isize, N>> for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<isize, N>> for Simd<isize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<u16, N>> for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<u16, N>> for Simd<u16, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<u32, N>> for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<u32, N>> for Simd<u32, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<u64, N>> for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<u64, N>> for Simd<u64, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<u8, N>> for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<u8, N>> for Simd<u8, N>where
LaneCount<N>: SupportedLaneCount,
source§impl<'a, const N: usize> Sum<&'a Simd<usize, N>> for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
impl<'a, const N: usize> Sum<&'a Simd<usize, N>> for Simd<usize, N>where
LaneCount<N>: SupportedLaneCount,
source§impl ToBytes for Simd<f32, 1>
impl ToBytes for Simd<f32, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#52}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#52}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f32, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f32, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f32, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f32, 1> as ToBytes>::Bytes) -> Simd<f32, 1>
fn from_ne_bytes(bytes: <Simd<f32, 1> as ToBytes>::Bytes) -> Simd<f32, 1>
portable_simd
#86656)source§impl ToBytes for Simd<f32, 16>
impl ToBytes for Simd<f32, 16>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#56}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#56}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f32, 16> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f32, 16> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f32, 16> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f32, 16> as ToBytes>::Bytes) -> Simd<f32, 16>
fn from_ne_bytes(bytes: <Simd<f32, 16> as ToBytes>::Bytes) -> Simd<f32, 16>
portable_simd
#86656)source§impl ToBytes for Simd<f32, 2>
impl ToBytes for Simd<f32, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#53}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#53}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f32, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f32, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f32, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f32, 2> as ToBytes>::Bytes) -> Simd<f32, 2>
fn from_ne_bytes(bytes: <Simd<f32, 2> as ToBytes>::Bytes) -> Simd<f32, 2>
portable_simd
#86656)source§impl ToBytes for Simd<f32, 4>
impl ToBytes for Simd<f32, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#54}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#54}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f32, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f32, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f32, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f32, 4> as ToBytes>::Bytes) -> Simd<f32, 4>
fn from_ne_bytes(bytes: <Simd<f32, 4> as ToBytes>::Bytes) -> Simd<f32, 4>
portable_simd
#86656)source§impl ToBytes for Simd<f32, 8>
impl ToBytes for Simd<f32, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#55}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#55}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f32, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f32, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f32, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f32, 8> as ToBytes>::Bytes) -> Simd<f32, 8>
fn from_ne_bytes(bytes: <Simd<f32, 8> as ToBytes>::Bytes) -> Simd<f32, 8>
portable_simd
#86656)source§impl ToBytes for Simd<f64, 1>
impl ToBytes for Simd<f64, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#57}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#57}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f64, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f64, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f64, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f64, 1> as ToBytes>::Bytes) -> Simd<f64, 1>
fn from_ne_bytes(bytes: <Simd<f64, 1> as ToBytes>::Bytes) -> Simd<f64, 1>
portable_simd
#86656)source§impl ToBytes for Simd<f64, 2>
impl ToBytes for Simd<f64, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#58}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#58}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f64, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f64, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f64, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f64, 2> as ToBytes>::Bytes) -> Simd<f64, 2>
fn from_ne_bytes(bytes: <Simd<f64, 2> as ToBytes>::Bytes) -> Simd<f64, 2>
portable_simd
#86656)source§impl ToBytes for Simd<f64, 4>
impl ToBytes for Simd<f64, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#59}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#59}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f64, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f64, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f64, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f64, 4> as ToBytes>::Bytes) -> Simd<f64, 4>
fn from_ne_bytes(bytes: <Simd<f64, 4> as ToBytes>::Bytes) -> Simd<f64, 4>
portable_simd
#86656)source§impl ToBytes for Simd<f64, 8>
impl ToBytes for Simd<f64, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#60}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#60}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<f64, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<f64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<f64, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<f64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<f64, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<f64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<f64, 8> as ToBytes>::Bytes) -> Simd<f64, 8>
fn from_ne_bytes(bytes: <Simd<f64, 8> as ToBytes>::Bytes) -> Simd<f64, 8>
portable_simd
#86656)source§impl ToBytes for Simd<i16, 1>
impl ToBytes for Simd<i16, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#33}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#33}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i16, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i16, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i16, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i16, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i16, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i16, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i16, 1> as ToBytes>::Bytes) -> Simd<i16, 1>
fn from_ne_bytes(bytes: <Simd<i16, 1> as ToBytes>::Bytes) -> Simd<i16, 1>
portable_simd
#86656)source§impl ToBytes for Simd<i16, 16>
impl ToBytes for Simd<i16, 16>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#37}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#37}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i16, 16> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i16, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i16, 16> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i16, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i16, 16> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i16, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i16, 16> as ToBytes>::Bytes) -> Simd<i16, 16>
fn from_ne_bytes(bytes: <Simd<i16, 16> as ToBytes>::Bytes) -> Simd<i16, 16>
portable_simd
#86656)source§impl ToBytes for Simd<i16, 2>
impl ToBytes for Simd<i16, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#34}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#34}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i16, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i16, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i16, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i16, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i16, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i16, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i16, 2> as ToBytes>::Bytes) -> Simd<i16, 2>
fn from_ne_bytes(bytes: <Simd<i16, 2> as ToBytes>::Bytes) -> Simd<i16, 2>
portable_simd
#86656)source§impl ToBytes for Simd<i16, 32>
impl ToBytes for Simd<i16, 32>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#38}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#38}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i16, 32> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i16, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i16, 32> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i16, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i16, 32> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i16, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i16, 32> as ToBytes>::Bytes) -> Simd<i16, 32>
fn from_ne_bytes(bytes: <Simd<i16, 32> as ToBytes>::Bytes) -> Simd<i16, 32>
portable_simd
#86656)source§impl ToBytes for Simd<i16, 4>
impl ToBytes for Simd<i16, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#35}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#35}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i16, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i16, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i16, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i16, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i16, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i16, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i16, 4> as ToBytes>::Bytes) -> Simd<i16, 4>
fn from_ne_bytes(bytes: <Simd<i16, 4> as ToBytes>::Bytes) -> Simd<i16, 4>
portable_simd
#86656)source§impl ToBytes for Simd<i16, 8>
impl ToBytes for Simd<i16, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#36}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#36}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i16, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i16, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i16, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i16, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i16, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i16, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i16, 8> as ToBytes>::Bytes) -> Simd<i16, 8>
fn from_ne_bytes(bytes: <Simd<i16, 8> as ToBytes>::Bytes) -> Simd<i16, 8>
portable_simd
#86656)source§impl ToBytes for Simd<i32, 1>
impl ToBytes for Simd<i32, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#39}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#39}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i32, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i32, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i32, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i32, 1> as ToBytes>::Bytes) -> Simd<i32, 1>
fn from_ne_bytes(bytes: <Simd<i32, 1> as ToBytes>::Bytes) -> Simd<i32, 1>
portable_simd
#86656)source§impl ToBytes for Simd<i32, 16>
impl ToBytes for Simd<i32, 16>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#43}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#43}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i32, 16> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i32, 16> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i32, 16> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i32, 16> as ToBytes>::Bytes) -> Simd<i32, 16>
fn from_ne_bytes(bytes: <Simd<i32, 16> as ToBytes>::Bytes) -> Simd<i32, 16>
portable_simd
#86656)source§impl ToBytes for Simd<i32, 2>
impl ToBytes for Simd<i32, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#40}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#40}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i32, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i32, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i32, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i32, 2> as ToBytes>::Bytes) -> Simd<i32, 2>
fn from_ne_bytes(bytes: <Simd<i32, 2> as ToBytes>::Bytes) -> Simd<i32, 2>
portable_simd
#86656)source§impl ToBytes for Simd<i32, 4>
impl ToBytes for Simd<i32, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#41}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#41}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i32, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i32, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i32, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i32, 4> as ToBytes>::Bytes) -> Simd<i32, 4>
fn from_ne_bytes(bytes: <Simd<i32, 4> as ToBytes>::Bytes) -> Simd<i32, 4>
portable_simd
#86656)source§impl ToBytes for Simd<i32, 8>
impl ToBytes for Simd<i32, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#42}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#42}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i32, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i32, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i32, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i32, 8> as ToBytes>::Bytes) -> Simd<i32, 8>
fn from_ne_bytes(bytes: <Simd<i32, 8> as ToBytes>::Bytes) -> Simd<i32, 8>
portable_simd
#86656)source§impl ToBytes for Simd<i64, 1>
impl ToBytes for Simd<i64, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#44}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#44}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i64, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i64, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i64, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i64, 1> as ToBytes>::Bytes) -> Simd<i64, 1>
fn from_ne_bytes(bytes: <Simd<i64, 1> as ToBytes>::Bytes) -> Simd<i64, 1>
portable_simd
#86656)source§impl ToBytes for Simd<i64, 2>
impl ToBytes for Simd<i64, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#45}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#45}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i64, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i64, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i64, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i64, 2> as ToBytes>::Bytes) -> Simd<i64, 2>
fn from_ne_bytes(bytes: <Simd<i64, 2> as ToBytes>::Bytes) -> Simd<i64, 2>
portable_simd
#86656)source§impl ToBytes for Simd<i64, 4>
impl ToBytes for Simd<i64, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#46}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#46}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i64, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i64, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i64, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i64, 4> as ToBytes>::Bytes) -> Simd<i64, 4>
fn from_ne_bytes(bytes: <Simd<i64, 4> as ToBytes>::Bytes) -> Simd<i64, 4>
portable_simd
#86656)source§impl ToBytes for Simd<i64, 8>
impl ToBytes for Simd<i64, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#47}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#47}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i64, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i64, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i64, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i64, 8> as ToBytes>::Bytes) -> Simd<i64, 8>
fn from_ne_bytes(bytes: <Simd<i64, 8> as ToBytes>::Bytes) -> Simd<i64, 8>
portable_simd
#86656)source§impl ToBytes for Simd<i8, 1>
impl ToBytes for Simd<i8, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#26}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#26}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i8, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i8, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i8, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i8, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i8, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i8, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i8, 1> as ToBytes>::Bytes) -> Simd<i8, 1>
fn from_ne_bytes(bytes: <Simd<i8, 1> as ToBytes>::Bytes) -> Simd<i8, 1>
portable_simd
#86656)source§impl ToBytes for Simd<i8, 16>
impl ToBytes for Simd<i8, 16>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#30}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#30}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i8, 16> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i8, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i8, 16> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i8, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i8, 16> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i8, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i8, 16> as ToBytes>::Bytes) -> Simd<i8, 16>
fn from_ne_bytes(bytes: <Simd<i8, 16> as ToBytes>::Bytes) -> Simd<i8, 16>
portable_simd
#86656)source§impl ToBytes for Simd<i8, 2>
impl ToBytes for Simd<i8, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#27}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#27}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i8, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i8, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i8, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i8, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i8, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i8, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i8, 2> as ToBytes>::Bytes) -> Simd<i8, 2>
fn from_ne_bytes(bytes: <Simd<i8, 2> as ToBytes>::Bytes) -> Simd<i8, 2>
portable_simd
#86656)source§impl ToBytes for Simd<i8, 32>
impl ToBytes for Simd<i8, 32>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#31}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#31}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i8, 32> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i8, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i8, 32> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i8, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i8, 32> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i8, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i8, 32> as ToBytes>::Bytes) -> Simd<i8, 32>
fn from_ne_bytes(bytes: <Simd<i8, 32> as ToBytes>::Bytes) -> Simd<i8, 32>
portable_simd
#86656)source§impl ToBytes for Simd<i8, 4>
impl ToBytes for Simd<i8, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#28}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#28}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i8, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i8, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i8, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i8, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i8, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i8, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i8, 4> as ToBytes>::Bytes) -> Simd<i8, 4>
fn from_ne_bytes(bytes: <Simd<i8, 4> as ToBytes>::Bytes) -> Simd<i8, 4>
portable_simd
#86656)source§impl ToBytes for Simd<i8, 64>
impl ToBytes for Simd<i8, 64>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#32}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#32}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i8, 64> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i8, 64> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i8, 64> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i8, 64> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i8, 64> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i8, 64> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i8, 64> as ToBytes>::Bytes) -> Simd<i8, 64>
fn from_ne_bytes(bytes: <Simd<i8, 64> as ToBytes>::Bytes) -> Simd<i8, 64>
portable_simd
#86656)source§impl ToBytes for Simd<i8, 8>
impl ToBytes for Simd<i8, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#29}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#29}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<i8, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<i8, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<i8, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<i8, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<i8, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<i8, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<i8, 8> as ToBytes>::Bytes) -> Simd<i8, 8>
fn from_ne_bytes(bytes: <Simd<i8, 8> as ToBytes>::Bytes) -> Simd<i8, 8>
portable_simd
#86656)source§impl ToBytes for Simd<isize, 1>
impl ToBytes for Simd<isize, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#48}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#48}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<isize, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<isize, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<isize, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<isize, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<isize, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<isize, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<isize, 1> as ToBytes>::Bytes) -> Simd<isize, 1>
fn from_ne_bytes(bytes: <Simd<isize, 1> as ToBytes>::Bytes) -> Simd<isize, 1>
portable_simd
#86656)source§impl ToBytes for Simd<isize, 2>
impl ToBytes for Simd<isize, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#49}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#49}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<isize, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<isize, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<isize, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<isize, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<isize, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<isize, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<isize, 2> as ToBytes>::Bytes) -> Simd<isize, 2>
fn from_ne_bytes(bytes: <Simd<isize, 2> as ToBytes>::Bytes) -> Simd<isize, 2>
portable_simd
#86656)source§impl ToBytes for Simd<isize, 4>
impl ToBytes for Simd<isize, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#50}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#50}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<isize, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<isize, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<isize, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<isize, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<isize, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<isize, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<isize, 4> as ToBytes>::Bytes) -> Simd<isize, 4>
fn from_ne_bytes(bytes: <Simd<isize, 4> as ToBytes>::Bytes) -> Simd<isize, 4>
portable_simd
#86656)source§impl ToBytes for Simd<isize, 8>
impl ToBytes for Simd<isize, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#51}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#51}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<isize, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<isize, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<isize, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<isize, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<isize, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<isize, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<isize, 8> as ToBytes>::Bytes) -> Simd<isize, 8>
fn from_ne_bytes(bytes: <Simd<isize, 8> as ToBytes>::Bytes) -> Simd<isize, 8>
portable_simd
#86656)source§impl ToBytes for Simd<u16, 1>
impl ToBytes for Simd<u16, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#7}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#7}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u16, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u16, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u16, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u16, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u16, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u16, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u16, 1> as ToBytes>::Bytes) -> Simd<u16, 1>
fn from_ne_bytes(bytes: <Simd<u16, 1> as ToBytes>::Bytes) -> Simd<u16, 1>
portable_simd
#86656)source§impl ToBytes for Simd<u16, 16>
impl ToBytes for Simd<u16, 16>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#11}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#11}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u16, 16> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u16, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u16, 16> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u16, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u16, 16> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u16, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u16, 16> as ToBytes>::Bytes) -> Simd<u16, 16>
fn from_ne_bytes(bytes: <Simd<u16, 16> as ToBytes>::Bytes) -> Simd<u16, 16>
portable_simd
#86656)source§impl ToBytes for Simd<u16, 2>
impl ToBytes for Simd<u16, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#8}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#8}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u16, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u16, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u16, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u16, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u16, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u16, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u16, 2> as ToBytes>::Bytes) -> Simd<u16, 2>
fn from_ne_bytes(bytes: <Simd<u16, 2> as ToBytes>::Bytes) -> Simd<u16, 2>
portable_simd
#86656)source§impl ToBytes for Simd<u16, 32>
impl ToBytes for Simd<u16, 32>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#12}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#12}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u16, 32> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u16, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u16, 32> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u16, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u16, 32> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u16, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u16, 32> as ToBytes>::Bytes) -> Simd<u16, 32>
fn from_ne_bytes(bytes: <Simd<u16, 32> as ToBytes>::Bytes) -> Simd<u16, 32>
portable_simd
#86656)source§impl ToBytes for Simd<u16, 4>
impl ToBytes for Simd<u16, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#9}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#9}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u16, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u16, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u16, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u16, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u16, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u16, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u16, 4> as ToBytes>::Bytes) -> Simd<u16, 4>
fn from_ne_bytes(bytes: <Simd<u16, 4> as ToBytes>::Bytes) -> Simd<u16, 4>
portable_simd
#86656)source§impl ToBytes for Simd<u16, 8>
impl ToBytes for Simd<u16, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#10}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#10}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u16, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u16, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u16, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u16, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u16, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u16, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u16, 8> as ToBytes>::Bytes) -> Simd<u16, 8>
fn from_ne_bytes(bytes: <Simd<u16, 8> as ToBytes>::Bytes) -> Simd<u16, 8>
portable_simd
#86656)source§impl ToBytes for Simd<u32, 1>
impl ToBytes for Simd<u32, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#13}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#13}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u32, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u32, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u32, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u32, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u32, 1> as ToBytes>::Bytes) -> Simd<u32, 1>
fn from_ne_bytes(bytes: <Simd<u32, 1> as ToBytes>::Bytes) -> Simd<u32, 1>
portable_simd
#86656)source§impl ToBytes for Simd<u32, 16>
impl ToBytes for Simd<u32, 16>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#17}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#17}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u32, 16> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u32, 16> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u32, 16> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u32, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u32, 16> as ToBytes>::Bytes) -> Simd<u32, 16>
fn from_ne_bytes(bytes: <Simd<u32, 16> as ToBytes>::Bytes) -> Simd<u32, 16>
portable_simd
#86656)source§impl ToBytes for Simd<u32, 2>
impl ToBytes for Simd<u32, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#14}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#14}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u32, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u32, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u32, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u32, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u32, 2> as ToBytes>::Bytes) -> Simd<u32, 2>
fn from_ne_bytes(bytes: <Simd<u32, 2> as ToBytes>::Bytes) -> Simd<u32, 2>
portable_simd
#86656)source§impl ToBytes for Simd<u32, 4>
impl ToBytes for Simd<u32, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#15}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#15}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u32, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u32, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u32, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u32, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u32, 4> as ToBytes>::Bytes) -> Simd<u32, 4>
fn from_ne_bytes(bytes: <Simd<u32, 4> as ToBytes>::Bytes) -> Simd<u32, 4>
portable_simd
#86656)source§impl ToBytes for Simd<u32, 8>
impl ToBytes for Simd<u32, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#16}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#16}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u32, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u32, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u32, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u32, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u32, 8> as ToBytes>::Bytes) -> Simd<u32, 8>
fn from_ne_bytes(bytes: <Simd<u32, 8> as ToBytes>::Bytes) -> Simd<u32, 8>
portable_simd
#86656)source§impl ToBytes for Simd<u64, 1>
impl ToBytes for Simd<u64, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#18}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#18}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u64, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u64, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u64, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u64, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u64, 1> as ToBytes>::Bytes) -> Simd<u64, 1>
fn from_ne_bytes(bytes: <Simd<u64, 1> as ToBytes>::Bytes) -> Simd<u64, 1>
portable_simd
#86656)source§impl ToBytes for Simd<u64, 2>
impl ToBytes for Simd<u64, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#19}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#19}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u64, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u64, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u64, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u64, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u64, 2> as ToBytes>::Bytes) -> Simd<u64, 2>
fn from_ne_bytes(bytes: <Simd<u64, 2> as ToBytes>::Bytes) -> Simd<u64, 2>
portable_simd
#86656)source§impl ToBytes for Simd<u64, 4>
impl ToBytes for Simd<u64, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#20}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#20}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u64, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u64, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u64, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u64, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u64, 4> as ToBytes>::Bytes) -> Simd<u64, 4>
fn from_ne_bytes(bytes: <Simd<u64, 4> as ToBytes>::Bytes) -> Simd<u64, 4>
portable_simd
#86656)source§impl ToBytes for Simd<u64, 8>
impl ToBytes for Simd<u64, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#21}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#21}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u64, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u64, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u64, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u64, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u64, 8> as ToBytes>::Bytes) -> Simd<u64, 8>
fn from_ne_bytes(bytes: <Simd<u64, 8> as ToBytes>::Bytes) -> Simd<u64, 8>
portable_simd
#86656)source§impl ToBytes for Simd<u8, 1>
impl ToBytes for Simd<u8, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#0}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#0}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u8, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u8, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u8, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u8, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u8, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u8, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u8, 1> as ToBytes>::Bytes) -> Simd<u8, 1>
fn from_ne_bytes(bytes: <Simd<u8, 1> as ToBytes>::Bytes) -> Simd<u8, 1>
portable_simd
#86656)source§impl ToBytes for Simd<u8, 16>
impl ToBytes for Simd<u8, 16>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#4}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#4}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u8, 16> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u8, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u8, 16> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u8, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u8, 16> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u8, 16> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u8, 16> as ToBytes>::Bytes) -> Simd<u8, 16>
fn from_ne_bytes(bytes: <Simd<u8, 16> as ToBytes>::Bytes) -> Simd<u8, 16>
portable_simd
#86656)source§impl ToBytes for Simd<u8, 2>
impl ToBytes for Simd<u8, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#1}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#1}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u8, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u8, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u8, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u8, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u8, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u8, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u8, 2> as ToBytes>::Bytes) -> Simd<u8, 2>
fn from_ne_bytes(bytes: <Simd<u8, 2> as ToBytes>::Bytes) -> Simd<u8, 2>
portable_simd
#86656)source§impl ToBytes for Simd<u8, 32>
impl ToBytes for Simd<u8, 32>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#5}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#5}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u8, 32> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u8, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u8, 32> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u8, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u8, 32> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u8, 32> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u8, 32> as ToBytes>::Bytes) -> Simd<u8, 32>
fn from_ne_bytes(bytes: <Simd<u8, 32> as ToBytes>::Bytes) -> Simd<u8, 32>
portable_simd
#86656)source§impl ToBytes for Simd<u8, 4>
impl ToBytes for Simd<u8, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#2}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#2}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u8, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u8, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u8, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u8, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u8, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u8, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u8, 4> as ToBytes>::Bytes) -> Simd<u8, 4>
fn from_ne_bytes(bytes: <Simd<u8, 4> as ToBytes>::Bytes) -> Simd<u8, 4>
portable_simd
#86656)source§impl ToBytes for Simd<u8, 64>
impl ToBytes for Simd<u8, 64>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#6}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#6}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u8, 64> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u8, 64> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u8, 64> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u8, 64> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u8, 64> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u8, 64> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u8, 64> as ToBytes>::Bytes) -> Simd<u8, 64>
fn from_ne_bytes(bytes: <Simd<u8, 64> as ToBytes>::Bytes) -> Simd<u8, 64>
portable_simd
#86656)source§impl ToBytes for Simd<u8, 8>
impl ToBytes for Simd<u8, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#3}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#3}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<u8, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<u8, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<u8, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<u8, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<u8, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<u8, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<u8, 8> as ToBytes>::Bytes) -> Simd<u8, 8>
fn from_ne_bytes(bytes: <Simd<u8, 8> as ToBytes>::Bytes) -> Simd<u8, 8>
portable_simd
#86656)source§impl ToBytes for Simd<usize, 1>
impl ToBytes for Simd<usize, 1>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#22}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#22}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<usize, 1> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<usize, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<usize, 1> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<usize, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<usize, 1> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<usize, 1> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<usize, 1> as ToBytes>::Bytes) -> Simd<usize, 1>
fn from_ne_bytes(bytes: <Simd<usize, 1> as ToBytes>::Bytes) -> Simd<usize, 1>
portable_simd
#86656)source§impl ToBytes for Simd<usize, 2>
impl ToBytes for Simd<usize, 2>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#23}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#23}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<usize, 2> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<usize, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<usize, 2> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<usize, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<usize, 2> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<usize, 2> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<usize, 2> as ToBytes>::Bytes) -> Simd<usize, 2>
fn from_ne_bytes(bytes: <Simd<usize, 2> as ToBytes>::Bytes) -> Simd<usize, 2>
portable_simd
#86656)source§impl ToBytes for Simd<usize, 4>
impl ToBytes for Simd<usize, 4>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#24}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#24}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<usize, 4> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<usize, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<usize, 4> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<usize, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<usize, 4> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<usize, 4> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<usize, 4> as ToBytes>::Bytes) -> Simd<usize, 4>
fn from_ne_bytes(bytes: <Simd<usize, 4> as ToBytes>::Bytes) -> Simd<usize, 4>
portable_simd
#86656)source§impl ToBytes for Simd<usize, 8>
impl ToBytes for Simd<usize, 8>
§type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#25}::Bytes::{constant#0}>
type Bytes = Simd<u8, core::::core_simd::to_bytes::{impl#25}::Bytes::{constant#0}>
portable_simd
#86656)source§fn to_ne_bytes(self) -> <Simd<usize, 8> as ToBytes>::Bytes
fn to_ne_bytes(self) -> <Simd<usize, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_be_bytes(self) -> <Simd<usize, 8> as ToBytes>::Bytes
fn to_be_bytes(self) -> <Simd<usize, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn to_le_bytes(self) -> <Simd<usize, 8> as ToBytes>::Bytes
fn to_le_bytes(self) -> <Simd<usize, 8> as ToBytes>::Bytes
portable_simd
#86656)source§fn from_ne_bytes(bytes: <Simd<usize, 8> as ToBytes>::Bytes) -> Simd<usize, 8>
fn from_ne_bytes(bytes: <Simd<usize, 8> as ToBytes>::Bytes) -> Simd<usize, 8>
portable_simd
#86656)