Struct I32x4

pub struct I32x4(/* private fields */);

[i32; 4] as a vector.

Implementations

impl I32x4

pub const fn from_array(arr: [i32; 4]) -> Self

Create a vector from an array.

Unlike the From trait function, the from_array function is const.

Example

const MY_EXTREMELY_FUN_VALUE: I32x4 = I32x4::from_array([0, 1, 2, 3]);
for (i, value) in MY_EXTREMELY_FUN_VALUE.as_array().iter().copied().enumerate() {
    assert_eq!(i as i32, value);
}

Trait Implementations

impl Add for I32x4

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

Perform a pairwise wrapping_add

Scalar Equivalent

I32x4::from([
    self.as_array()[0].wrapping_add(rhs.as_array()[0]),
    self.as_array()[1].wrapping_add(rhs.as_array()[1]),
    self.as_array()[2].wrapping_add(rhs.as_array()[2]),
    self.as_array()[3].wrapping_add(rhs.as_array()[3]),
])

AVX2 Intrinsics Used

• _mm_add_epi32
  • PADDD xmm, xmm

Neon Intrinsics Used

• vaddq_s32
  • This intrinsic compiles to the following instructions:
    • ADD Vd.4S,Vn.4S,Vm.4S

type Output = I32x4

The resulting type after applying the + operator.

impl AddAssign for I32x4

fn add_assign(&mut self, other: I32x4)

Performs the += operation.

impl AsMut<[i32]> for I32x4

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[i32]> for I32x4

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

Converts this type into a shared reference of the (usually inferred) input type.

impl BitAnd for I32x4

fn bitand(self, rhs: I32x4) -> I32x4

Perform a pairwise bitwise and

Scalar Equivalent

I32x4::from([
    self.as_array()[0] & rhs.as_array()[0],
    self.as_array()[1] & rhs.as_array()[1],
    self.as_array()[2] & rhs.as_array()[2],
    self.as_array()[3] & rhs.as_array()[3],
])

AVX2 Intrinsics Used

• _mm_and_si128
  • PAND xmm, xmm

Neon Intrinsics Used

• vandq_s32
  • This intrinsic compiles to the following instructions:
    • AND Vd.16B,Vn.16B,Vm.16B

type Output = I32x4

The resulting type after applying the & operator.

impl BitAndAssign for I32x4

fn bitand_assign(&mut self, other: I32x4)

Performs the &= operation.

impl BitOr for I32x4

fn bitor(self, rhs: I32x4) -> I32x4

Perform a pairwise bitwise or

Scalar Equivalent

I32x4::from([
    self.as_array()[0] | rhs.as_array()[0],
    self.as_array()[1] | rhs.as_array()[1],
    self.as_array()[2] | rhs.as_array()[2],
    self.as_array()[3] | rhs.as_array()[3],
])

AVX2 Intrinsics Used

• _mm_or_si128
  • POR xmm, xmm

Neon Intrinsics Used

• vorrq_s32
  • This intrinsic compiles to the following instructions:
    • ORR Vd.16B,Vn.16B,Vm.16B

type Output = I32x4

The resulting type after applying the | operator.

impl BitOrAssign for I32x4

fn bitor_assign(&mut self, other: I32x4)

Performs the |= operation.

impl BitXor for I32x4

fn bitxor(self, rhs: I32x4) -> I32x4

Perform a pairwise bitwise xor

Scalar Equivalent

I32x4::from([
    self.as_array()[0] ^ rhs.as_array()[0],
    self.as_array()[1] ^ rhs.as_array()[1],
    self.as_array()[2] ^ rhs.as_array()[2],
    self.as_array()[3] ^ rhs.as_array()[3],
])

AVX2 Intrinsics Used

• _mm_xor_si128
  • PXOR xmm, xmm

Neon Intrinsics Used

• veorq_s32
  • This intrinsic compiles to the following instructions:
    • EOR Vd.16B,Vn.16B,Vm.16B

type Output = I32x4

The resulting type after applying the ^ operator.

impl BitXorAssign for I32x4

fn bitxor_assign(&mut self, other: I32x4)

Performs the ^= operation.

impl Clone for I32x4

fn clone(&self) -> I32x4

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConditionallySelectable for I32x4

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl ConstantTimeEq for I32x4

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl Debug for I32x4

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

Formats the value using the given formatter.

impl Default for I32x4

fn default() -> Self

The zero vector.

impl<'de> Deserialize<'de> for I32x4

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Distribution<I32x4> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> I32x4

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl ExtendingCast<I16x8> for I32x4

fn extending_cast_from(vector: I16x8) -> I32x4

Scalar Equivalent:

I32x4::from([
        i32::from(vector.as_array()[0]),
        i32::from(vector.as_array()[1]),
        i32::from(vector.as_array()[2]),
        i32::from(vector.as_array()[3]),
])

Avx2

• _mm_cvtepi16_epi32

  • PMOVSXWD xmm, xmm

impl ExtendingCast<I32x4> for I64x2

fn extending_cast_from(vector: I32x4) -> I64x2

Scalar Equivalent:

I64x2::from([
        i64::from(vector.as_array()[0]),
        i64::from(vector.as_array()[1]),
])

Avx2

• _mm_cvtepi32_epi64

  • PMOVSXDQ xmm, xmm

impl ExtendingCast<I32x4> for I64x4

fn extending_cast_from(vector: I32x4) -> I64x4

Scalar Equivalent:

I64x4::from([
        i64::from(vector.as_array()[0]),
        i64::from(vector.as_array()[1]),
        i64::from(vector.as_array()[2]),
        i64::from(vector.as_array()[3]),
])

Avx2

• _mm256_cvtepi32_epi64

  • VPMOVSXDQ ymm, xmm

impl ExtendingCast<I8x16> for I32x4

fn extending_cast_from(vector: I8x16) -> I32x4

Scalar Equivalent:

I32x4::from([
        i32::from(vector.as_array()[0]),
        i32::from(vector.as_array()[1]),
        i32::from(vector.as_array()[2]),
        i32::from(vector.as_array()[3]),
])

Avx2

• _mm_cvtepi8_epi32

  • PMOVSXBD xmm, xmm

impl From<[i32; 4]> for I32x4

fn from(arr: [i32; 4]) -> I32x4

Converts to this type from the input type.

impl From<I16x8> for I32x4

fn from(x: I16x8) -> I32x4

This cast is 100% free. It reinterprets the little-endinan bits of I16x8 as little endian bits of I32x4.

impl From<I32x4> for [i32; 4]

fn from(arr: I32x4) -> [i32; 4]

Converts to this type from the input type.

impl From<I32x4> for I16x8

fn from(x: I32x4) -> I16x8

This cast is 100% free. It reinterprets the little-endinan bits of I32x4 as little endian bits of I16x8.

impl From<I32x4> for I32x8

fn from(vector: I32x4) -> I32x8

NOTE: this will zero the upper bits of the destination. Other intrinsics are more effcient, but leave the upper bits undefined. At present, these more effcient intrinsics are not exposed.

Scalar Equivalent:

let mut out = [0; 8];
out[0..4].copy_from_slice(&vector.as_array());
I32x8::from(out)

Avx2

• _mm256_zextsi128_si256

impl From<I32x4> for I64x2

fn from(x: I32x4) -> I64x2

This cast is 100% free. It reinterprets the little-endinan bits of I32x4 as little endian bits of I64x2.

impl From<I32x4> for I64x4

fn from(vector: I32x4) -> I64x4

Scalar Equivalent:

I64x4::from([
        i64::from(vector.as_array()[0]),
        i64::from(vector.as_array()[1]),
        i64::from(vector.as_array()[2]),
        i64::from(vector.as_array()[3]),
])

Avx2

• _mm256_cvtepi32_epi64

  • VPMOVSXDQ ymm, xmm

impl From<I32x4> for I8x16

fn from(x: I32x4) -> I8x16

This cast is 100% free. It reinterprets the little-endinan bits of I32x4 as little endian bits of I8x16.

impl From<I32x4> for U16x8

fn from(x: I32x4) -> U16x8

This cast is 100% free. It reinterprets the little-endinan bits of I32x4 as little endian bits of U16x8.

impl From<I32x4> for U32x4

fn from(x: I32x4) -> U32x4

This cast is 100% free. It reinterprets the little-endinan bits of I32x4 as little endian bits of U32x4.

impl From<I32x4> for U64x2

fn from(x: I32x4) -> U64x2

This cast is 100% free. It reinterprets the little-endinan bits of I32x4 as little endian bits of U64x2.

impl From<I32x4> for U8x16

fn from(x: I32x4) -> U8x16

This cast is 100% free. It reinterprets the little-endinan bits of I32x4 as little endian bits of U8x16.

impl From<I64x2> for I32x4

fn from(x: I64x2) -> I32x4

This cast is 100% free. It reinterprets the little-endinan bits of I64x2 as little endian bits of I32x4.

impl From<I8x16> for I32x4

fn from(x: I8x16) -> I32x4

This cast is 100% free. It reinterprets the little-endinan bits of I8x16 as little endian bits of I32x4.

impl From<U16x8> for I32x4

fn from(x: U16x8) -> I32x4

This cast is 100% free. It reinterprets the little-endinan bits of U16x8 as little endian bits of I32x4.

impl From<U32x4> for I32x4

fn from(x: U32x4) -> I32x4

This cast is 100% free. It reinterprets the little-endinan bits of U32x4 as little endian bits of I32x4.

impl From<U64x2> for I32x4

fn from(x: U64x2) -> I32x4

This cast is 100% free. It reinterprets the little-endinan bits of U64x2 as little endian bits of I32x4.

impl From<U8x16> for I32x4

fn from(x: U8x16) -> I32x4

This cast is 100% free. It reinterprets the little-endinan bits of U8x16 as little endian bits of I32x4.

impl Hash for I32x4

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for I32x4

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for I32x4

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Shl<u64> for I32x4

fn shl(self, amount: u64) -> I32x4

Scalar Equivalent:

if amount >= 32 {
    I32x4::ZERO
} else {
    I32x4::from([
        self.as_array()[0] << amount,
        self.as_array()[1] << amount,
        self.as_array()[2] << amount,
        self.as_array()[3] << amount,
    ])
}

Avx2

• _mm_set_epi64x

  Instruction sequence.

• _mm_sll_epi32

  • PSLLD xmm, xmm

type Output = I32x4

The resulting type after applying the << operator.

impl Shl for I32x4

fn shl(self, amount: I32x4) -> I32x4

Scalar Equivalent:

let mut out = self.as_array();
for (x, amm) in out.iter_mut().zip(amount.as_array().iter().copied()) {
    *x = if (0..32).contains(&amm) {
        *x << amm
    }  else {
        0
    };
}
I32x4::from(out)

Avx2

• _mm_sllv_epi32

  • VPSLLVD xmm, xmm, xmm

type Output = I32x4

The resulting type after applying the << operator.

impl ShlAssign<u64> for I32x4

fn shl_assign(&mut self, amount: u64)

Performs the <<= operation.

impl ShlAssign for I32x4

fn shl_assign(&mut self, amount: I32x4)

Performs the <<= operation.

impl Shr<u64> for I32x4

fn shr(self, amount: u64) -> I32x4

Scalar Equivalent:

if amount >= 32 {
    let mut out = self.as_array();
    for x in out.iter_mut() {
        *x = if *x < 0 { -1 } else { 0 };
    }
    I32x4::from(out)
} else {
    I32x4::from([
        self.as_array()[0] >> amount,
        self.as_array()[1] >> amount,
        self.as_array()[2] >> amount,
        self.as_array()[3] >> amount,
    ])
}

Avx2

• _mm_set_epi64x

  Instruction sequence.

• _mm_sra_epi32

  • PSRAD xmm, xmm

type Output = I32x4

The resulting type after applying the >> operator.

impl Shr for I32x4

fn shr(self, amount: I32x4) -> I32x4

Scalar Equivalent:

let mut out = self.as_array();
for (x, amm) in out.iter_mut().zip(amount.as_array().iter().copied()) {
    *x = if (0..32).contains(&amm) {
        *x >> amm
    } else if *x < 0 {
        -1
    }  else {
        0
    };
}
I32x4::from(out)

Avx2

• _mm_srav_epi32

  • VPSRAVD xmm, xmm, xmm

type Output = I32x4

The resulting type after applying the >> operator.

impl ShrAssign<u64> for I32x4

fn shr_assign(&mut self, amount: u64)

Performs the >>= operation.

impl ShrAssign for I32x4

fn shr_assign(&mut self, amount: I32x4)

Performs the >>= operation.

impl SimdBase for I32x4

fn is_zero(&self) -> bool

Scalar Equivalent:

self.as_array().iter().all(|x| *x == 0)

Avx2

• _mm_testz_si128

  • PTEST xmm, xmm

fn set_lo(scalar: i32) -> I32x4

Scalar Equivalent:

let mut out = [0; 4];
out[0] = scalar;
I32x4::from(out)

Avx2

• _mm_set_epi32

  Instruction sequence.

fn extract<const I: usize>(&self) -> i32

Scalar Equivalent:

self.as_array()[I]

Avx2

• _mm_extract_epi32

  • PEXTRD r32, xmm, imm8

fn broadcast(scalar: i32) -> I32x4

Scalar Equivalent:

I32x4::from([scalar; 4])

Avx2

• _mm_set1_epi32

  Instruction sequence.

fn broadcast_lo(vector: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([vector.as_array()[0]; 4])

Avx2

• _mm_broadcastd_epi32

  • VPBROADCASTD xmm, xmm

fn cmp_eq(&self, other: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    if self.as_array()[0] == other.as_array()[0] {  -1  } else { 0 },
    if self.as_array()[1] == other.as_array()[1] {  -1  } else { 0 },
    if self.as_array()[2] == other.as_array()[2] {  -1  } else { 0 },
    if self.as_array()[3] == other.as_array()[3] {  -1  } else { 0 },
])

Avx2

• _mm_cmpeq_epi32

  • PCMPEQD xmm, xmm

fn and_not(&self, other: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    self.as_array()[0] & (!other.as_array()[0]),
    self.as_array()[1] & (!other.as_array()[1]),
    self.as_array()[2] & (!other.as_array()[2]),
    self.as_array()[3] & (!other.as_array()[3]),
])

Avx2

• _mm_andnot_si128

  • PANDN xmm, xmm

fn cmp_gt(&self, other: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    if self.as_array()[0] > other.as_array()[0] {  -1  } else { 0 },
    if self.as_array()[1] > other.as_array()[1] {  -1  } else { 0 },
    if self.as_array()[2] > other.as_array()[2] {  -1  } else { 0 },
    if self.as_array()[3] > other.as_array()[3] {  -1  } else { 0 },
])

Avx2

• _mm_cmpgt_epi32

  • PCMPGTD xmm, xmm

fn shift_left<const BITS: usize>(&self) -> I32x4

Scalar Equivalent:

let mut out = self.as_array();
for x in out.iter_mut() {
    *x <<= BITS;
}
I32x4::from(out)

Avx2

• _mm_slli_epi32

  • PSLLD xmm, imm8

fn shift_right<const BITS: usize>(&self) -> I32x4

Scalar Equivalent:

let mut out = self.as_array();
for x in out.iter_mut() {
    *x >>= BITS;
}
I32x4::from(out)

Avx2

• _mm_srai_epi32

  • PSRAD xmm, imm8

fn unpack_lo(&self, other: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    // Lane# 0
    self.as_array()[0],
    other.as_array()[0],
    self.as_array()[1],
    other.as_array()[1],
])

Avx2

• _mm_unpacklo_epi32

  • PUNPCKLDQ xmm, xmm

fn unpack_hi(&self, other: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    // Lane# 0
    self.as_array()[2],
    other.as_array()[2],
    self.as_array()[3],
    other.as_array()[3],
])

Avx2

• _mm_unpackhi_epi32

  • PUNPCKHDQ xmm, xmm

fn max(&self, other: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    self.as_array()[0].max(other.as_array()[0]),
    self.as_array()[1].max(other.as_array()[1]),
    self.as_array()[2].max(other.as_array()[2]),
    self.as_array()[3].max(other.as_array()[3]),
])

Avx2

• _mm_max_epi32

  • PMAXSD xmm, xmm

fn min(&self, other: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    self.as_array()[0].min(other.as_array()[0]),
    self.as_array()[1].min(other.as_array()[1]),
    self.as_array()[2].min(other.as_array()[2]),
    self.as_array()[3].min(other.as_array()[3]),
])

Avx2

• _mm_min_epi32

  • PMINSD xmm, xmm

const LANES: usize = 4usize

The number of elements of this vector.

const ZERO: Self

A vector where every element is zero.

type Scalar = i32

The scalar that this value holds.

type Array = [i32; 4]

The equivalent array type of this vector.

type Signed = I32x4

The signed version of this vector.

type Unsigned = U32x4

The unsigned version of this vector.

type BroadcastLoInput = I32x4

A vector of [Self::Scalar; 128 / (8 * std::mem::size_of::<Self::Scalar>())]

fn as_array(&self) -> Self::Array

Convert the vector to an array.

impl SimdBase32 for I32x4

fn shuffle<const I3: usize, const I2: usize, const I1: usize, const I0: usize>( &self, ) -> I32x4

Scalar Equivalent:

I32x4::from([
    // 128-bit Lane #0
    self.as_array()[I0 + 0 * 4],
    self.as_array()[I1 + 0 * 4],
    self.as_array()[I2 + 0 * 4],
    self.as_array()[I3 + 0 * 4],
])

Avx2

• _mm_shuffle_epi32

  • PSHUFD xmm, xmm, imm8

impl SimdBase4x for I32x4

fn blend<const B3: bool, const B2: bool, const B1: bool, const B0: bool>( &self, if_true: I32x4, ) -> I32x4

Scalar Equivalent:

I32x4::from([
        (if B0 { if_true } else { *self }).as_array()[0],
        (if B1 { if_true } else { *self }).as_array()[1],
        (if B2 { if_true } else { *self }).as_array()[2],
        (if B3 { if_true } else { *self }).as_array()[3],
])

Avx2

• _mm_blend_epi32

  • VPBLENDD xmm, xmm, xmm, imm8

impl SimdBaseGatherable<I32x4> for I32x4

Safety

base does not need to be aligned. Forall i, base + indices[i] must meet the safety requirements of std::ptr::read_unaligned

unsafe fn gather(base: *const i32, indices: I32x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    base.offset(indices.as_array()[0] as isize).read_unaligned(),
    base.offset(indices.as_array()[1] as isize).read_unaligned(),
    base.offset(indices.as_array()[2] as isize).read_unaligned(),
    base.offset(indices.as_array()[3] as isize).read_unaligned(),
])

Avx2

• _mm_i32gather_epi32

  • VPGATHERDD xmm, vm32x, xmm

unsafe fn gather_masked( base: *const i32, indices: I32x4, mask: I32x4, src: I32x4, ) -> I32x4

Scalar Equivalent:

I32x4::from([
    if ((mask.as_array()[0] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[0] as isize).read_unaligned()
    } else {
        src.as_array()[0]
    },
    if ((mask.as_array()[1] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[1] as isize).read_unaligned()
    } else {
        src.as_array()[1]
    },
    if ((mask.as_array()[2] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[2] as isize).read_unaligned()
    } else {
        src.as_array()[2]
    },
    if ((mask.as_array()[3] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[3] as isize).read_unaligned()
    } else {
        src.as_array()[3]
    },
])

Avx2

• _mm_mask_i32gather_epi32

  • VPGATHERDD xmm, vm32x, xmm

impl SimdBaseGatherable<I32x4> for I64x4

Safety

base does not need to be aligned. Forall i, base + indices[i] must meet the safety requirements of std::ptr::read_unaligned

unsafe fn gather(base: *const i64, indices: I32x4) -> I64x4

Scalar Equivalent:

I64x4::from([
    base.offset(indices.as_array()[0] as isize).read_unaligned(),
    base.offset(indices.as_array()[1] as isize).read_unaligned(),
    base.offset(indices.as_array()[2] as isize).read_unaligned(),
    base.offset(indices.as_array()[3] as isize).read_unaligned(),
])

Avx2

• _mm256_i32gather_epi64

  • VPGATHERDQ ymm, vm32x, ymm

unsafe fn gather_masked( base: *const i64, indices: I32x4, mask: I64x4, src: I64x4, ) -> I64x4

Scalar Equivalent:

I64x4::from([
    if ((mask.as_array()[0] as u64) >> 63) == 1 {
        base.offset(indices.as_array()[0] as isize).read_unaligned()
    } else {
        src.as_array()[0]
    },
    if ((mask.as_array()[1] as u64) >> 63) == 1 {
        base.offset(indices.as_array()[1] as isize).read_unaligned()
    } else {
        src.as_array()[1]
    },
    if ((mask.as_array()[2] as u64) >> 63) == 1 {
        base.offset(indices.as_array()[2] as isize).read_unaligned()
    } else {
        src.as_array()[2]
    },
    if ((mask.as_array()[3] as u64) >> 63) == 1 {
        base.offset(indices.as_array()[3] as isize).read_unaligned()
    } else {
        src.as_array()[3]
    },
])

Avx2

• _mm256_mask_i32gather_epi64

  • VPGATHERDQ ymm, vm32x, ymm

impl SimdBaseGatherable<I32x4> for U32x4

Safety

base does not need to be aligned. Forall i, base + indices[i] must meet the safety requirements of std::ptr::read_unaligned

unsafe fn gather(base: *const u32, indices: I32x4) -> U32x4

Scalar Equivalent:

U32x4::from([
    base.offset(indices.as_array()[0] as isize).read_unaligned(),
    base.offset(indices.as_array()[1] as isize).read_unaligned(),
    base.offset(indices.as_array()[2] as isize).read_unaligned(),
    base.offset(indices.as_array()[3] as isize).read_unaligned(),
])

Avx2

• _mm_i32gather_epi32

  • VPGATHERDD xmm, vm32x, xmm

unsafe fn gather_masked( base: *const u32, indices: I32x4, mask: U32x4, src: U32x4, ) -> U32x4

Scalar Equivalent:

U32x4::from([
    if (mask.as_array()[0] >> 31) == 1 {
        base.offset(indices.as_array()[0] as isize).read_unaligned()
    } else {
        src.as_array()[0]
    },
    if (mask.as_array()[1] >> 31) == 1 {
        base.offset(indices.as_array()[1] as isize).read_unaligned()
    } else {
        src.as_array()[1]
    },
    if (mask.as_array()[2] >> 31) == 1 {
        base.offset(indices.as_array()[2] as isize).read_unaligned()
    } else {
        src.as_array()[2]
    },
    if (mask.as_array()[3] >> 31) == 1 {
        base.offset(indices.as_array()[3] as isize).read_unaligned()
    } else {
        src.as_array()[3]
    },
])

Avx2

• _mm_mask_i32gather_epi32

  • VPGATHERDD xmm, vm32x, xmm

impl SimdBaseGatherable<I32x4> for U64x4

Safety

base does not need to be aligned. Forall i, base + indices[i] must meet the safety requirements of std::ptr::read_unaligned

unsafe fn gather(base: *const u64, indices: I32x4) -> U64x4

Scalar Equivalent:

U64x4::from([
    base.offset(indices.as_array()[0] as isize).read_unaligned(),
    base.offset(indices.as_array()[1] as isize).read_unaligned(),
    base.offset(indices.as_array()[2] as isize).read_unaligned(),
    base.offset(indices.as_array()[3] as isize).read_unaligned(),
])

Avx2

• _mm256_i32gather_epi64

  • VPGATHERDQ ymm, vm32x, ymm

unsafe fn gather_masked( base: *const u64, indices: I32x4, mask: U64x4, src: U64x4, ) -> U64x4

Scalar Equivalent:

U64x4::from([
    if (mask.as_array()[0] >> 63) == 1 {
        base.offset(indices.as_array()[0] as isize).read_unaligned()
    } else {
        src.as_array()[0]
    },
    if (mask.as_array()[1] >> 63) == 1 {
        base.offset(indices.as_array()[1] as isize).read_unaligned()
    } else {
        src.as_array()[1]
    },
    if (mask.as_array()[2] >> 63) == 1 {
        base.offset(indices.as_array()[2] as isize).read_unaligned()
    } else {
        src.as_array()[2]
    },
    if (mask.as_array()[3] >> 63) == 1 {
        base.offset(indices.as_array()[3] as isize).read_unaligned()
    } else {
        src.as_array()[3]
    },
])

Avx2

• _mm256_mask_i32gather_epi64

  • VPGATHERDQ ymm, vm32x, ymm

impl SimdBaseGatherable<I64x4> for I32x4

Safety

base does not need to be aligned. Forall i, base + indices[i] must meet the safety requirements of std::ptr::read_unaligned

unsafe fn gather(base: *const i32, indices: I64x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    base.offset(indices.as_array()[0] as isize).read_unaligned(),
    base.offset(indices.as_array()[1] as isize).read_unaligned(),
    base.offset(indices.as_array()[2] as isize).read_unaligned(),
    base.offset(indices.as_array()[3] as isize).read_unaligned(),
])

Avx2

• _mm256_i64gather_epi32

  • VPGATHERQD xmm, vm64y, xmm

unsafe fn gather_masked( base: *const i32, indices: I64x4, mask: I32x4, src: I32x4, ) -> I32x4

Scalar Equivalent:

I32x4::from([
    if ((mask.as_array()[0] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[0] as isize).read_unaligned()
    } else {
        src.as_array()[0]
    },
    if ((mask.as_array()[1] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[1] as isize).read_unaligned()
    } else {
        src.as_array()[1]
    },
    if ((mask.as_array()[2] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[2] as isize).read_unaligned()
    } else {
        src.as_array()[2]
    },
    if ((mask.as_array()[3] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[3] as isize).read_unaligned()
    } else {
        src.as_array()[3]
    },
])

Avx2

• _mm256_mask_i64gather_epi32

  • VPGATHERQD xmm, vm64y, xmm

impl SimdBaseGatherable<U64x4> for I32x4

Safety

base does not need to be aligned. Forall i, base + indices[i] must meet the safety requirements of std::ptr::read_unaligned

unsafe fn gather(base: *const i32, indices: U64x4) -> I32x4

Scalar Equivalent:

I32x4::from([
    base.offset(indices.as_array()[0] as isize).read_unaligned(),
    base.offset(indices.as_array()[1] as isize).read_unaligned(),
    base.offset(indices.as_array()[2] as isize).read_unaligned(),
    base.offset(indices.as_array()[3] as isize).read_unaligned(),
])

Avx2

• _mm256_i64gather_epi32

  • VPGATHERQD xmm, vm64y, xmm

unsafe fn gather_masked( base: *const i32, indices: U64x4, mask: I32x4, src: I32x4, ) -> I32x4

Scalar Equivalent:

I32x4::from([
    if ((mask.as_array()[0] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[0] as isize).read_unaligned()
    } else {
        src.as_array()[0]
    },
    if ((mask.as_array()[1] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[1] as isize).read_unaligned()
    } else {
        src.as_array()[1]
    },
    if ((mask.as_array()[2] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[2] as isize).read_unaligned()
    } else {
        src.as_array()[2]
    },
    if ((mask.as_array()[3] as u32) >> 31) == 1 {
        base.offset(indices.as_array()[3] as isize).read_unaligned()
    } else {
        src.as_array()[3]
    },
])

Avx2

• _mm256_mask_i64gather_epi32

  • VPGATHERQD xmm, vm64y, xmm

impl Sub for I32x4

fn sub(self, rhs: I32x4) -> I32x4

Perform a pairwise wrapping_sub

Scalar Equivalent

I32x4::from([
    self.as_array()[0].wrapping_sub(rhs.as_array()[0]),
    self.as_array()[1].wrapping_sub(rhs.as_array()[1]),
    self.as_array()[2].wrapping_sub(rhs.as_array()[2]),
    self.as_array()[3].wrapping_sub(rhs.as_array()[3]),
])

AVX2 Intrinsics Used

• _mm_sub_epi32
  • PSUBD xmm, xmm

Neon Intrinsics Used

• vsubq_s32
  • This intrinsic compiles to the following instructions:
    • SUB Vd.4S,Vn.4S,Vm.4S

type Output = I32x4

The resulting type after applying the - operator.

impl SubAssign for I32x4

fn sub_assign(&mut self, other: I32x4)

Performs the -= operation.

impl Zeroable for I32x4

fn zeroed() -> Self

Calls zeroed.

impl Copy for I32x4

impl Eq for I32x4

impl Pod for I32x4