Struct i64x8

Source

pub struct i64x8 { /* private fields */ }

Expand description

A SIMD vector with eight elements of type i64.

See the crate level documentation for more information about SIMD vectors.

Returns a mask that checks if each element of self is greater than or equal to the corresponding element of other.

Source

pub fn bitselect(self, if_one: Self, if_zero: Self) -> Self

Bitwise selection.

For each bit of self:

If the bit is one, return the corresponding bit of if_one
If the bit is zero, return the corresponding bit of if_zero

If you know self is a mask, meaning each element is either all zeros or all ones, consider using select which is faster.

Source

pub fn select(self, if_true: Self, if_false: Self) -> Self

Elementwise selection.

For each element of self:

If all bits are one, return the corresponding element of if_true
If all bits are zero, return the corresponding element of if_false

This function assumes self is a mask, meaning each element is either all zeros or all ones. For bitwise selection use bitselect.

Source

pub fn to_bitmask(self) -> u32

Converts to a bitmask, where each bit is 1 if the element of self is true or 0 if the element of self is false.

Each bit of the output corresponds to an element of self. The least significant bit corresponds to the lowest element. Remaining bits are 0.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

returns the bit mask for each high bit set in the vector with the lowest lane being the lowest bit

Source

pub fn any(self) -> bool

Returns true if any element of self is true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

true if any high bits are set for any value in the vector

Source

pub fn all(self) -> bool

Returns true if all elements of self are true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

true if all high bits are set for every value in the vector

Source

pub fn none(self) -> bool

Returns true if none of the elements of self are true.

This function assumes self is a mask, meaning each element is either all zeros or all ones. If the input is not a mask, the result is unspecified.

Source

pub fn transpose(data: [i64x8; 8]) -> [i64x8; 8]

Transposes an array of SIMD vectors interpreted as a square matrix.

Currently this function is never accelerated.

Source

pub fn blend(self, if_true: Self, if_false: Self) -> Self

👎Deprecated since 1.6.0:

split into select and bitselect functions

Elementwise selection.

For each element of self:

If all bits are one, return the corresponding element of if_true
If all bits are zero, return the corresponding element of if_false

Returns the bit patterns of self reinterpreted as unsigned integers of the same size.

Source

pub fn unbounded_shl(self, rhs: u64x8) -> Self

Shifts left each element of self by the corresponding element of rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in i64, the entire value is shifted out, and 0 is returned.

This is different from the standard operator, which behaves like wrapping_shl. For most targets, unbounded_shl is faster than the standard operator.

If you intend to shift all elements by the same value, consider using unbounded_shl_scalar which is faster.

Source

pub fn unbounded_shl_scalar(self, rhs: u32) -> Self

Shifts left each element of self by the uniform scalar rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in i64, the entire value is shifted out, and 0 is returned.

This is different from the standard operator, which behaves like wrapping_shl. For most targets, unbounded_shl_scalar is faster than the standard operator.

This function is faster than self.unbounded_shl(splat(rhs)) because it has special hardware support.

Source

pub fn unbounded_shr(self, rhs: u64x8) -> Self

Shifts right each element of self by the corresponding element of rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in i64, the entire value is shifted out, which yields 0 for a positive number, and -1 for a negative number.

This is different from the standard operator, which behaves like wrapping_shr. For most targets, unbounded_shr is faster than the standard operator.

If you intend to shift all elements by the same value, consider using unbounded_shr_scalar which is faster.

Source

pub fn unbounded_shr_scalar(self, rhs: u32) -> Self

Shifts right each element of self by the uniform scalar rhs, without bounding rhs.

If rhs is larger than or equal to the number of bits in i64, the entire value is shifted out, which yields 0 for a positive number, and -1 for a negative number.

This is different from the standard operator, which behaves like wrapping_shr. For most targets, unbounded_shr_scalar is faster than the standard operator.

Source

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

Returns self - rhs and whether an overflow occured.

Returns a tuple with:

The subtraction (returns the wrapped value if an overflow occured)
A mask indicating whether an overflow occured

Source

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

Returns self * rhs and whether an overflow occured.

Returns a tuple with:

The multiplication (returns the wrapped value if an overflow occured)
A mask indicating whether an overflow occured

Source

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

Returns self / rhs and whether an overflow occured.

Returns a tuple with:

The division (returns self if an overflow occured)
A mask indicating whether an overflow occured

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

Source

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

Returns self % rhs and whether an overflow occured.

Returns a tuple with:

The remainder (returns zero if an overflow occured)
A mask indicating whether an overflow occured

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

Source

pub fn mul_keep_low_high(self, rhs: Self) -> (u64x8, i64x8)

Computes self * rhs, producing intermediate 128-bit integers, then returns their low 64-bit parts and high 64-bit parts in two seperate SIMD vectors.

This function is different from widening_mul, which returns a single SIMD vector of a larger integer type, instead of two seperate SIMD vectors for low and high parts. Also note that while mul_keep_low_high exists for all types, widening_mul does not exist for types with no wider variant (e.g., for i32x16 because there is no i64x16).

Source