Struct u8x32 

pub struct u8x32 { /* private fields */ }

Implementations

impl u8x32

pub const ONE: u8x32

pub const ZERO: u8x32

pub const MAX: u8x32

pub const MIN: u8x32

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 u8x32

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

pub fn reduce_max(self) -> u8

pub fn reduce_min(self) -> u8

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 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: u8x32) -> u8x32

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 none(self) -> bool

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

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

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

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

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

impl u8x32

pub const fn splat(elem: u8) -> u8x32

Trait Implementations

impl CmpEq<u8> for u8x32

type Output = u8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpEq for u8x32

type Output = u8x32

👎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<u8> for u8x32

type Output = u8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGe for u8x32

type Output = u8x32

👎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<u8> for u8x32

type Output = u8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpGt for u8x32

type Output = u8x32

👎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<u8> for u8x32

type Output = u8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLe for u8x32

type Output = u8x32

👎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<u8> for u8x32

type Output = u8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpLt for u8x32

type Output = u8x32

👎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<u8> for u8x32

type Output = u8x32

👎Deprecated since 1.5.0:

use inherit function instead

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

👎Deprecated since 1.5.0:

use inherit function instead

impl CmpNe for u8x32

type Output = u8x32

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

type Output = u8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8> for u8x32

type Output = u8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8x32> for u8

type Output = u8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for u8x32

type Output = u8x32

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&u8x32> for u8x32

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

Performs the += operation.

impl AddAssign for u8x32

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AlignTo for u8x32

type Elem = u8

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 u8x32

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

Formats the value using the given formatter.

impl BitAnd<&u8x32> for u8x32

type Output = u8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd for u8x32

type Output = u8x32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<&u8x32> for u8x32

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

Performs the &= operation.

impl BitAndAssign for u8x32

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<&u8x32> for u8x32

type Output = u8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr for u8x32

type Output = u8x32

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<&u8x32> for u8x32

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

Performs the |= operation.

impl BitOrAssign for u8x32

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<&u8x32> for u8x32

type Output = u8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor for u8x32

type Output = u8x32

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign<&u8x32> for u8x32

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

Performs the ^= operation.

impl BitXorAssign for u8x32

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for u8x32

fn clone(&self) -> u8x32

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for u8x32

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

Formats the value using the given formatter.

impl Default for u8x32

fn default() -> u8x32

Returns the “default value” for a type.

impl Display for u8x32

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

Formats the value using the given formatter.

impl Div<u8> for u8x32

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

The resulting type after applying the / operator.

impl Div<u8x32> for u8

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

The resulting type after applying the / operator.

impl Div for u8x32

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

The resulting type after applying the / operator.

impl From<&[u8]> for u8x32

fn from(src: &[u8]) -> u8x32

Converts to this type from the input type.

impl From<[u8; 32]> for u8x32

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

Converts to this type from the input type.

impl From<u8> for u8x32

fn from(elem: u8) -> Self

Splats the single value given across all lanes.

impl From<u8x32> for [u8; 32]

fn from(simd: u8x32) -> Self

Converts to this type from the input type.

impl LowerExp for u8x32

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

Formats the value using the given formatter.

impl LowerHex for u8x32

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

Formats the value using the given formatter.

impl Mul<u8> for u8x32

type Output = u8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<u8x32> for u8

type Output = u8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for u8x32

type Output = u8x32

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for &u8x32

type Output = u8x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for u8x32

type Output = u8x32

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for &u8x32

type Output = u8x32

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for u8x32

type Output = u8x32

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Octal for u8x32

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

Formats the value using the given formatter.

impl PartialEq for u8x32

fn eq(&self, other: &u8x32) -> 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<u8> for u8x32

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

The resulting type after applying the % operator.

impl Rem<u8x32> for u8

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

The resulting type after applying the % operator.

impl Rem for u8x32

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

The resulting type after applying the % operator.

impl Shl<i128> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<i16> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<i32> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<i64> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<i8> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<u128> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<u16> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<u32> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<u64> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl<u8> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the << operator.

impl Shl for u8x32

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

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

The resulting type after applying the << operator.

impl Shr<i128> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<i16> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<i32> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<i64> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<i8> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<u128> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<u16> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<u32> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<u64> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr<u8> for u8x32

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

Shifts all lanes by a uniform value.

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

The resulting type after applying the >> operator.

impl Shr for u8x32

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

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

The resulting type after applying the >> operator.

impl Sub<&u8x32> for u8x32

type Output = u8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u8> for u8x32

type Output = u8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<u8x32> for u8

type Output = u8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for u8x32

type Output = u8x32

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&u8x32> for u8x32

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

Performs the -= operation.

impl SubAssign for u8x32

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<RHS> Sum<RHS> for u8x32

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

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

Formats the value using the given formatter.

impl UpperHex for u8x32

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

Formats the value using the given formatter.

impl Zeroable for u8x32

fn zeroed() -> Self

Calls zeroed.

impl Copy for u8x32

impl Eq for u8x32

impl Pod for u8x32

impl StructuralPartialEq for u8x32