Trait SimdInt

source

pub trait SimdInt: Copy + Sealed {
    type Mask;
    type Scalar;
    type Unsigned;
    type Cast<T: SimdElement>;

Show 22 methods    // Required methods
    fn cast<T>(self) -> Self::Cast<T>
       where T: SimdCast;
    fn saturating_add(self, second: Self) -> Self;
    fn saturating_sub(self, second: Self) -> Self;
    fn abs(self) -> Self;
    fn saturating_abs(self) -> Self;
    fn saturating_neg(self) -> Self;
    fn is_positive(self) -> Self::Mask;
    fn is_negative(self) -> Self::Mask;
    fn signum(self) -> Self;
    fn reduce_sum(self) -> Self::Scalar;
    fn reduce_product(self) -> Self::Scalar;
    fn reduce_max(self) -> Self::Scalar;
    fn reduce_min(self) -> Self::Scalar;
    fn reduce_and(self) -> Self::Scalar;
    fn reduce_or(self) -> Self::Scalar;
    fn reduce_xor(self) -> Self::Scalar;
    fn swap_bytes(self) -> Self;
    fn reverse_bits(self) -> Self;
    fn leading_zeros(self) -> Self::Unsigned;
    fn trailing_zeros(self) -> Self::Unsigned;
    fn leading_ones(self) -> Self::Unsigned;
    fn trailing_ones(self) -> Self::Unsigned;
}

🔬This is a nightly-only experimental API. (portable_simd)

Expand description

Operations on SIMD vectors of signed integers.

Required Associated Types§

source

type Mask

🔬This is a nightly-only experimental API. (portable_simd)

Mask type used for manipulating this SIMD vector type.

source

type Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Scalar type contained by this SIMD vector type.

source

type Unsigned

🔬This is a nightly-only experimental API. (portable_simd)

A SIMD vector of unsigned integers with the same element size.

source

type Cast<T: SimdElement>

🔬This is a nightly-only experimental API. (portable_simd)

A SIMD vector with a different element type.

Required Methods§

source

fn cast<T>(self) -> Self::Cast<T>
where T: SimdCast,

🔬This is a nightly-only experimental API. (portable_simd)

Performs elementwise conversion of this vector’s elements to another SIMD-valid type.

This follows the semantics of Rust’s as conversion for casting integers (wrapping to other integer types, and saturating to float types).

source

fn saturating_add(self, second: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

Lanewise saturating add.

§Examples

use core::i32::{MIN, MAX};
let x = Simd::from_array([MIN, 0, 1, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([-1, MAX, MIN, -2]));
assert_eq!(sat, Simd::from_array([-1, MAX, MAX, MAX]));

source

fn saturating_sub(self, second: Self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

Lanewise saturating subtract.

§Examples

use core::i32::{MIN, MAX};
let x = Simd::from_array([MIN, -2, -1, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([1, MAX, MIN, 0]));
assert_eq!(sat, Simd::from_array([MIN, MIN, MIN, 0]));

source

fn abs(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

Lanewise absolute value, implemented in Rust. Every element becomes its absolute value.

§Examples

use core::i32::{MIN, MAX};
let xs = Simd::from_array([MIN, MIN +1, -5, 0]);
assert_eq!(xs.abs(), Simd::from_array([MIN, MAX, 5, 0]));

source

fn saturating_abs(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

Lanewise saturating absolute value, implemented in Rust. As abs(), except the MIN value becomes MAX instead of itself.

§Examples

use core::i32::{MIN, MAX};
let xs = Simd::from_array([MIN, -2, 0, 3]);
let unsat = xs.abs();
let sat = xs.saturating_abs();
assert_eq!(unsat, Simd::from_array([MIN, 2, 0, 3]));
assert_eq!(sat, Simd::from_array([MAX, 2, 0, 3]));

source

fn saturating_neg(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

Lanewise saturating negation, implemented in Rust. As neg(), except the MIN value becomes MAX instead of itself.

§Examples

use core::i32::{MIN, MAX};
let x = Simd::from_array([MIN, -2, 3, MAX]);
let unsat = -x;
let sat = x.saturating_neg();
assert_eq!(unsat, Simd::from_array([MIN, 2, -3, MIN + 1]));
assert_eq!(sat, Simd::from_array([MAX, 2, -3, MIN + 1]));

source

fn is_positive(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd)

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

source

fn is_negative(self) -> Self::Mask

🔬This is a nightly-only experimental API. (portable_simd)

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

source

fn signum(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

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

source

fn reduce_sum(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Returns the sum of the elements of the vector, with wrapping addition.

§Examples

let v = i32x4::from_array([1, 2, 3, 4]);
assert_eq!(v.reduce_sum(), 10);

// SIMD integer addition is always wrapping
let v = i32x4::from_array([i32::MAX, 1, 0, 0]);
assert_eq!(v.reduce_sum(), i32::MIN);

source

fn reduce_product(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Returns the product of the elements of the vector, with wrapping multiplication.

§Examples

let v = i32x4::from_array([1, 2, 3, 4]);
assert_eq!(v.reduce_product(), 24);

// SIMD integer multiplication is always wrapping
let v = i32x4::from_array([i32::MAX, 2, 1, 1]);
assert!(v.reduce_product() < i32::MAX);

source

fn reduce_max(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Returns the maximum element in the vector.

§Examples

let v = i32x4::from_array([1, 2, 3, 4]);
assert_eq!(v.reduce_max(), 4);

source

fn reduce_min(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Returns the minimum element in the vector.

§Examples

let v = i32x4::from_array([1, 2, 3, 4]);
assert_eq!(v.reduce_min(), 1);

source

fn reduce_and(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Returns the cumulative bitwise “and” across the elements of the vector.

source

fn reduce_or(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Returns the cumulative bitwise “or” across the elements of the vector.

source

fn reduce_xor(self) -> Self::Scalar

🔬This is a nightly-only experimental API. (portable_simd)

Returns the cumulative bitwise “xor” across the elements of the vector.

source

fn swap_bytes(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

Reverses the byte order of each element.

source

fn reverse_bits(self) -> Self

🔬This is a nightly-only experimental API. (portable_simd)

Reverses the order of bits in each elemnent. The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

source