#[repr(simd)]pub struct Simd<T, const LANES: usize>(_)
where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount;
Expand description
A SIMD vector of LANES
elements of type T
.
Implementations
sourceimpl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> i8
pub fn horizontal_sum(self) -> i8
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> i8
pub fn horizontal_product(self) -> i8
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> i8
pub fn horizontal_max(self) -> i8
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> i8
pub fn horizontal_min(self) -> i8
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> i16
pub fn horizontal_sum(self) -> i16
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> i16
pub fn horizontal_product(self) -> i16
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> i16
pub fn horizontal_max(self) -> i16
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> i16
pub fn horizontal_min(self) -> i16
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> i32
pub fn horizontal_sum(self) -> i32
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> i32
pub fn horizontal_product(self) -> i32
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> i32
pub fn horizontal_max(self) -> i32
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> i32
pub fn horizontal_min(self) -> i32
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> i64
pub fn horizontal_sum(self) -> i64
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> i64
pub fn horizontal_product(self) -> i64
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> i64
pub fn horizontal_max(self) -> i64
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> i64
pub fn horizontal_min(self) -> i64
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> isize
pub fn horizontal_sum(self) -> isize
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> isize
pub fn horizontal_product(self) -> isize
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> isize
pub fn horizontal_max(self) -> isize
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> isize
pub fn horizontal_min(self) -> isize
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> u8
pub fn horizontal_sum(self) -> u8
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> u8
pub fn horizontal_product(self) -> u8
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> u8
pub fn horizontal_max(self) -> u8
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> u8
pub fn horizontal_min(self) -> u8
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> u16
pub fn horizontal_sum(self) -> u16
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> u16
pub fn horizontal_product(self) -> u16
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> u16
pub fn horizontal_max(self) -> u16
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> u16
pub fn horizontal_min(self) -> u16
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> u32
pub fn horizontal_sum(self) -> u32
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> u32
pub fn horizontal_product(self) -> u32
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> u32
pub fn horizontal_max(self) -> u32
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> u32
pub fn horizontal_min(self) -> u32
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> u64
pub fn horizontal_sum(self) -> u64
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> u64
pub fn horizontal_product(self) -> u64
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> u64
pub fn horizontal_max(self) -> u64
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> u64
pub fn horizontal_min(self) -> u64
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> usize
pub fn horizontal_sum(self) -> usize
Horizontal wrapping add. Returns the sum of the lanes of the vector, with wrapping addition.
sourcepub fn horizontal_product(self) -> usize
pub fn horizontal_product(self) -> usize
Horizontal wrapping multiply. Returns the product of the lanes of the vector, with wrapping multiplication.
sourcepub fn horizontal_max(self) -> usize
pub fn horizontal_max(self) -> usize
Horizontal maximum. Returns the maximum lane in the vector.
sourcepub fn horizontal_min(self) -> usize
pub fn horizontal_min(self) -> usize
Horizontal minimum. Returns the minimum lane in the vector.
sourceimpl<const LANES: usize> Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> f32
pub fn horizontal_sum(self) -> f32
Horizontal add. Returns the sum of the lanes of the vector.
sourcepub fn horizontal_product(self) -> f32
pub fn horizontal_product(self) -> f32
Horizontal multiply. Returns the product of the lanes of the vector.
sourcepub fn horizontal_max(self) -> f32
pub fn horizontal_max(self) -> f32
Horizontal maximum. Returns the maximum lane in the vector.
Returns values based on equality, so a vector containing both 0.
and -0.
may
return either. This function will not return NaN
unless all lanes are NaN
.
sourcepub fn horizontal_min(self) -> f32
pub fn horizontal_min(self) -> f32
Horizontal minimum. Returns the minimum lane in the vector.
Returns values based on equality, so a vector containing both 0.
and -0.
may
return either. This function will not return NaN
unless all lanes are NaN
.
sourceimpl<const LANES: usize> Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_sum(self) -> f64
pub fn horizontal_sum(self) -> f64
Horizontal add. Returns the sum of the lanes of the vector.
sourcepub fn horizontal_product(self) -> f64
pub fn horizontal_product(self) -> f64
Horizontal multiply. Returns the product of the lanes of the vector.
sourcepub fn horizontal_max(self) -> f64
pub fn horizontal_max(self) -> f64
Horizontal maximum. Returns the maximum lane in the vector.
Returns values based on equality, so a vector containing both 0.
and -0.
may
return either. This function will not return NaN
unless all lanes are NaN
.
sourcepub fn horizontal_min(self) -> f64
pub fn horizontal_min(self) -> f64
Horizontal minimum. Returns the minimum lane in the vector.
Returns values based on equality, so a vector containing both 0.
and -0.
may
return either. This function will not return NaN
unless all lanes are NaN
.
sourceimpl<T, const LANES: usize> Simd<T, LANES> where
Self: BitAnd<Self, Output = Self>,
T: SimdElement + BitAnd<T, Output = T>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES> where
Self: BitAnd<Self, Output = Self>,
T: SimdElement + BitAnd<T, Output = T>,
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_and(self) -> T
pub fn horizontal_and(self) -> T
Horizontal bitwise “and”. Returns the cumulative bitwise “and” across the lanes of the vector.
sourceimpl<T, const LANES: usize> Simd<T, LANES> where
Self: BitOr<Self, Output = Self>,
T: SimdElement + BitOr<T, Output = T>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES> where
Self: BitOr<Self, Output = Self>,
T: SimdElement + BitOr<T, Output = T>,
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_or(self) -> T
pub fn horizontal_or(self) -> T
Horizontal bitwise “or”. Returns the cumulative bitwise “or” across the lanes of the vector.
sourceimpl<T, const LANES: usize> Simd<T, LANES> where
Self: BitXor<Self, Output = Self>,
T: SimdElement + BitXor<T, Output = T>,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES> where
Self: BitXor<Self, Output = Self>,
T: SimdElement + BitXor<T, Output = T>,
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn horizontal_xor(self) -> T
pub fn horizontal_xor(self) -> T
Horizontal bitwise “xor”. Returns the cumulative bitwise “xor” across the lanes of the vector.
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 rotate_lanes_left<const OFFSET: usize>(self) -> Self
pub fn rotate_lanes_left<const OFFSET: usize>(self) -> Self
Rotates the vector such that the first OFFSET
elements of the slice move to the end
while the last 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) -> Self
pub fn rotate_lanes_right<const OFFSET: usize>(self) -> Self
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: Self) -> (Self, Self)
pub fn interleave(self, other: Self) -> (Self, Self)
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: Self) -> (Self, Self)
pub fn deinterleave(self, other: Self) -> (Self, Self)
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
T: SimdElement + PartialEq,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES> where
T: SimdElement + PartialEq,
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> Simd<T, LANES> where
T: SimdElement + PartialOrd,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Simd<T, LANES> where
T: SimdElement + PartialOrd,
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn lanes_lt(self, other: Self) -> Mask<T::Mask, LANES>
pub fn lanes_lt(self, other: Self) -> Mask<T::Mask, LANES>
Test if each lane is less than the corresponding lane in other
.
sourcepub fn lanes_gt(self, other: Self) -> Mask<T::Mask, LANES>
pub fn lanes_gt(self, other: Self) -> Mask<T::Mask, LANES>
Test if each lane is greater than the corresponding lane in other
.
sourceimpl<const LANES: usize> Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourceimpl<const LANES: usize> Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourceimpl<const LANES: usize> Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourceimpl<const LANES: usize> Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourceimpl<const LANES: usize> Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourceimpl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourcepub fn saturating_abs(self) -> Self
pub fn saturating_abs(self) -> Self
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));
Runsourcepub fn saturating_neg(self) -> Self
pub fn saturating_neg(self) -> Self
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));
Runsourceimpl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourcepub fn saturating_abs(self) -> Self
pub fn saturating_abs(self) -> Self
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));
Runsourcepub fn saturating_neg(self) -> Self
pub fn saturating_neg(self) -> Self
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));
Runsourceimpl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourcepub fn saturating_abs(self) -> Self
pub fn saturating_abs(self) -> Self
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));
Runsourcepub fn saturating_neg(self) -> Self
pub fn saturating_neg(self) -> Self
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));
Runsourceimpl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourcepub fn saturating_abs(self) -> Self
pub fn saturating_abs(self) -> Self
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));
Runsourcepub fn saturating_neg(self) -> Self
pub fn saturating_neg(self) -> Self
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));
Runsourceimpl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn saturating_add(self, second: Self) -> Self
pub fn saturating_add(self, second: Self) -> Self
sourcepub fn saturating_sub(self, second: Self) -> Self
pub fn saturating_sub(self, second: Self) -> Self
sourcepub fn saturating_abs(self) -> Self
pub fn saturating_abs(self) -> Self
Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.
Examples
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));
Runsourcepub fn saturating_neg(self) -> Self
pub fn saturating_neg(self) -> Self
Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.
Examples
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));
Runsourceimpl<const LANES: usize> Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub unsafe fn to_int_unchecked(self) -> Simd<i32, LANES>
pub unsafe fn to_int_unchecked(self) -> Simd<i32, LANES>
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
sourcepub fn round_from_int(value: Simd<i32, LANES>) -> Self
pub fn round_from_int(value: Simd<i32, LANES>) -> Self
Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.
sourceimpl<const LANES: usize> Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub unsafe fn to_int_unchecked(self) -> Simd<i64, LANES>
pub unsafe fn to_int_unchecked(self) -> Simd<i64, LANES>
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
sourcepub fn round_from_int(value: Simd<i64, LANES>) -> Self
pub fn round_from_int(value: Simd<i64, LANES>) -> Self
Creates a floating-point vector from an integer vector. Rounds values that are not exactly representable.
sourceimpl<const LANES: usize> Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn to_bits(self) -> Simd<u32, LANES>
pub fn to_bits(self) -> Simd<u32, LANES>
Raw transmutation to an unsigned integer vector type with the same size and number of lanes.
sourcepub fn from_bits(bits: Simd<u32, LANES>) -> Self
pub fn from_bits(bits: Simd<u32, LANES>) -> Self
Raw transmutation from an unsigned integer vector type with the same size and number of lanes.
sourcepub fn abs(self) -> Self
pub fn abs(self) -> Self
Produces a vector where every lane has the absolute value of the
equivalently-indexed lane in self
.
sourcepub fn to_degrees(self) -> Self
pub fn to_degrees(self) -> Self
Converts each lane from radians to degrees.
sourcepub fn to_radians(self) -> Self
pub fn to_radians(self) -> Self
Converts each lane from degrees to radians.
sourcepub fn is_sign_positive(self) -> Mask<i32, LANES>
pub fn is_sign_positive(self) -> Mask<i32, LANES>
Returns true for each lane if it has a positive sign, including
+0.0
, NaN
s with positive sign bit and positive infinity.
sourcepub fn is_sign_negative(self) -> Mask<i32, LANES>
pub fn is_sign_negative(self) -> Mask<i32, LANES>
Returns true for each lane if it has a negative sign, including
-0.0
, NaN
s with negative sign bit and negative infinity.
sourcepub fn is_infinite(self) -> Mask<i32, LANES>
pub fn is_infinite(self) -> Mask<i32, LANES>
Returns true for each lane if its value is positive infinity or negative infinity.
sourcepub fn is_finite(self) -> Mask<i32, LANES>
pub fn is_finite(self) -> Mask<i32, LANES>
Returns true for each lane if its value is neither infinite nor NaN
.
sourcepub fn is_subnormal(self) -> Mask<i32, LANES>
pub fn is_subnormal(self) -> Mask<i32, LANES>
Returns true for each lane if its value is subnormal.
sourcepub fn is_normal(self) -> Mask<i32, LANES>
pub fn is_normal(self) -> Mask<i32, LANES>
Returns true for each lane if its value is neither zero, infinite,
subnormal, nor NaN
.
sourcepub fn signum(self) -> Self
pub fn signum(self) -> Self
Replaces each lane with a number that represents its sign.
1.0
if the number is positive,+0.0
, orINFINITY
-1.0
if the number is negative,-0.0
, orNEG_INFINITY
NAN
if the number isNAN
sourcepub fn copysign(self, sign: Self) -> Self
pub fn copysign(self, sign: Self) -> Self
Returns each lane with the magnitude of self
and the sign of sign
.
If any lane is a NAN
, then a NAN
with the sign of sign
is returned.
sourcepub fn min(self, other: Self) -> Self
pub fn min(self, other: Self) -> Self
Returns the minimum of each lane.
If one of the values is NAN
, then the other value is returned.
sourcepub fn max(self, other: Self) -> Self
pub fn max(self, other: Self) -> Self
Returns the maximum of each lane.
If one of the values is NAN
, then the other value is returned.
sourcepub fn clamp(self, min: Self, max: Self) -> Self
pub fn clamp(self, min: Self, max: Self) -> Self
Restrict each lane to a certain interval unless it is NaN.
For each lane in self
, returns the corresponding lane in max
if the lane is
greater than max
, and the corresponding lane in min
if the lane is less
than min
. Otherwise returns the lane in self
.
sourceimpl<const LANES: usize> Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn to_bits(self) -> Simd<u64, LANES>
pub fn to_bits(self) -> Simd<u64, LANES>
Raw transmutation to an unsigned integer vector type with the same size and number of lanes.
sourcepub fn from_bits(bits: Simd<u64, LANES>) -> Self
pub fn from_bits(bits: Simd<u64, LANES>) -> Self
Raw transmutation from an unsigned integer vector type with the same size and number of lanes.
sourcepub fn abs(self) -> Self
pub fn abs(self) -> Self
Produces a vector where every lane has the absolute value of the
equivalently-indexed lane in self
.
sourcepub fn to_degrees(self) -> Self
pub fn to_degrees(self) -> Self
Converts each lane from radians to degrees.
sourcepub fn to_radians(self) -> Self
pub fn to_radians(self) -> Self
Converts each lane from degrees to radians.
sourcepub fn is_sign_positive(self) -> Mask<i64, LANES>
pub fn is_sign_positive(self) -> Mask<i64, LANES>
Returns true for each lane if it has a positive sign, including
+0.0
, NaN
s with positive sign bit and positive infinity.
sourcepub fn is_sign_negative(self) -> Mask<i64, LANES>
pub fn is_sign_negative(self) -> Mask<i64, LANES>
Returns true for each lane if it has a negative sign, including
-0.0
, NaN
s with negative sign bit and negative infinity.
sourcepub fn is_infinite(self) -> Mask<i64, LANES>
pub fn is_infinite(self) -> Mask<i64, LANES>
Returns true for each lane if its value is positive infinity or negative infinity.
sourcepub fn is_finite(self) -> Mask<i64, LANES>
pub fn is_finite(self) -> Mask<i64, LANES>
Returns true for each lane if its value is neither infinite nor NaN
.
sourcepub fn is_subnormal(self) -> Mask<i64, LANES>
pub fn is_subnormal(self) -> Mask<i64, LANES>
Returns true for each lane if its value is subnormal.
sourcepub fn is_normal(self) -> Mask<i64, LANES>
pub fn is_normal(self) -> Mask<i64, LANES>
Returns true for each lane if its value is neither zero, infinite,
subnormal, nor NaN
.
sourcepub fn signum(self) -> Self
pub fn signum(self) -> Self
Replaces each lane with a number that represents its sign.
1.0
if the number is positive,+0.0
, orINFINITY
-1.0
if the number is negative,-0.0
, orNEG_INFINITY
NAN
if the number isNAN
sourcepub fn copysign(self, sign: Self) -> Self
pub fn copysign(self, sign: Self) -> Self
Returns each lane with the magnitude of self
and the sign of sign
.
If any lane is a NAN
, then a NAN
with the sign of sign
is returned.
sourcepub fn min(self, other: Self) -> Self
pub fn min(self, other: Self) -> Self
Returns the minimum of each lane.
If one of the values is NAN
, then the other value is returned.
sourcepub fn max(self, other: Self) -> Self
pub fn max(self, other: Self) -> Self
Returns the maximum of each lane.
If one of the values is NAN
, then the other value is returned.
sourcepub fn clamp(self, min: Self, max: Self) -> Self
pub fn clamp(self, min: Self, max: Self) -> Self
Restrict each lane to a certain interval unless it is NaN.
For each lane in self
, returns the corresponding lane in max
if the lane is
greater than max
, and the corresponding lane in min
if the lane is less
than min
. Otherwise returns the lane in self
.
sourceimpl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn is_positive(self) -> Mask<isize, LANES>
pub fn is_positive(self) -> Mask<isize, LANES>
Returns true for each positive lane and false if it is zero or negative.
sourcepub fn is_negative(self) -> Mask<isize, LANES>
pub fn is_negative(self) -> Mask<isize, LANES>
Returns true for each negative lane and false if it is zero or positive.
sourceimpl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn is_positive(self) -> Mask<i16, LANES>
pub fn is_positive(self) -> Mask<i16, LANES>
Returns true for each positive lane and false if it is zero or negative.
sourcepub fn is_negative(self) -> Mask<i16, LANES>
pub fn is_negative(self) -> Mask<i16, LANES>
Returns true for each negative lane and false if it is zero or positive.
sourceimpl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn is_positive(self) -> Mask<i32, LANES>
pub fn is_positive(self) -> Mask<i32, LANES>
Returns true for each positive lane and false if it is zero or negative.
sourcepub fn is_negative(self) -> Mask<i32, LANES>
pub fn is_negative(self) -> Mask<i32, LANES>
Returns true for each negative lane and false if it is zero or positive.
sourceimpl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn is_positive(self) -> Mask<i64, LANES>
pub fn is_positive(self) -> Mask<i64, LANES>
Returns true for each positive lane and false if it is zero or negative.
sourcepub fn is_negative(self) -> Mask<i64, LANES>
pub fn is_negative(self) -> Mask<i64, LANES>
Returns true for each negative lane and false if it is zero or positive.
sourceimpl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourcepub fn is_positive(self) -> Mask<i8, LANES>
pub fn is_positive(self) -> Mask<i8, LANES>
Returns true for each positive lane and false if it is zero or negative.
sourcepub fn is_negative(self) -> Mask<i8, LANES>
pub fn is_negative(self) -> Mask<i8, LANES>
Returns true for each negative lane and false if it is zero or positive.
sourceimpl<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 fn splat(value: T) -> Self
pub const fn splat(value: T) -> Self
Construct a SIMD vector by setting all lanes to the given value.
sourcepub const fn as_array(&self) -> &[T; LANES]
pub const fn as_array(&self) -> &[T; LANES]
Returns an array reference containing the entire SIMD vector.
sourcepub fn as_mut_array(&mut self) -> &mut [T; LANES]
pub fn as_mut_array(&mut self) -> &mut [T; LANES]
Returns a mutable array reference containing the entire SIMD vector.
sourcepub const fn from_array(array: [T; LANES]) -> Self
pub const fn from_array(array: [T; LANES]) -> Self
Converts an array to a SIMD vector.
sourcepub const fn from_slice(slice: &[T]) -> Self
pub const fn from_slice(slice: &[T]) -> Self
Converts a slice to a SIMD vector containing slice[..LANES]
Panics
from_slice
will panic if the slice’s len
is less than the vector’s Simd::LANES
.
sourcepub fn cast<U: SimdElement>(self) -> Simd<U, LANES>
pub fn cast<U: SimdElement>(self) -> Simd<U, LANES>
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 fn gather_or(slice: &[T], idxs: Simd<usize, LANES>, or: Self) -> Self
pub fn gather_or(slice: &[T], idxs: Simd<usize, LANES>, or: Self) -> Self
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>) -> Self where
T: Default,
pub fn gather_or_default(slice: &[T], idxs: Simd<usize, LANES>) -> Self where
T: Default,
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: Self
) -> Self
pub fn gather_select(
slice: &[T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Self
) -> Self
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: Self
) -> Self
pub unsafe fn gather_select_unchecked(
slice: &[T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>,
or: Self
) -> Self
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.lanes_lt(Simd::splat(vec.len()));
// We have masked the OOB lane, so it's safe to gather now.
let result = unsafe { Simd::gather_select_unchecked(&vec, enable, idxs, alt) };
assert_eq!(result, Simd::from_array([-5, 13, 10, -2]));
Runsourcepub fn scatter(self, slice: &mut [T], idxs: Simd<usize, LANES>)
pub fn scatter(self, slice: &mut [T], idxs: Simd<usize, LANES>)
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>
)
pub fn scatter_select(
self,
slice: &mut [T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>
)
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>
)
pub unsafe fn scatter_select_unchecked(
self,
slice: &mut [T],
enable: Mask<isize, LANES>,
idxs: Simd<usize, LANES>
)
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.lanes_lt(Simd::splat(vec.len()));
// We have masked the OOB lane, so it's safe to scatter now.
unsafe { vals.scatter_select_unchecked(&mut vec, enable, idxs); }
// index 0's second write is masked, thus was omitted.
assert_eq!(vec, vec![-41, 11, 12, 82, 14, 15, 16, 17, 18]);
RunTrait Implementations
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<'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<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
Self: Add<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> AddAssign<U> for Simd<T, LANES> where
Self: Add<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn add_assign(&mut self, rhs: U)
fn add_assign(&mut self, rhs: U)
Performs the +=
operation. Read more
sourceimpl<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,
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,
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<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<'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<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
Self: BitAnd<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> BitAndAssign<U> for Simd<T, LANES> where
Self: BitAnd<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn bitand_assign(&mut self, rhs: U)
fn bitand_assign(&mut self, rhs: U)
Performs the &=
operation. Read more
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<'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<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
Self: BitOr<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> BitOrAssign<U> for Simd<T, LANES> where
Self: BitOr<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn bitor_assign(&mut self, rhs: U)
fn bitor_assign(&mut self, rhs: U)
Performs the |=
operation. Read more
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<'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<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
Self: BitXor<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> BitXorAssign<U> for Simd<T, LANES> where
Self: BitXor<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn bitxor_assign(&mut self, rhs: U)
fn bitxor_assign(&mut self, rhs: U)
Performs the ^=
operation. Read more
sourceimpl<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<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<'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<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
Self: Div<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> DivAssign<U> for Simd<T, LANES> where
Self: Div<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn div_assign(&mut self, rhs: U)
fn div_assign(&mut self, rhs: U)
Performs the /=
operation. Read more
sourceimpl<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,
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,
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<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<'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<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
Self: Mul<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> MulAssign<U> for Simd<T, LANES> where
Self: Mul<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn mul_assign(&mut self, rhs: U)
fn mul_assign(&mut self, rhs: U)
Performs the *=
operation. Read more
sourceimpl<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<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<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<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<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<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<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<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<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<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,
sourceimpl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialEq,
impl<T, const LANES: usize> PartialEq<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialEq,
sourceimpl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialOrd,
impl<T, const LANES: usize> PartialOrd<Simd<T, LANES>> for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + PartialOrd,
sourcefn partial_cmp(&self, other: &Self) -> Option<Ordering>
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl<'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<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<'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<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
Self: Rem<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> RemAssign<U> for Simd<T, LANES> where
Self: Rem<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn rem_assign(&mut self, rhs: U)
fn rem_assign(&mut self, rhs: U)
Performs the %=
operation. Read more
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<'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<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
Self: Shl<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> ShlAssign<U> for Simd<T, LANES> where
Self: Shl<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn shl_assign(&mut self, rhs: U)
fn shl_assign(&mut self, rhs: U)
Performs the <<=
operation. Read more
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<'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<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
Self: Shr<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> ShrAssign<U> for Simd<T, LANES> where
Self: Shr<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn shr_assign(&mut self, rhs: U)
fn shr_assign(&mut self, rhs: U)
Performs the >>=
operation. Read more
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<'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<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
Self: Sub<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, U, const LANES: usize> SubAssign<U> for Simd<T, LANES> where
Self: Sub<U, Output = Self>,
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
sourcefn sub_assign(&mut self, rhs: U)
fn sub_assign(&mut self, rhs: U)
Performs the -=
operation. Read more
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<f32, LANES>> for Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<f32, LANES>> for Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<f64, LANES>> for Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<f64, LANES>> for Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<'a, const LANES: usize> Sum<&'a Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<'a, const LANES: usize> Sum<&'a Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<f32, LANES>> for Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<f32, LANES>> for Simd<f32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<f64, LANES>> for Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<f64, LANES>> for Simd<f64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<i16, LANES>> for Simd<i16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<i32, LANES>> for Simd<i32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<i64, LANES>> for Simd<i64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<i8, LANES>> for Simd<i8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<isize, LANES>> for Simd<isize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<u16, LANES>> for Simd<u16, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<u32, LANES>> for Simd<u32, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<u64, LANES>> for Simd<u64, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<u8, LANES>> for Simd<u8, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<const LANES: usize> Sum<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
impl<const LANES: usize> Sum<Simd<usize, LANES>> for Simd<usize, LANES> where
LaneCount<LANES>: SupportedLaneCount,
sourceimpl<T, const LANES: usize> UpperExp for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperExp,
impl<T, const LANES: usize> UpperExp for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperExp,
sourceimpl<T, const LANES: usize> UpperHex for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperHex,
impl<T, const LANES: usize> UpperHex for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + UpperHex,
impl<T, const LANES: usize> Copy for Simd<T, LANES> where
T: SimdElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> Eq for Simd<T, LANES> where
LaneCount<LANES>: SupportedLaneCount,
T: SimdElement + Eq,
Auto Trait Implementations
impl<T, const LANES: usize> RefUnwindSafe for Simd<T, LANES> where
T: RefUnwindSafe,
impl<T, const LANES: usize> Send for Simd<T, LANES> where
T: Send,
impl<T, const LANES: usize> Sync for Simd<T, LANES> where
T: Sync,
impl<T, const LANES: usize> Unpin for Simd<T, LANES> where
T: Unpin,
impl<T, const LANES: usize> UnwindSafe for Simd<T, LANES> where
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more