#[repr(simd)]pub struct Simd<T, const LANES: usize>(_)
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount;
portable_simd
#86656)Expand description
A SIMD vector of LANES
elements of type T
. Simd<T, N>
has the same shape as [T; N]
, but operates like T
.
Two vectors of the same type and length will, by convention, support the operators (+, *, etc.) that T
does.
These take the lanes at each index on the left-hand side and right-hand side, perform the operation,
and return the result in the same lane in a vector of equal size. For a given operator, this is equivalent to zipping
the two arrays together and mapping the operator over each lane.
let a0: [i32; 4] = [-2, 0, 2, 4];
let a1 = [10, 9, 8, 7];
let zm_add = a0.zip(a1).map(|(lhs, rhs)| lhs + rhs);
let zm_mul = a0.zip(a1).map(|(lhs, rhs)| lhs * rhs);
// `Simd<T, N>` implements `From<[T; N]>
let (v0, v1) = (Simd::from(a0), Simd::from(a1));
// Which means arrays implement `Into<Simd<T, N>>`.
assert_eq!(v0 + v1, zm_add.into());
assert_eq!(v0 * v1, zm_mul.into());
RunSimd
with integers has the quirk that these operations are also inherently 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 still causes a panic, so you may want to consider using floating point numbers if that is unacceptable.
Layout
Simd<T, N>
has a layout similar to [T; N]
(identical “shapes”), but with a greater alignment.
[T; N]
is aligned to T
, but Simd<T, N>
will have an alignment based on both T
and N
.
It is thus sound to transmute
Simd<T, N>
to [T; N]
, and will typically optimize to zero cost,
but the reverse transmutation is more likely to require a copy the compiler cannot simply elide.
ABI “Features”
Due to Rust’s safety guarantees, Simd<T, N>
is currently passed to and from functions via memory, not SIMD registers,
except as an optimization. #[inline]
hints are recommended on functions that accept Simd<T, N>
or return it.
The need for this may be corrected in the future.
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)- the likely source for reading or destination for writing
Simd<T, N>
is[T]
and similar types, aligned toT
- combining these actions would violate the
unsafe
contract and explode 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 suffer no performance penalty for “unaligned” reads and writes that are aligned at runtime
By imposing less obligations, unaligned functions 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 sufficient, then it is most ideal to design data structures to be already aligned
to the Simd<T, N>
you wish to use before using unsafe
Rust to read or write.
More conventional 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
sourceimpl<T, const LANES: usize> Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn reverse(self) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn reverse(self) -> Simd<T, LANES>
portable_simd
#86656)Reverse the order of the lanes in the vector.
sourcepub fn rotate_lanes_left<const OFFSET: usize>(self) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn rotate_lanes_left<const OFFSET: usize>(self) -> Simd<T, LANES>
portable_simd
#86656)Rotates the vector such that the first OFFSET
elements of the slice move to the end
while the last LANES - OFFSET
elements move to the front. After calling rotate_lanes_left
,
the element previously in lane OFFSET
will become the first element in the slice.
sourcepub fn rotate_lanes_right<const OFFSET: usize>(self) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn rotate_lanes_right<const OFFSET: usize>(self) -> Simd<T, LANES>
portable_simd
#86656)Rotates the vector such that the first LANES - OFFSET
elements of the vector move to
the end while the last OFFSET
elements move to the front. After calling rotate_lanes_right
,
the element previously at index LANES - OFFSET
will become the first element in the slice.
sourcepub fn interleave(
self,
other: Simd<T, LANES>
) -> (Simd<T, LANES>, Simd<T, LANES>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn interleave(
self,
other: Simd<T, LANES>
) -> (Simd<T, LANES>, Simd<T, LANES>)
portable_simd
#86656)Interleave two vectors.
Produces two vectors with lanes taken alternately from self
and other
.
The first result contains the first LANES / 2
lanes from self
and other
,
alternating, starting with the first lane of self
.
The second result contains the last LANES / 2
lanes from self
and other
,
alternating, starting with the lane LANES / 2
from the start of self
.
#![feature(portable_simd)]
let a = Simd::from_array([0, 1, 2, 3]);
let b = Simd::from_array([4, 5, 6, 7]);
let (x, y) = a.interleave(b);
assert_eq!(x.to_array(), [0, 4, 1, 5]);
assert_eq!(y.to_array(), [2, 6, 3, 7]);
Runsourcepub fn deinterleave(
self,
other: Simd<T, LANES>
) -> (Simd<T, LANES>, Simd<T, LANES>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn deinterleave(
self,
other: Simd<T, LANES>
) -> (Simd<T, LANES>, Simd<T, LANES>)
portable_simd
#86656)Deinterleave two vectors.
The first result takes every other lane of self
and then other
, starting with
the first lane.
The second result takes every other lane of self
and then other
, starting with
the second lane.
#![feature(portable_simd)]
let a = Simd::from_array([0, 4, 1, 5]);
let b = Simd::from_array([2, 6, 3, 7]);
let (x, y) = a.deinterleave(b);
assert_eq!(x.to_array(), [0, 1, 2, 3]);
assert_eq!(y.to_array(), [4, 5, 6, 7]);
Runsourceimpl<T, const LANES: usize> Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
sourcepub const LANES: usize = LANES
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const LANES: usize = LANES
portable_simd
#86656)Number of lanes in this vector.
sourcepub const fn lanes(&self) -> usize
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn lanes(&self) -> usize
portable_simd
#86656)sourcepub fn splat(value: T) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn splat(value: T) -> Simd<T, LANES>
portable_simd
#86656)sourcepub const fn as_array(&self) -> &[T; LANES]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn as_array(&self) -> &[T; LANES]
portable_simd
#86656)sourcepub fn as_mut_array(&mut self) -> &mut [T; LANES]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn as_mut_array(&mut self) -> &mut [T; LANES]
portable_simd
#86656)Returns a mutable array reference containing the entire SIMD vector.
sourcepub const fn from_array(array: [T; LANES]) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn from_array(array: [T; LANES]) -> Simd<T, LANES>
portable_simd
#86656)Converts an array to a SIMD vector.
sourcepub const fn to_array(self) -> [T; LANES]
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn to_array(self) -> [T; LANES]
portable_simd
#86656)Converts a SIMD vector to an array.
sourcepub const fn from_slice(slice: &[T]) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub const fn from_slice(slice: &[T]) -> Simd<T, LANES>
portable_simd
#86656)sourcepub fn cast<U>(self) -> Simd<U, LANES>where
U: SimdElement,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn cast<U>(self) -> Simd<U, LANES>where
U: SimdElement,
portable_simd
#86656)Performs lanewise conversion of a SIMD vector’s elements to another SIMD-valid type.
This follows the semantics of Rust’s as
conversion for casting
integers to unsigned integers (interpreting as the other type, so -1
to MAX
),
and from floats to integers (truncating, or saturating at the limits) for each lane,
or vice versa.
Examples
let floats: Simd<f32, 4> = Simd::from_array([1.9, -4.5, f32::INFINITY, f32::NAN]);
let ints = floats.cast::<i32>();
assert_eq!(ints, Simd::from_array([1, -4, i32::MAX, 0]));
// Formally equivalent, but `Simd::cast` can optimize better.
assert_eq!(ints, Simd::from_array(floats.to_array().map(|x| x as i32)));
// The float conversion does not round-trip.
let floats_again = ints.cast();
assert_ne!(floats, floats_again);
assert_eq!(floats_again, Simd::from_array([1.0, -4.0, 2147483647.0, 0.0]));
Runsourcepub unsafe fn to_int_unchecked<I>(self) -> Simd<I, LANES>where
T: FloatToInt<I>,
I: SimdElement,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn to_int_unchecked<I>(self) -> Simd<I, LANES>where
T: FloatToInt<I>,
I: SimdElement,
portable_simd
#86656)Rounds toward zero and converts to the same-width integer type, assuming that the value is finite and fits in that type.
Safety
The value must:
- Not be NaN
- Not be infinite
- Be representable in the return type, after truncating off its fractional part
If these requirements are infeasible or costly, consider using the safe function cast, which saturates on conversion.
sourcepub fn gather_or(
slice: &[T],
idxs: Simd<usize, LANES>,
or: Simd<T, LANES>
) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn gather_or(
slice: &[T],
idxs: Simd<usize, LANES>,
or: Simd<T, LANES>
) -> Simd<T, LANES>
portable_simd
#86656)Reads from potentially discontiguous indices in slice
to construct a SIMD vector.
If an index is out-of-bounds, the lane is instead selected from the or
vector.
Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let result = Simd::gather_or(&vec, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, 15]));
Runsourcepub fn gather_or_default(slice: &[T], idxs: Simd<usize, LANES>) -> Simd<T, LANES>where
T: Default,
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn gather_or_default(slice: &[T], idxs: Simd<usize, LANES>) -> Simd<T, LANES>where
T: Default,
portable_simd
#86656)Reads from potentially discontiguous indices in slice
to construct a SIMD vector.
If an index is out-of-bounds, the lane is set to the default value for the type.
Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let result = Simd::gather_or_default(&vec, idxs); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([0, 13, 10, 15]));
Runsourcepub fn gather_select(
slice: &[T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Simd<T, LANES>
) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn gather_select(
slice: &[T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Simd<T, LANES>
) -> Simd<T, LANES>
portable_simd
#86656)Reads from potentially discontiguous indices in slice
to construct a SIMD vector.
The mask enable
s all true
lanes and disables all false
lanes.
If an index is disabled or is out-of-bounds, the lane is selected from the or
vector.
Examples
let vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 5]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.
let result = Simd::gather_select(&vec, enable, idxs, alt); // Note the lane that is out-of-bounds.
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
Runsourcepub unsafe fn gather_select_unchecked(
slice: &[T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Simd<T, LANES>
) -> Simd<T, LANES>
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn gather_select_unchecked(
slice: &[T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Simd<T, LANES>
) -> Simd<T, LANES>
portable_simd
#86656)Reads from potentially discontiguous indices in slice
to construct a SIMD vector.
The mask enable
s all true
lanes and disables all false
lanes.
If an index is disabled, the lane is selected from the or
vector.
Safety
Calling this function with an 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]);
let alt = Simd::from_array([-5, -4, -3, -2]);
let enable = Mask::from_array([true, true, true, false]); // Note the final mask lane.
// If this mask was used to gather, it would be unsound. Let's fix that.
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));
// We have masked the OOB lane, so it's safe to gather now.
let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
Runsourcepub fn scatter(self, slice: &mut [T], idxs: Simd<usize, LANES>)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn scatter(self, slice: &mut [T], idxs: Simd<usize, LANES>)
portable_simd
#86656)Writes the values in a SIMD vector to potentially discontiguous indices in slice
.
If two lanes in the scattered vector would write to the same index
only the last lane is guaranteed to actually be written.
Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
vals.scatter(&mut vec, idxs); // index 0 receives two writes.
assert_eq!(vec, vec![124, 11, 12, 82, 14, 15, 16, 17, 18]);
Runsourcepub fn scatter_select(
self,
slice: &mut [T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>
)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub fn scatter_select(
self,
slice: &mut [T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>
)
portable_simd
#86656)Writes the values in a SIMD vector to multiple potentially discontiguous indices in slice
.
The mask enable
s all true
lanes and disables all false
lanes.
If an enabled index is out-of-bounds, the lane is not written.
If two enabled lanes in the scattered vector would write to the same index,
only the last lane is guaranteed to actually be written.
Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.
vals.scatter_select(&mut vec, enable, idxs); // index 0's second write is masked, thus omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);
Runsourcepub unsafe fn scatter_select_unchecked(
self,
slice: &mut [T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>
)
🔬This is a nightly-only experimental API. (portable_simd
#86656)
pub unsafe fn scatter_select_unchecked(
self,
slice: &mut [T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>
)
portable_simd
#86656)Writes the values in a SIMD vector to multiple potentially discontiguous indices in slice
.
The mask enable
s all true
lanes and disables all false
lanes.
If two enabled lanes in the scattered vector would write to the same index,
only the last lane is guaranteed to actually be written.
Safety
Calling this function with an enabled out-of-bounds index is undefined behavior, and may lead to memory corruption.
Examples
let mut vec: Vec<i32> = vec![10, 11, 12, 13, 14, 15, 16, 17, 18];
let idxs = Simd::from_array([9, 3, 0, 0]);
let vals = Simd::from_array([-27, 82, -41, 124]);
let enable = Mask::from_array([true, true, true, false]); // Note the mask of the last lane.
// If this mask was used to scatter, it would be unsound. Let's fix that.
let enable = enable & idxs.simd_lt(Simd::splat(vec.len()));
// We have masked the OOB lane, so it's safe to scatter now.
unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }
// index 0's second write is masked, thus was omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);
RunTrait Implementations
sourceimpl<'lhs, 'rhs, T, const LANES: usize> Add<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Add<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Add<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Add<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Add<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Add<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Add<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Add<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Add<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Add<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Add<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Add<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Add<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Add<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> AddAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Add<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> AddAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Add<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn add_assign(&mut self, rhs: U)
fn add_assign(&mut self, rhs: U)
+=
operation. Read moresourceimpl<T, const LANES: usize> AsMut<[T; LANES]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsMut<[T; LANES]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
sourcefn as_mut(&mut self) -> &mut [T; LANES]
fn as_mut(&mut self) -> &mut [T; LANES]
sourceimpl<T, const LANES: usize> AsMut<[T]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsMut<[T]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
sourceimpl<T, const LANES: usize> AsRef<[T; LANES]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsRef<[T; LANES]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
sourcefn as_ref(&self) -> &[T; LANES]
fn as_ref(&self) -> &[T; LANES]
sourceimpl<T, const LANES: usize> AsRef<[T]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> AsRef<[T]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
sourceimpl<T, const LANES: usize> Binary for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Binary,
impl<T, const LANES: usize> Binary for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Binary,
sourceimpl<'lhs, 'rhs, T, const LANES: usize> BitAnd<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> BitAnd<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> BitAnd<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> BitAnd<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> BitAnd<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> BitAnd<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitAnd<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitAnd<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitAnd<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> BitAndAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: BitAnd<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> BitAndAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: BitAnd<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn bitand_assign(&mut self, rhs: U)
fn bitand_assign(&mut self, rhs: U)
&=
operation. Read moresourceimpl<'lhs, 'rhs, T, const LANES: usize> BitOr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitOr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> BitOr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitOr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> BitOr<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitOr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> BitOr<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitOr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> BitOr<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitOr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> BitOr<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitOr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitOr<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitOr<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> BitOrAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: BitOr<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> BitOrAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: BitOr<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn bitor_assign(&mut self, rhs: U)
fn bitor_assign(&mut self, rhs: U)
|=
operation. Read moresourceimpl<'lhs, 'rhs, T, const LANES: usize> BitXor<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitXor<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> BitXor<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitXor<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> BitXor<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitXor<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> BitXor<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitXor<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> BitXor<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitXor<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> BitXor<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: BitXor<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> BitXor<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> BitXor<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> BitXorAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: BitXor<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> BitXorAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: BitXor<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn bitxor_assign(&mut self, rhs: U)
fn bitxor_assign(&mut self, rhs: U)
^=
operation. Read moresourceimpl<T, const LANES: usize> Clone for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Clone for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Debug for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Debug,
impl<T, const LANES: usize> Debug for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Debug,
sourceimpl<T, const LANES: usize> Default for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Default,
impl<T, const LANES: usize> Default for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Default,
sourceimpl<'lhs, 'rhs, T, const LANES: usize> Div<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Div<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Div<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Div<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Div<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Div<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Div<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Div<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Div<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Div<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Div<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Div<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Div<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Div<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> DivAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Div<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> DivAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Div<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn div_assign(&mut self, rhs: U)
fn div_assign(&mut self, rhs: U)
/=
operation. Read moresourceimpl<T, const LANES: usize> From<[T; LANES]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> From<[T; LANES]> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
sourcefn from(array: [T; LANES]) -> Simd<T, LANES>
fn from(array: [T; LANES]) -> Simd<T, LANES>
sourceimpl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES>where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> From<Mask<T, LANES>> for Simd<T, LANES>where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES]where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
impl<T, const LANES: usize> From<Simd<T, LANES>> for [T; LANES]where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement,
sourcefn from(vector: Simd<T, LANES>) -> [T; LANES]
fn from(vector: Simd<T, LANES>) -> [T; LANES]
sourceimpl<T, const LANES: usize> Hash for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Hash,
impl<T, const LANES: usize> Hash for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Hash,
sourceimpl<I, T, const LANES: usize> Index<I> for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<I, T, const LANES: usize> Index<I> for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
sourceimpl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
impl<I, T, const LANES: usize> IndexMut<I> for Simd<T, LANES>where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
I: SliceIndex<[T]>,
sourceimpl<T, const LANES: usize> LowerExp for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerExp,
impl<T, const LANES: usize> LowerExp for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerExp,
sourceimpl<T, const LANES: usize> LowerHex for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerHex,
impl<T, const LANES: usize> LowerHex for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + LowerHex,
sourceimpl<'lhs, 'rhs, T, const LANES: usize> Mul<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Mul<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Mul<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Mul<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Mul<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Mul<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Mul<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Mul<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Mul<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> MulAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Mul<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> MulAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Mul<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn mul_assign(&mut self, rhs: U)
fn mul_assign(&mut self, rhs: U)
*=
operation. Read moresourceimpl<const LANES: usize> Neg for Simd<f32, LANES>where
f32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<f32, LANES>where
f32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Neg for Simd<f64, LANES>where
f64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<f64, LANES>where
f64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Neg for Simd<i16, LANES>where
i16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i16, LANES>where
i16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Neg for Simd<i32, LANES>where
i32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i32, LANES>where
i32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Neg for Simd<i64, LANES>where
i64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i64, LANES>where
i64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Neg for Simd<i8, LANES>where
i8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<i8, LANES>where
i8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Neg for Simd<isize, LANES>where
isize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Neg for Simd<isize, LANES>where
isize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<i16, LANES>where
i16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i16, LANES>where
i16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<i32, LANES>where
i32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i32, LANES>where
i32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<i64, LANES>where
i64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i64, LANES>where
i64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<i8, LANES>where
i8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<i8, LANES>where
i8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<isize, LANES>where
isize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<isize, LANES>where
isize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<u16, LANES>where
u16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u16, LANES>where
u16: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<u32, LANES>where
u32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u32, LANES>where
u32: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<u64, LANES>where
u64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u64, LANES>where
u64: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<u8, LANES>where
u8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<u8, LANES>where
u8: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Not for Simd<usize, LANES>where
usize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Not for Simd<usize, LANES>where
usize: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Octal for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Octal,
impl<T, const LANES: usize> Octal for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Octal,
sourceimpl<T, const LANES: usize> Ord for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Ord,
impl<T, const LANES: usize> Ord for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Ord,
1.21.0 · sourceconst fn max(self, other: Self) -> Self
const fn max(self, other: Self) -> Self
1.21.0 · sourceconst fn min(self, other: Self) -> Self
const fn min(self, other: Self) -> Self
1.50.0 · sourceconst fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
const fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
sourceimpl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialEq<T>,
impl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialEq<T>,
sourceimpl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialOrd<T>,
impl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES>where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialOrd<T>,
sourcefn partial_cmp(&self, other: &Simd<T, LANES>) -> Option<Ordering>
fn partial_cmp(&self, other: &Simd<T, LANES>) -> Option<Ordering>
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl<'a, const LANES: usize> Product<&'a Simd<f32, LANES>> for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<f32, LANES>> for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<f64, LANES>> for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<f64, LANES>> for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<i16, LANES>> for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i16, LANES>> for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<i32, LANES>> for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i32, LANES>> for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<i64, LANES>> for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i64, LANES>> for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<i8, LANES>> for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<i8, LANES>> for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<isize, LANES>> for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<isize, LANES>> for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<u16, LANES>> for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u16, LANES>> for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<u32, LANES>> for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u32, LANES>> for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<u64, LANES>> for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u64, LANES>> for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<u8, LANES>> for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Product<&'a Simd<usize, LANES>> for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Product<&'a Simd<usize, LANES>> for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<f32, LANES>> for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<f32, LANES>> for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<f64, LANES>> for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<f64, LANES>> for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<i16, LANES>> for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i16, LANES>> for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<i32, LANES>> for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i32, LANES>> for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<i64, LANES>> for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i64, LANES>> for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<i8, LANES>> for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<i8, LANES>> for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<isize, LANES>> for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<isize, LANES>> for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<u16, LANES>> for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u16, LANES>> for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<u32, LANES>> for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u32, LANES>> for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<u64, LANES>> for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u64, LANES>> for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<u8, LANES>> for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<u8, LANES>> for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Product<Simd<usize, LANES>> for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Product<Simd<usize, LANES>> for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'lhs, 'rhs, T, const LANES: usize> Rem<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Rem<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Rem<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Rem<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Rem<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Rem<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Rem<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Rem<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Rem<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Rem<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Rem<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Rem<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Rem<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Rem<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> RemAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Rem<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> RemAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Rem<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn rem_assign(&mut self, rhs: U)
fn rem_assign(&mut self, rhs: U)
%=
operation. Read moresourceimpl<'lhs, 'rhs, T, const LANES: usize> Shl<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shl<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Shl<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shl<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Shl<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shl<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Shl<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shl<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Shl<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shl<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Shl<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shl<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shl<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shl<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> ShlAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Shl<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> ShlAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Shl<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn shl_assign(&mut self, rhs: U)
fn shl_assign(&mut self, rhs: U)
<<=
operation. Read moresourceimpl<'lhs, 'rhs, T, const LANES: usize> Shr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Shr<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Shr<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Shr<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Shr<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Shr<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Shr<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Shr<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Shr<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> ShrAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Shr<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> ShrAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Shr<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn shr_assign(&mut self, rhs: U)
fn shr_assign(&mut self, rhs: U)
>>=
operation. Read moresourceimpl<const LANES: usize> SimdFloat for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdFloat for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
portable_simd
#86656)type Scalar = f32
type Scalar = f32
portable_simd
#86656)type Bits = Simd<u32, LANES>
type Bits = Simd<u32, LANES>
portable_simd
#86656)sourcefn to_bits(self) -> Simd<u32, LANES>
fn to_bits(self) -> Simd<u32, LANES>
portable_simd
#86656)sourcefn from_bits(bits: Simd<u32, LANES>) -> Simd<f32, LANES>
fn from_bits(bits: Simd<u32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn abs(self) -> Simd<f32, LANES>
fn abs(self) -> Simd<f32, LANES>
portable_simd
#86656)self
. Read moresourcefn recip(self) -> Simd<f32, LANES>
fn recip(self) -> Simd<f32, LANES>
portable_simd
#86656)1/x
.sourcefn to_degrees(self) -> Simd<f32, LANES>
fn to_degrees(self) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn to_radians(self) -> Simd<f32, LANES>
fn to_radians(self) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn is_sign_positive(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_sign_positive(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)+0.0
, NaN
s with positive sign bit and positive infinity. Read moresourcefn is_sign_negative(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_sign_negative(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)-0.0
, NaN
s with negative sign bit and negative infinity. Read moresourcefn is_nan(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_nan(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
.sourcefn is_infinite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_infinite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)sourcefn is_finite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_finite(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
.sourcefn is_subnormal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_subnormal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)sourcefn is_normal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
fn is_normal(self) -> <Simd<f32, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
. Read moresourcefn signum(self) -> Simd<f32, LANES>
fn signum(self) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn copysign(self, sign: Simd<f32, LANES>) -> Simd<f32, LANES>
fn copysign(self, sign: Simd<f32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn simd_min(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
fn simd_min(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn simd_max(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
fn simd_max(self, other: Simd<f32, LANES>) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn simd_clamp(
self,
min: Simd<f32, LANES>,
max: Simd<f32, LANES>
) -> Simd<f32, LANES>
fn simd_clamp(
self,
min: Simd<f32, LANES>,
max: Simd<f32, LANES>
) -> Simd<f32, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
fn reduce_sum(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
fn reduce_product(self) -> <Simd<f32, LANES> as SimdFloat>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdFloat for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdFloat for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
portable_simd
#86656)type Scalar = f64
type Scalar = f64
portable_simd
#86656)type Bits = Simd<u64, LANES>
type Bits = Simd<u64, LANES>
portable_simd
#86656)sourcefn to_bits(self) -> Simd<u64, LANES>
fn to_bits(self) -> Simd<u64, LANES>
portable_simd
#86656)sourcefn from_bits(bits: Simd<u64, LANES>) -> Simd<f64, LANES>
fn from_bits(bits: Simd<u64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn abs(self) -> Simd<f64, LANES>
fn abs(self) -> Simd<f64, LANES>
portable_simd
#86656)self
. Read moresourcefn recip(self) -> Simd<f64, LANES>
fn recip(self) -> Simd<f64, LANES>
portable_simd
#86656)1/x
.sourcefn to_degrees(self) -> Simd<f64, LANES>
fn to_degrees(self) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn to_radians(self) -> Simd<f64, LANES>
fn to_radians(self) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn is_sign_positive(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_sign_positive(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)+0.0
, NaN
s with positive sign bit and positive infinity. Read moresourcefn is_sign_negative(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_sign_negative(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)-0.0
, NaN
s with negative sign bit and negative infinity. Read moresourcefn is_nan(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_nan(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
.sourcefn is_infinite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_infinite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)sourcefn is_finite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_finite(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
.sourcefn is_subnormal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_subnormal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)sourcefn is_normal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
fn is_normal(self) -> <Simd<f64, LANES> as SimdFloat>::Mask
portable_simd
#86656)NaN
. Read moresourcefn signum(self) -> Simd<f64, LANES>
fn signum(self) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn copysign(self, sign: Simd<f64, LANES>) -> Simd<f64, LANES>
fn copysign(self, sign: Simd<f64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn simd_min(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
fn simd_min(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn simd_max(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
fn simd_max(self, other: Simd<f64, LANES>) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn simd_clamp(
self,
min: Simd<f64, LANES>,
max: Simd<f64, LANES>
) -> Simd<f64, LANES>
fn simd_clamp(
self,
min: Simd<f64, LANES>,
max: Simd<f64, LANES>
) -> Simd<f64, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
fn reduce_sum(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
fn reduce_product(self) -> <Simd<f64, LANES> as SimdFloat>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdInt for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
portable_simd
#86656)type Scalar = i16
type Scalar = i16
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
fn saturating_add(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
fn saturating_sub(self, second: Simd<i16, LANES>) -> Simd<i16, LANES>
portable_simd
#86656)sourcefn abs(self) -> Simd<i16, LANES>
fn abs(self) -> Simd<i16, LANES>
portable_simd
#86656)sourcefn saturating_abs(self) -> Simd<i16, LANES>
fn saturating_abs(self) -> Simd<i16, LANES>
portable_simd
#86656)sourcefn saturating_neg(self) -> Simd<i16, LANES>
fn saturating_neg(self) -> Simd<i16, LANES>
portable_simd
#86656)sourcefn is_positive(self) -> <Simd<i16, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i16, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn is_negative(self) -> <Simd<i16, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i16, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn signum(self) -> Simd<i16, LANES>
fn signum(self) -> Simd<i16, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i16, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdInt for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
portable_simd
#86656)type Scalar = i32
type Scalar = i32
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
fn saturating_add(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
fn saturating_sub(self, second: Simd<i32, LANES>) -> Simd<i32, LANES>
portable_simd
#86656)sourcefn abs(self) -> Simd<i32, LANES>
fn abs(self) -> Simd<i32, LANES>
portable_simd
#86656)sourcefn saturating_abs(self) -> Simd<i32, LANES>
fn saturating_abs(self) -> Simd<i32, LANES>
portable_simd
#86656)sourcefn saturating_neg(self) -> Simd<i32, LANES>
fn saturating_neg(self) -> Simd<i32, LANES>
portable_simd
#86656)sourcefn is_positive(self) -> <Simd<i32, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i32, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn is_negative(self) -> <Simd<i32, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i32, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn signum(self) -> Simd<i32, LANES>
fn signum(self) -> Simd<i32, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i32, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdInt for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
portable_simd
#86656)type Scalar = i64
type Scalar = i64
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
fn saturating_add(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
fn saturating_sub(self, second: Simd<i64, LANES>) -> Simd<i64, LANES>
portable_simd
#86656)sourcefn abs(self) -> Simd<i64, LANES>
fn abs(self) -> Simd<i64, LANES>
portable_simd
#86656)sourcefn saturating_abs(self) -> Simd<i64, LANES>
fn saturating_abs(self) -> Simd<i64, LANES>
portable_simd
#86656)sourcefn saturating_neg(self) -> Simd<i64, LANES>
fn saturating_neg(self) -> Simd<i64, LANES>
portable_simd
#86656)sourcefn is_positive(self) -> <Simd<i64, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i64, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn is_negative(self) -> <Simd<i64, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i64, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn signum(self) -> Simd<i64, LANES>
fn signum(self) -> Simd<i64, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i64, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdInt for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i8 as SimdElement>::Mask, LANES>
type Mask = Mask<<i8 as SimdElement>::Mask, LANES>
portable_simd
#86656)type Scalar = i8
type Scalar = i8
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
fn saturating_add(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
fn saturating_sub(self, second: Simd<i8, LANES>) -> Simd<i8, LANES>
portable_simd
#86656)sourcefn abs(self) -> Simd<i8, LANES>
fn abs(self) -> Simd<i8, LANES>
portable_simd
#86656)sourcefn saturating_abs(self) -> Simd<i8, LANES>
fn saturating_abs(self) -> Simd<i8, LANES>
portable_simd
#86656)sourcefn saturating_neg(self) -> Simd<i8, LANES>
fn saturating_neg(self) -> Simd<i8, LANES>
portable_simd
#86656)sourcefn is_positive(self) -> <Simd<i8, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<i8, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn is_negative(self) -> <Simd<i8, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<i8, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn signum(self) -> Simd<i8, LANES>
fn signum(self) -> Simd<i8, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<i8, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdInt for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdInt for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<isize as SimdElement>::Mask, LANES>
type Mask = Mask<<isize as SimdElement>::Mask, LANES>
portable_simd
#86656)type Scalar = isize
type Scalar = isize
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
fn saturating_add(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
fn saturating_sub(self, second: Simd<isize, LANES>) -> Simd<isize, LANES>
portable_simd
#86656)sourcefn abs(self) -> Simd<isize, LANES>
fn abs(self) -> Simd<isize, LANES>
portable_simd
#86656)sourcefn saturating_abs(self) -> Simd<isize, LANES>
fn saturating_abs(self) -> Simd<isize, LANES>
portable_simd
#86656)sourcefn saturating_neg(self) -> Simd<isize, LANES>
fn saturating_neg(self) -> Simd<isize, LANES>
portable_simd
#86656)sourcefn is_positive(self) -> <Simd<isize, LANES> as SimdInt>::Mask
fn is_positive(self) -> <Simd<isize, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn is_negative(self) -> <Simd<isize, LANES> as SimdInt>::Mask
fn is_negative(self) -> <Simd<isize, LANES> as SimdInt>::Mask
portable_simd
#86656)sourcefn signum(self) -> Simd<isize, LANES>
fn signum(self) -> Simd<isize, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_sum(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_product(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_max(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_min(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
fn reduce_and(self) -> <Simd<isize, LANES> as SimdInt>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdOrd for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<i16, LANES>) -> Simd<i16, LANES>
fn simd_max(self, other: Simd<i16, LANES>) -> Simd<i16, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<i32, LANES>) -> Simd<i32, LANES>
fn simd_max(self, other: Simd<i32, LANES>) -> Simd<i32, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<i64, LANES>) -> Simd<i64, LANES>
fn simd_max(self, other: Simd<i64, LANES>) -> Simd<i64, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<i8, LANES>) -> Simd<i8, LANES>
fn simd_max(self, other: Simd<i8, LANES>) -> Simd<i8, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<isize, LANES>) -> Simd<isize, LANES>
fn simd_max(self, other: Simd<isize, LANES>) -> Simd<isize, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<u16, LANES>) -> Simd<u16, LANES>
fn simd_max(self, other: Simd<u16, LANES>) -> Simd<u16, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<u32, LANES>) -> Simd<u32, LANES>
fn simd_max(self, other: Simd<u32, LANES>) -> Simd<u32, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<u64, LANES>) -> Simd<u64, LANES>
fn simd_max(self, other: Simd<u64, LANES>) -> Simd<u64, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>
fn simd_max(self, other: Simd<u8, LANES>) -> Simd<u8, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdOrd for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdOrd for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_max(self, other: Simd<usize, LANES>) -> Simd<usize, LANES>
fn simd_max(self, other: Simd<usize, LANES>) -> Simd<usize, LANES>
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialEq for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<f32 as SimdElement>::Mask, LANES>
type Mask = Mask<<f32 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<f64 as SimdElement>::Mask, LANES>
type Mask = Mask<<f64 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
type Mask = Mask<<i16 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
type Mask = Mask<<i32 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
type Mask = Mask<<i64 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<i8 as SimdElement>::Mask, LANES>
type Mask = Mask<<i8 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<isize as SimdElement>::Mask, LANES>
type Mask = Mask<<isize as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<u16 as SimdElement>::Mask, LANES>
type Mask = Mask<<u16 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<u32 as SimdElement>::Mask, LANES>
type Mask = Mask<<u32 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<u64 as SimdElement>::Mask, LANES>
type Mask = Mask<<u64 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<u8 as SimdElement>::Mask, LANES>
type Mask = Mask<<u8 as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialEq for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialEq for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Mask = Mask<<usize as SimdElement>::Mask, LANES>
type Mask = Mask<<usize as SimdElement>::Mask, LANES>
portable_simd
#86656)sourceimpl<const LANES: usize> SimdPartialOrd for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<f32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<f32, LANES>
) -> <Simd<f32, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<f32, LANES>
) -> <Simd<f32, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<f32, LANES>
) -> <Simd<f32, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<f32, LANES>
) -> <Simd<f32, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<f64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<f64, LANES>
) -> <Simd<f64, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<f64, LANES>
) -> <Simd<f64, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<f64, LANES>
) -> <Simd<f64, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<f64, LANES>
) -> <Simd<f64, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<i16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<i16, LANES>
) -> <Simd<i16, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<i16, LANES>
) -> <Simd<i16, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<i16, LANES>
) -> <Simd<i16, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<i16, LANES>
) -> <Simd<i16, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<i32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<i32, LANES>
) -> <Simd<i32, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<i32, LANES>
) -> <Simd<i32, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<i32, LANES>
) -> <Simd<i32, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<i32, LANES>
) -> <Simd<i32, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<i64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<i64, LANES>
) -> <Simd<i64, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<i64, LANES>
) -> <Simd<i64, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<i64, LANES>
) -> <Simd<i64, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<i64, LANES>
) -> <Simd<i64, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<i8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<i8, LANES>
) -> <Simd<i8, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<i8, LANES>
) -> <Simd<i8, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<i8, LANES>
) -> <Simd<i8, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<i8, LANES>
) -> <Simd<i8, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<isize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<isize, LANES>
) -> <Simd<isize, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<isize, LANES>
) -> <Simd<isize, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<isize, LANES>
) -> <Simd<isize, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<isize, LANES>
) -> <Simd<isize, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<u16, LANES>
) -> <Simd<u16, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<u16, LANES>
) -> <Simd<u16, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<u16, LANES>
) -> <Simd<u16, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<u16, LANES>
) -> <Simd<u16, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<u32, LANES>
) -> <Simd<u32, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<u32, LANES>
) -> <Simd<u32, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<u32, LANES>
) -> <Simd<u32, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<u32, LANES>
) -> <Simd<u32, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<u64, LANES>
) -> <Simd<u64, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<u64, LANES>
) -> <Simd<u64, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<u64, LANES>
) -> <Simd<u64, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<u64, LANES>
) -> <Simd<u64, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<u8, LANES>
) -> <Simd<u8, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<u8, LANES>
) -> <Simd<u8, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<u8, LANES>
) -> <Simd<u8, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<u8, LANES>
) -> <Simd<u8, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdPartialOrd for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdPartialOrd for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
sourcefn simd_lt(
self,
other: Simd<usize, LANES>
) -> <Simd<usize, LANES> as SimdPartialEq>::Mask
fn simd_lt(
self,
other: Simd<usize, LANES>
) -> <Simd<usize, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourcefn simd_le(
self,
other: Simd<usize, LANES>
) -> <Simd<usize, LANES> as SimdPartialEq>::Mask
fn simd_le(
self,
other: Simd<usize, LANES>
) -> <Simd<usize, LANES> as SimdPartialEq>::Mask
portable_simd
#86656)other
.sourceimpl<const LANES: usize> SimdUint for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdUint for Simd<u16, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Scalar = u16
type Scalar = u16
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>
fn saturating_add(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>
fn saturating_sub(self, second: Simd<u16, LANES>) -> Simd<u16, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u16, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdUint for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdUint for Simd<u32, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Scalar = u32
type Scalar = u32
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>
fn saturating_add(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>
fn saturating_sub(self, second: Simd<u32, LANES>) -> Simd<u32, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u32, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdUint for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdUint for Simd<u64, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Scalar = u64
type Scalar = u64
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>
fn saturating_add(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>
fn saturating_sub(self, second: Simd<u64, LANES>) -> Simd<u64, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u64, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdUint for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdUint for Simd<u8, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Scalar = u8
type Scalar = u8
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>
fn saturating_add(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>
fn saturating_sub(self, second: Simd<u8, LANES>) -> Simd<u8, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<u8, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourceimpl<const LANES: usize> SimdUint for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> SimdUint for Simd<usize, LANES>where
LaneCount<LANES>: SupportedLaneCount,
type Scalar = usize
type Scalar = usize
portable_simd
#86656)sourcefn saturating_add(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>
fn saturating_add(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>
portable_simd
#86656)sourcefn saturating_sub(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>
fn saturating_sub(self, second: Simd<usize, LANES>) -> Simd<usize, LANES>
portable_simd
#86656)sourcefn reduce_sum(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
fn reduce_sum(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_product(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
fn reduce_product(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_max(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
fn reduce_max(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_min(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
fn reduce_min(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourcefn reduce_and(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
fn reduce_and(self) -> <Simd<usize, LANES> as SimdUint>::Scalar
portable_simd
#86656)sourceimpl<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,
sourcefn 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.
sourcefn 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 moresourcefn sqrt(self) -> Self
fn sqrt(self) -> Self
portable_simd
#86656)self
Read moresourcefn ceil(self) -> Self
fn ceil(self) -> Self
portable_simd
#86656)sourcefn floor(self) -> Self
fn floor(self) -> Self
portable_simd
#86656)sourceimpl<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,
sourcefn 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.
sourcefn 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 moresourcefn sqrt(self) -> Self
fn sqrt(self) -> Self
portable_simd
#86656)self
Read moresourcefn ceil(self) -> Self
fn ceil(self) -> Self
portable_simd
#86656)sourcefn floor(self) -> Self
fn floor(self) -> Self
portable_simd
#86656)sourceimpl<'lhs, 'rhs, T, const LANES: usize> Sub<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Sub<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<'lhs, 'rhs, T, const LANES: usize> Sub<&'rhs Simd<T, LANES>> for &'lhs Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Sub<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Sub<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Sub<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Sub<&Simd<T, LANES>> for Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Sub<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Sub<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Sub<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Sub<Simd<T, LANES>> for &Simd<T, LANES>where
T: SimdElement,
Simd<T, LANES>: Sub<Simd<T, LANES>, Output = Simd<T, LANES>>,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<f32, N>> for Simd<f32, N>where
f32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<f64, N>> for Simd<f64, N>where
f64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<i16, N>> for Simd<i16, N>where
i16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<i32, N>> for Simd<i32, N>where
i32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<i64, N>> for Simd<i64, N>where
i64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<i8, N>> for Simd<i8, N>where
i8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<isize, N>> for Simd<isize, N>where
isize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<u16, N>> for Simd<u16, N>where
u16: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<u32, N>> for Simd<u32, N>where
u32: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<u64, N>> for Simd<u64, N>where
u64: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<u8, N>> for Simd<u8, N>where
u8: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<const N: usize> Sub<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
impl<const N: usize> Sub<Simd<usize, N>> for Simd<usize, N>where
usize: SimdElement,
LaneCount<N>: SupportedLaneCount,
sourceimpl<T, U, const LANES: usize> SubAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Sub<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> SubAssign<U> for Simd<T, LANES>where
Simd<T, LANES>: Sub<U, Output = Simd<T, LANES>>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn sub_assign(&mut self, rhs: U)
fn sub_assign(&mut self, rhs: U)
-=
operation. Read more