Struct i32x4 

pub struct i32x4 { /* private fields */ }

Implementations

impl i32x4

pub const ONE: i32x4

pub const ZERO: i32x4

pub const MAX: i32x4

pub const MIN: i32x4

pub const LANES: u16 = 4

The number of lanes in this SIMD vector.

pub const BITS: u16 = 128

The size of this SIMD vector in bits.

impl i32x4

pub const fn new(array: [i32; 4]) -> Self

pub fn simd_eq<Rhs>(self, other: Rhs) -> <Self as CmpEq<Rhs>>::Output

where Self: CmpEq<Rhs>,

Test if each element is equal to the corresponding element in other.

pub fn simd_ne<Rhs>(self, other: Rhs) -> <Self as CmpNe<Rhs>>::Output

where Self: CmpNe<Rhs>,

Test if each element is not equal to the corresponding element in other.

pub fn simd_lt<Rhs>(self, other: Rhs) -> <Self as CmpLt<Rhs>>::Output

where Self: CmpLt<Rhs>,

Test if each element is less than the corresponding element in other.

pub fn simd_gt<Rhs>(self, other: Rhs) -> <Self as CmpGt<Rhs>>::Output

where Self: CmpGt<Rhs>,

Test if each element is greater than the corresponding element in other.

pub fn simd_le<Rhs>(self, other: Rhs) -> <Self as CmpLe<Rhs>>::Output

where Self: CmpLe<Rhs>,

Test if each element is less than or equal to the corresponding element in other.

pub fn simd_ge<Rhs>(self, other: Rhs) -> <Self as CmpGe<Rhs>>::Output

where Self: CmpGe<Rhs>,

Test if each element is greater than or equal to the corresponding element in other.

pub fn blend(self, t: Self, f: Self) -> Self

pub fn is_positive(self) -> Self

Returns true for each positive element and false if it is zero or negative.

pub fn is_negative(self) -> Self

Returns true for each negative element and false if it is zero or positive.

pub fn mul_widen(self, rhs: Self) -> i64x4

Multiplies corresponding 32 bit lanes and returns the 64 bit result on the corresponding lanes.

Effectively does two multiplies on 128 bit platforms, but is easier to use than wrapping mul_widen_i32_odd_m128i individually.

pub fn abs(self) -> Self

pub fn unsigned_abs(self) -> u32x4

pub fn signum(self) -> Self

Returns numbers representing the sign of each element.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

pub fn reduce_add(self) -> i32

horizontal add of all the elements of the vector

pub fn reduce_max(self) -> i32

horizontal max of all the elements of the vector

pub fn reduce_min(self) -> i32

horizontal min of all the elements of the vector

pub fn max(self, rhs: Self) -> Self

pub fn min(self, rhs: Self) -> Self

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict each element to a certain interval.

If min > max, the result is unspeficied. Consider manually checking for that case.

pub fn saturating_add(self, rhs: Self) -> Self

pub fn saturating_sub(self, rhs: Self) -> Self

pub fn saturating_mul(self, rhs: Self) -> Self

Lanewise saturating multiply.

pub fn saturating_div(self, rhs: Self) -> Self

Lanewise saturating divide.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

pub fn round_float(self) -> f32x4

pub fn to_bitmask(self) -> u32

pub fn any(self) -> bool

pub fn all(self) -> bool

pub fn none(self) -> bool

pub fn transpose(data: [i32x4; 4]) -> [i32x4; 4]

Transpose matrix of 4x4 i32 matrix. Currently only accelerated on SSE.

pub fn to_array(self) -> [i32; 4]

pub fn as_array(&self) -> &[i32; 4]

pub fn as_mut_array(&mut self) -> &mut [i32; 4]

impl i32x4

pub const fn splat(elem: i32) -> i32x4

Trait Implementations

impl CmpEq<i32> for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_eq(self, rhs: i32) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpEq for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_eq(self, rhs: Self) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGe<i32> for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_ge(self, rhs: i32) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGe for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_ge(self, rhs: Self) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGt<i32> for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_gt(self, rhs: i32) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGt for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_gt(self, rhs: Self) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLe<i32> for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_le(self, rhs: i32) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLe for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_le(self, rhs: Self) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLt<i32> for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_lt(self, rhs: i32) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLt for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_lt(self, rhs: Self) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpNe<i32> for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_ne(self, rhs: i32) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpNe for i32x4

type Output = i32x4

👎Deprecated since 1.5.0:

use inherit function instead

fn simd_ne(self, rhs: Self) -> Self::Output

👎Deprecated since 1.5.0:

use inherit function instead

impl Add<&i32x4> for i32x4

type Output = i32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for i32x4

type Output = i32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32x4> for i32

type Output = i32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for i32x4

type Output = i32x4

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&i32x4> for i32x4

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl AddAssign for i32x4

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AlignTo for i32x4

type Elem = i32

fn simd_align_to( slice: &[Self::Elem], ) -> (&[Self::Elem], &[Self], &[Self::Elem])

fn simd_align_to_mut( slice: &mut [Self::Elem], ) -> (&mut [Self::Elem], &mut [Self], &mut [Self::Elem])

impl Binary for i32x4

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

Formats the value using the given formatter.

impl BitAnd<&i32x4> for i32x4

type Output = i32x4

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl BitAnd for i32x4

type Output = i32x4

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAndAssign<&i32x4> for i32x4

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl BitAndAssign for i32x4

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<&i32x4> for i32x4

type Output = i32x4

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl BitOr for i32x4

type Output = i32x4

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign<&i32x4> for i32x4

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl BitOrAssign for i32x4

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<&i32x4> for i32x4

type Output = i32x4

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl BitXor for i32x4

type Output = i32x4

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXorAssign<&i32x4> for i32x4

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl BitXorAssign for i32x4

fn bitxor_assign(&mut self, rhs: Self)

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 Debug for i32x4

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

Formats the value using the given formatter.

impl Default for i32x4

fn default() -> i32x4

Returns the “default value” for a type.

impl Display for i32x4

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

Formats the value using the given formatter.

impl Div<i32> for i32x4

fn div(self, rhs: i32) -> Self::Output

Lanewise divide.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

type Output = i32x4

The resulting type after applying the / operator.

impl Div<i32x4> for i32

fn div(self, rhs: i32x4) -> Self::Output

Lanewise divide.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

type Output = i32x4

The resulting type after applying the / operator.

impl Div for i32x4

fn div(self, rhs: Self) -> Self::Output

Lanewise divide.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

type Output = i32x4

The resulting type after applying the / operator.

impl From<&[i32]> for i32x4

fn from(src: &[i32]) -> i32x4

Converts to this type from the input type.

impl From<[i32; 4]> for i32x4

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

Converts to this type from the input type.

impl From<i32> for i32x4

fn from(elem: i32) -> Self

Splats the single value given across all lanes.

impl From<i32x4> for [i32; 4]

fn from(simd: i32x4) -> Self

Converts to this type from the input type.

impl From<i32x4> for f64x2

fn from(v: i32x4) -> Self

Converts the lower two i32 lanes to two f64 lanes (and dropping the higher two i32 lanes)

impl From<i32x4> for f64x4

fn from(v: i32x4) -> Self

Converts to this type from the input type.

impl LowerExp for i32x4

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

Formats the value using the given formatter.

impl LowerHex for i32x4

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

Formats the value using the given formatter.

impl Mul<&i32x4> for i32x4

type Output = i32x4

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self::Output

Performs the * operation.

impl Mul<i32> for i32x4

type Output = i32x4

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl Mul<i32x4> for i32

type Output = i32x4

The resulting type after applying the * operator.

fn mul(self, rhs: i32x4) -> Self::Output

Performs the * operation.

impl Mul for i32x4

type Output = i32x4

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl MulAssign<&i32x4> for i32x4

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl MulAssign for i32x4

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for &i32x4

type Output = i32x4

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for i32x4

type Output = i32x4

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for &i32x4

type Output = i32x4

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for i32x4

type Output = i32x4

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Octal for i32x4

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

Formats the value using the given formatter.

impl PartialEq for i32x4

fn eq(&self, other: &i32x4) -> 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<RHS> Product<RHS> for i32x4

where i32x4: MulAssign<RHS>,

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

Takes an iterator and generates Self from the elements by multiplying the items.

impl Rem<i32> for i32x4

fn rem(self, rhs: i32) -> Self::Output

Lanewise remainder.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

type Output = i32x4

The resulting type after applying the % operator.

impl Rem<i32x4> for i32

fn rem(self, rhs: i32x4) -> Self::Output

Lanewise remainder.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

type Output = i32x4

The resulting type after applying the % operator.

impl Rem for i32x4

fn rem(self, rhs: Self) -> Self::Output

Lanewise remainder.

Note that because division has no hardware support, this operation is very slow and should be avoided if possible.

type Output = i32x4

The resulting type after applying the % operator.

impl Shl<i128> for i32x4

fn shl(self, rhs: i128) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<i16> for i32x4

fn shl(self, rhs: i16) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<i32> for i32x4

fn shl(self, rhs: i32) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<i64> for i32x4

fn shl(self, rhs: i64) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<i8> for i32x4

fn shl(self, rhs: i8) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<u128> for i32x4

fn shl(self, rhs: u128) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<u16> for i32x4

fn shl(self, rhs: u16) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<u32> for i32x4

fn shl(self, rhs: u32) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<u64> for i32x4

fn shl(self, rhs: u64) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl<u8> for i32x4

fn shl(self, rhs: u8) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the << operator.

impl Shl for i32x4

Shifts lanes by the corresponding lane.

Bitwise shift-left; yields self << mask(rhs), where mask removes any high-order bits of rhs that would cause the shift to exceed the bitwidth of the type. (same as wrapping_shl)

type Output = i32x4

The resulting type after applying the << operator.

fn shl(self, rhs: i32x4) -> Self::Output

Performs the << operation.

impl Shr<i128> for i32x4

fn shr(self, rhs: i128) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<i16> for i32x4

fn shr(self, rhs: i16) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<i32> for i32x4

fn shr(self, rhs: i32) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<i64> for i32x4

fn shr(self, rhs: i64) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<i8> for i32x4

fn shr(self, rhs: i8) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<u128> for i32x4

fn shr(self, rhs: u128) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<u16> for i32x4

fn shr(self, rhs: u16) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<u32> for i32x4

fn shr(self, rhs: u32) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<u64> for i32x4

fn shr(self, rhs: u64) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr<u8> for i32x4

fn shr(self, rhs: u8) -> Self::Output

Shifts all lanes by the value given.

type Output = i32x4

The resulting type after applying the >> operator.

impl Shr for i32x4

Shifts lanes by the corresponding lane.

Bitwise shift-right; yields self >> mask(rhs), where mask removes any high-order bits of rhs that would cause the shift to exceed the bitwidth of the type. (same as wrapping_shr)

type Output = i32x4

The resulting type after applying the >> operator.

fn shr(self, rhs: i32x4) -> Self::Output

Performs the >> operation.

impl Sub<&i32x4> for i32x4

type Output = i32x4

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self::Output

Performs the - operation.

impl Sub<i32> for i32x4

type Output = i32x4

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl Sub<i32x4> for i32

type Output = i32x4

The resulting type after applying the - operator.

fn sub(self, rhs: i32x4) -> Self::Output

Performs the - operation.

impl Sub for i32x4

type Output = i32x4

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl SubAssign<&i32x4> for i32x4

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl SubAssign for i32x4

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<RHS> Sum<RHS> for i32x4

where i32x4: AddAssign<RHS>,

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

Takes an iterator and generates Self from the elements by “summing up” the items.

impl UpperExp for i32x4

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

Formats the value using the given formatter.

impl UpperHex for i32x4

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

Formats the value using the given formatter.

impl Zeroable for i32x4

fn zeroed() -> Self

Calls zeroed.

impl Copy for i32x4

impl Eq for i32x4

impl Pod for i32x4

impl StructuralPartialEq for i32x4