Struct i8x32 

pub struct i8x32 { /* private fields */ }

Implementations

impl i8x32

pub const ONE: i8x32

pub const ZERO: i8x32

pub const MAX: i8x32

pub const MIN: i8x32

pub const LANES: u16 = 32

The number of lanes in this SIMD vector.

pub const BITS: u16 = 256

The size of this SIMD vector in bits.

impl i8x32

pub const fn new(array: [i8; 32]) -> 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 reduce_add(self) -> i8

pub fn reduce_max(self) -> i8

pub fn reduce_min(self) -> i8

pub fn abs(self) -> Self

pub fn unsigned_abs(self) -> u8x32

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 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 to_bitmask(self) -> u32

pub fn any(self) -> bool

pub fn all(self) -> bool

pub fn none(self) -> bool

pub fn swizzle_half(self, rhs: i8x32) -> i8x32

Returns a new vector with lanes selected from the lanes of the first input vector a specified in the second input vector rhs. The indices i in range [0, 15] select the i-th element of self. For indices outside of the range the resulting lane is 0.

This note that is the equivalent of two parallel swizzle operations on the two halves of the vector, and the indexes each refer to the corresponding half.

pub fn swizzle_half_relaxed(self, rhs: i8x32) -> i8x32

Indices in the range [0, 15] will select the i-th element of self. If the high bit of any element of rhs is set (negative) then the corresponding output lane is guaranteed to be zero. Otherwise if the element of rhs is within the range [32, 127] then the output lane is either 0 or self[rhs[i] % 16] depending on the implementation.

This is the equivalent to two parallel swizzle operations on the two halves of the vector, and the indexes each refer to their corresponding half.

pub fn transpose(data: [i8x32; 32]) -> [i8x32; 32]

Transpose matrix of 32x32 i8 matrix. Currently not accelerated.

pub fn to_array(self) -> [i8; 32]

pub fn as_array(&self) -> &[i8; 32]

pub fn as_mut_array(&mut self) -> &mut [i8; 32]

impl i8x32

pub const fn splat(elem: i8) -> i8x32

Trait Implementations

impl CmpEq<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpEq for i8x32

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGe for i8x32

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGt for i8x32

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLe for i8x32

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLt for i8x32

type Output = i8x32

👎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<i8> for i8x32

type Output = i8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpNe for i8x32

type Output = i8x32

👎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<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8x32> for i8

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for i8x32

type Output = i8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&i8x32> for i8x32

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

Performs the += operation.

impl AddAssign for i8x32

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AlignTo for i8x32

type Elem = i8

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 i8x32

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

Formats the value using the given formatter.

impl BitAnd<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd for i8x32

type Output = i8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<&i8x32> for i8x32

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

Performs the &= operation.

impl BitAndAssign for i8x32

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for i8x32

type Output = i8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<&i8x32> for i8x32

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

Performs the |= operation.

impl BitOrAssign for i8x32

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor for i8x32

type Output = i8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign<&i8x32> for i8x32

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

Performs the ^= operation.

impl BitXorAssign for i8x32

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for i8x32

fn clone(&self) -> i8x32

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for i8x32

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

Formats the value using the given formatter.

impl Default for i8x32

fn default() -> i8x32

Returns the “default value” for a type.

impl Display for i8x32

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

Formats the value using the given formatter.

impl Div<i8> for i8x32

fn div(self, rhs: i8) -> 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 = i8x32

The resulting type after applying the / operator.

impl Div<i8x32> for i8

fn div(self, rhs: i8x32) -> 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 = i8x32

The resulting type after applying the / operator.

impl Div for i8x32

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 = i8x32

The resulting type after applying the / operator.

impl From<&[i8]> for i8x32

fn from(src: &[i8]) -> i8x32

Converts to this type from the input type.

impl From<[i8; 32]> for i8x32

fn from(arr: [i8; 32]) -> Self

Converts to this type from the input type.

impl From<i8> for i8x32

fn from(elem: i8) -> Self

Splats the single value given across all lanes.

impl From<i8x32> for [i8; 32]

fn from(simd: i8x32) -> Self

Converts to this type from the input type.

impl LowerExp for i8x32

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

Formats the value using the given formatter.

impl LowerHex for i8x32

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

Formats the value using the given formatter.

impl Mul<i8> for i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8x32> for i8

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for i8x32

type Output = i8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for &i8x32

type Output = i8x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for i8x32

type Output = i8x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for &i8x32

type Output = i8x32

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for i8x32

type Output = i8x32

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Octal for i8x32

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

Formats the value using the given formatter.

impl PartialEq for i8x32

fn eq(&self, other: &i8x32) -> 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 Rem<i8> for i8x32

fn rem(self, rhs: i8) -> 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 = i8x32

The resulting type after applying the % operator.

impl Rem<i8x32> for i8

fn rem(self, rhs: i8x32) -> 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 = i8x32

The resulting type after applying the % operator.

impl Rem for i8x32

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 = i8x32

The resulting type after applying the % operator.

impl Shl<i128> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<i16> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<i32> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<i64> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<i8> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<u128> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<u16> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<u32> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<u64> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl<u8> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the << operator.

impl Shl for i8x32

type Output = i8x32

The resulting type after applying the << operator.

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

Performs the << operation.

impl Shr<i128> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<i16> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<i32> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<i64> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<i8> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<u128> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<u16> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<u32> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<u64> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr<u8> for i8x32

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

Shifts all lanes by a uniform value.

type Output = i8x32

The resulting type after applying the >> operator.

impl Shr for i8x32

type Output = i8x32

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl Sub<&i8x32> for i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8> for i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i8x32> for i8

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for i8x32

type Output = i8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&i8x32> for i8x32

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

Performs the -= operation.

impl SubAssign for i8x32

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<RHS> Sum<RHS> for i8x32

where i8x32: 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 i8x32

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

Formats the value using the given formatter.

impl UpperHex for i8x32

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

Formats the value using the given formatter.

impl Zeroable for i8x32

fn zeroed() -> Self

Calls zeroed.

impl Copy for i8x32

impl Eq for i8x32

impl Pod for i8x32

impl StructuralPartialEq for i8x32