[−][src]Struct slipstream::vector::Packed4
A packed vector.
See the module documentation and the Vector
trait for details.
Trait Implementations
impl<B, S> Add<Packed4<B, S>> for Packed4<B, S> where
B: Repr + Add<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Add<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the +
operator.
fn add(self, rhs: Self) -> Self
[src]
impl<B, S> AddAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + AddAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + AddAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn add_assign(&mut self, rhs: Self)
[src]
impl<B, S> AsMut<[B]> for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> AsRef<[B]> for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> BitAnd<Packed4<B, S>> for Packed4<B, S> where
B: Repr + BitAnd<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + BitAnd<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the &
operator.
fn bitand(self, rhs: Self) -> Self
[src]
impl<B, S> BitAndAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + BitAndAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + BitAndAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn bitand_assign(&mut self, rhs: Self)
[src]
impl<B, S> BitOr<Packed4<B, S>> for Packed4<B, S> where
B: Repr + BitOr<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + BitOr<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the |
operator.
fn bitor(self, rhs: Self) -> Self
[src]
impl<B, S> BitOrAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + BitOrAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + BitOrAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn bitor_assign(&mut self, rhs: Self)
[src]
impl<B, S> BitXor<Packed4<B, S>> for Packed4<B, S> where
B: Repr + BitXor<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + BitXor<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Self) -> Self
[src]
impl<B, S> BitXorAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + BitXorAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + BitXorAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn bitxor_assign(&mut self, rhs: Self)
[src]
impl<B: Clone, S: Clone> Clone for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn clone(&self) -> Packed4<B, S>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<B: Copy, S: Copy> Copy for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B: Debug, S: Debug> Debug for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B: Default, S: Default> Default for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> Deref for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> DerefMut for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> Div<Packed4<B, S>> for Packed4<B, S> where
B: Repr + Div<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Div<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the /
operator.
fn div(self, rhs: Self) -> Self
[src]
impl<B, S> DivAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + DivAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + DivAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn div_assign(&mut self, rhs: Self)
[src]
impl<B: Eq, S: Eq> Eq for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> Index<usize> for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> IndexMut<usize> for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> Mul<Packed4<B, S>> for Packed4<B, S> where
B: Repr + Mul<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Mul<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, rhs: Self) -> Self
[src]
impl<B, S> MulAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + MulAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + MulAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn mul_assign(&mut self, rhs: Self)
[src]
impl<B, S> Neg for Packed4<B, S> where
B: Repr + Neg<Output = B> + Copy,
S: Unsigned + ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Neg<Output = B> + Copy,
S: Unsigned + ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> Not for Packed4<B, S> where
B: Repr + Not<Output = B> + Copy,
S: Unsigned + ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Not<Output = B> + Copy,
S: Unsigned + ArrayLength<B>,
S::ArrayType: Copy,
impl<B: Ord, S: Ord> Ord for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn cmp(&self, other: &Packed4<B, S>) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<B: PartialEq, S: PartialEq> PartialEq<Packed4<B, S>> for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B: PartialOrd, S: PartialOrd> PartialOrd<Packed4<B, S>> for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn partial_cmp(&self, other: &Packed4<B, S>) -> Option<Ordering>
[src]
fn lt(&self, other: &Packed4<B, S>) -> bool
[src]
fn le(&self, other: &Packed4<B, S>) -> bool
[src]
fn gt(&self, other: &Packed4<B, S>) -> bool
[src]
fn ge(&self, other: &Packed4<B, S>) -> bool
[src]
impl<B, S> Product<Packed4<B, S>> for Packed4<B, S> where
B: Repr + MulAssign,
S: ArrayLength<B>,
S::ArrayType: Copy,
Self: Vector<Base = B, Lanes = S>,
Self::Mask: AsRef<[B::Mask]>,
[src]
B: Repr + MulAssign,
S: ArrayLength<B>,
S::ArrayType: Copy,
Self: Vector<Base = B, Lanes = S>,
Self::Mask: AsRef<[B::Mask]>,
impl<B, S> Rem<Packed4<B, S>> for Packed4<B, S> where
B: Repr + Rem<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Rem<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the %
operator.
fn rem(self, rhs: Self) -> Self
[src]
impl<B, S> RemAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + RemAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + RemAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn rem_assign(&mut self, rhs: Self)
[src]
impl<B, S> Shl<Packed4<B, S>> for Packed4<B, S> where
B: Repr + Shl<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Shl<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the <<
operator.
fn shl(self, rhs: Self) -> Self
[src]
impl<B, S> ShlAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + ShlAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + ShlAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn shl_assign(&mut self, rhs: Self)
[src]
impl<B, S> Shr<Packed4<B, S>> for Packed4<B, S> where
B: Repr + Shr<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Shr<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the >>
operator.
fn shr(self, rhs: Self) -> Self
[src]
impl<B, S> ShrAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + ShrAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + ShrAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn shr_assign(&mut self, rhs: Self)
[src]
impl<B, S> StructuralEq for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> StructuralPartialEq for Packed4<B, S> where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
impl<B, S> Sub<Packed4<B, S>> for Packed4<B, S> where
B: Repr + Sub<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + Sub<Output = B> + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Output = Self
The resulting type after applying the -
operator.
fn sub(self, rhs: Self) -> Self
[src]
impl<B, S> SubAssign<Packed4<B, S>> for Packed4<B, S> where
B: Repr + SubAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr + SubAssign + Copy,
S: ArrayLength<B>,
S::ArrayType: Copy,
fn sub_assign(&mut self, rhs: Self)
[src]
impl<B, S> Sum<Packed4<B, S>> for Packed4<B, S> where
B: Repr + AddAssign,
S: ArrayLength<B>,
S::ArrayType: Copy,
Self: Default,
[src]
B: Repr + AddAssign,
S: ArrayLength<B>,
S::ArrayType: Copy,
Self: Default,
impl<B, S> Vector for Packed4<B, S> where
B: Repr + 'static,
S: ArrayLength<B> + ArrayLength<B::Mask> + 'static,
<S as ArrayLength<B>>::ArrayType: Copy,
<S as ArrayLength<B::Mask>>::ArrayType: Copy,
[src]
B: Repr + 'static,
S: ArrayLength<B> + ArrayLength<B::Mask> + 'static,
<S as ArrayLength<B>>::ArrayType: Copy,
<S as ArrayLength<B::Mask>>::ArrayType: Copy,
type Base = B
Type of one lane of the vector. Read more
type Lanes = S
A type-level integer specifying the length of the vector. Read more
type Mask = Packed4<B::Mask, S>
The mask type for this vector. Read more
unsafe fn new_unchecked(input: *const B) -> Self
[src]
fn splat(value: B) -> Self
[src]
fn gather_load<I, Idx>(input: I, idx: Idx) -> Self where
I: AsRef<[B]>,
Idx: AsRef<[usize]>,
[src]
I: AsRef<[B]>,
Idx: AsRef<[usize]>,
fn gather_load_masked<I, Idx, M, MB>(self, input: I, idx: Idx, mask: M) -> Self where
I: AsRef<[B]>,
Idx: AsRef<[usize]>,
M: AsRef<[MB]>,
MB: Mask,
[src]
I: AsRef<[B]>,
Idx: AsRef<[usize]>,
M: AsRef<[MB]>,
MB: Mask,
fn scatter_store<O, Idx>(self, output: O, idx: Idx) where
O: AsMut<[B]>,
Idx: AsRef<[usize]>,
[src]
O: AsMut<[B]>,
Idx: AsRef<[usize]>,
fn scatter_store_masked<O, Idx, M, MB>(self, output: O, idx: Idx, mask: M) where
O: AsMut<[B]>,
Idx: AsRef<[usize]>,
M: AsRef<[MB]>,
MB: Mask,
[src]
O: AsMut<[B]>,
Idx: AsRef<[usize]>,
M: AsRef<[MB]>,
MB: Mask,
fn blend<M, MB>(self, other: Self, mask: M) -> Self where
M: AsRef<[MB]>,
MB: Mask,
[src]
M: AsRef<[MB]>,
MB: Mask,
fn horizontal_sum(self) -> B where
B: Add<Output = B>,
[src]
B: Add<Output = B>,
fn horizontal_product(self) -> B where
B: Mul<Output = B>,
[src]
B: Mul<Output = B>,
fn eq(self, other: Self) -> Self::Mask where
Self::Base: PartialEq,
[src]
Self::Base: PartialEq,
fn lt(self, other: Self) -> Self::Mask where
Self::Base: PartialOrd,
[src]
Self::Base: PartialOrd,
fn gt(self, other: Self) -> Self::Mask where
Self::Base: PartialOrd,
[src]
Self::Base: PartialOrd,
fn le(self, other: Self) -> Self::Mask where
Self::Base: PartialOrd,
[src]
Self::Base: PartialOrd,
fn ge(self, other: Self) -> Self::Mask where
Self::Base: PartialOrd,
[src]
Self::Base: PartialOrd,
const LANES: usize
[src]
fn new<I>(input: I) -> Self where
I: AsRef<[Self::Base]>,
[src]
I: AsRef<[Self::Base]>,
fn maximum(self, other: Self) -> Self where
Self::Base: PartialOrd,
[src]
Self::Base: PartialOrd,
fn minimum(self, other: Self) -> Self where
Self::Base: PartialOrd,
[src]
Self::Base: PartialOrd,
impl<'a, B, S> Vectorizable<&'a mut Packed4<B, S>> for &'a mut [Packed4<B, S>] where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Padding = ()
The input type provided by user to fill in the padding/uneven end. Read more
type Vectorizer = &'a mut [Packed4<B, S>]
An internal type managing the splitting into vectors. Read more
fn create(
self,
_pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed4<B, S>>)
[src]
self,
_pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed4<B, S>>)
fn vectorize(self) -> VectorizedIter<Self::Vectorizer, (), V>
[src]
fn vectorize_pad(
self,
pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>
[src]
self,
pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>
impl<'a, B, S> Vectorizable<Packed4<B, S>> for &'a [Packed4<B, S>] where
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
[src]
B: Repr,
S: ArrayLength<B>,
S::ArrayType: Copy,
type Padding = ()
The input type provided by user to fill in the padding/uneven end. Read more
type Vectorizer = &'a [Packed4<B, S>]
An internal type managing the splitting into vectors. Read more
fn create(
self,
_pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed4<B, S>>)
[src]
self,
_pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed4<B, S>>)
fn vectorize(self) -> VectorizedIter<Self::Vectorizer, (), V>
[src]
fn vectorize_pad(
self,
pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>
[src]
self,
pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>
Auto Trait Implementations
impl<B, S> Send for Packed4<B, S>
impl<B, S> Sync for Packed4<B, S>
impl<B, S> Unpin for Packed4<B, S> where
<S as ArrayLength<B>>::ArrayType: Unpin,
<S as ArrayLength<B>>::ArrayType: Unpin,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
[src]
type Output = T
Should always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,