Struct slipstream::vector::Packed4

#[repr(C, align(4))]pub struct Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy,  { /* fields omitted */ }

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, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<B, S> AddAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + AddAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<B, S> AsMut<[B]> for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

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

Performs the conversion.

impl<B, S> AsRef<[B]> for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

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

Performs the conversion.

impl<B, S> BitAnd<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the & operation.

impl<B, S> BitAndAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + BitAndAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<B, S> BitOr<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the | operation.

impl<B, S> BitOrAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + BitOrAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<B, S> BitXor<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the ^ operation.

impl<B, S> BitXorAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + BitXorAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<B: Clone, S: Clone> Clone for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn clone(&self) -> Packed4<B, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Copy, S: Copy> Copy for Packed4<B, S> where
    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, 

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

Formats the value using the given formatter.

impl<B: Default, S: Default> Default for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn default() -> Packed4<B, S>

Returns the "default value" for a type.

impl<B, S> Deref for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Target = [B]

The resulting type after dereferencing.

fn deref(&self) -> &[B]

Dereferences the value.

impl<B, S> DerefMut for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn deref_mut(&mut self) -> &mut [B]

Mutably dereferences the value.

impl<B, S> Div<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the / operation.

impl<B, S> DivAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + DivAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<B: Eq, S: Eq> Eq for Packed4<B, S> where
    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, 

type Output = B

The returned type after indexing.

fn index(&self, idx: usize) -> &B

Performs the indexing (container[index]) operation.

impl<B, S> IndexMut<usize> for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn index_mut(&mut self, idx: usize) -> &mut B

Performs the mutable indexing (container[index]) operation.

impl<B, S> Mul<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the * operation.

impl<B, S> MulAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + MulAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<B, S> Neg for Packed4<B, S> where
    B: Repr + Neg<Output = B> + Copy,
    S: Unsigned + ArrayLength<B>,
    S::ArrayType: Copy, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<B, S> Not for Packed4<B, S> where
    B: Repr + Not<Output = B> + Copy,
    S: Unsigned + ArrayLength<B>,
    S::ArrayType: Copy, 

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl<B: Ord, S: Ord> Ord for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn cmp(&self, other: &Packed4<B, S>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<B: PartialEq, S: PartialEq> PartialEq<Packed4<B, S>> for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn eq(&self, other: &Packed4<B, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Packed4<B, S>) -> bool

This method tests for !=.

impl<B: PartialOrd, S: PartialOrd> PartialOrd<Packed4<B, S>> for Packed4<B, S> where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn partial_cmp(&self, other: &Packed4<B, S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Packed4<B, S>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Packed4<B, S>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Packed4<B, S>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Packed4<B, S>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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]>, 

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

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<B, S> Rem<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the % operation.

impl<B, S> RemAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + RemAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<B, S> Shl<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the << operation.

impl<B, S> ShlAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + ShlAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<B, S> Shr<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the >> operation.

impl<B, S> ShrAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + ShrAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<B, S> StructuralEq for Packed4<B, S> where
    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, 

impl<B, S> Sub<Packed4<B, S>> for Packed4<B, S> where
    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

Performs the - operation.

impl<B, S> SubAssign<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + SubAssign + Copy,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<B, S> Sum<Packed4<B, S>> for Packed4<B, S> where
    B: Repr + AddAssign,
    S: ArrayLength<B>,
    S::ArrayType: Copy,
    Self: Default, 

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

Method which takes an iterator and generates Self from the elements by "summing up" the items.

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, 

type Base = B

Type of one lane of the vector.

type Lanes = S

A type-level integer specifying the length of the vector.

type Mask = Packed4<B::Mask, S>

The mask type for this vector.

unsafe fn new_unchecked(input: *const B) -> Self

Load the vector without doing bounds checks.

fn splat(value: B) -> Self

Produces a vector of all lanes set to the same value.

fn gather_load<I, Idx>(input: I, idx: Idx) -> Self where
    I: AsRef<[B]>,
    Idx: AsRef<[usize]>, 

Loads the vector from a slice by indexing it.

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, 

Loads enabled lanes from a slice by indexing it.

fn scatter_store<O, Idx>(self, output: O, idx: Idx) where
    O: AsMut<[B]>,
    Idx: AsRef<[usize]>, 

Store the vector into a slice by indexing it.

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, 

A masked version of [scatter_store].

fn blend<M, MB>(self, other: Self, mask: M) -> Self where
    M: AsRef<[MB]>,
    MB: Mask, 

Blend self and other using mask.

fn horizontal_sum(self) -> B where
    B: Add<Output = B>, 

Sums the lanes together.

fn horizontal_product(self) -> B where
    B: Mul<Output = B>, 

Multiplies all the lanes of the vector.

fn eq(self, other: Self) -> Self::Mask where
    Self::Base: PartialEq, 

Lane-wise ==.

fn lt(self, other: Self) -> Self::Mask where
    Self::Base: PartialOrd, 

Lane-wise <.

fn gt(self, other: Self) -> Self::Mask where
    Self::Base: PartialOrd, 

Lane-wise >.

fn le(self, other: Self) -> Self::Mask where
    Self::Base: PartialOrd, 

Lane-wise <=.

fn ge(self, other: Self) -> Self::Mask where
    Self::Base: PartialOrd, 

Lane-wise >=.

const LANES: usize

Number of lanes of the vector.

fn new<I>(input: I) -> Self where
    I: AsRef<[Self::Base]>, 

Loads the vector from correctly sized slice.

fn maximum(self, other: Self) -> Self where
    Self::Base: PartialOrd, 

A lane-wise maximum.

fn minimum(self, other: Self) -> Self where
    Self::Base: PartialOrd, 

A lane-wise maximum.

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, 

type Padding = ()

The input type provided by user to fill in the padding/uneven end.

type Vectorizer = &'a mut [Packed4<B, S>]

An internal type managing the splitting into vectors.

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<&'a mut Packed4<B, S>>)

Internal method to create the vectorizer and kick of the iteration.

fn vectorize(self) -> VectorizedIter<Self::Vectorizer, (), V>

Vectorize a slice or composite of slices

fn vectorize_pad(
    self,
    pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>

Vectorizes a slice or composite of slices, padding the odd end if needed.

impl<'a, B, S> Vectorizable<Packed4<B, S>> for &'a [Packed4<B, S>] where
    B: Repr,
    S: ArrayLength<B>,
    S::ArrayType: Copy, 

type Padding = ()

The input type provided by user to fill in the padding/uneven end.

type Vectorizer = &'a [Packed4<B, S>]

An internal type managing the splitting into vectors.

fn create(
    self,
    _pad: Option<()>
) -> (Self::Vectorizer, usize, Option<Packed4<B, S>>)

Internal method to create the vectorizer and kick of the iteration.

fn vectorize(self) -> VectorizedIter<Self::Vectorizer, (), V>

Vectorize a slice or composite of slices

fn vectorize_pad(
    self,
    pad: Self::Padding
) -> VectorizedIter<Self::Vectorizer, Option<V>, V>

Vectorizes a slice or composite of slices, padding the odd end if needed.