Required Methods

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

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).

fn wrapping_neg(self) -> Self

Wrapping negation.

Like u32::wrapping_neg, all applications of this function will wrap, with the exception of -0.

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

Lanewise saturating add.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::prelude::*;
use core::u32::MAX;
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x + max;
let sat = x.saturating_add(max);
assert_eq!(unsat, Simd::from_array([1, 0, MAX, MAX - 1]));
assert_eq!(sat, max);

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

Lanewise saturating subtract.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::prelude::*;
use core::u32::MAX;
let x = Simd::from_array([2, 1, 0, MAX]);
let max = Simd::splat(MAX);
let unsat = x - max;
let sat = x.saturating_sub(max);
assert_eq!(unsat, Simd::from_array([3, 2, 1, 0]));
assert_eq!(sat, Simd::splat(0));

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

Lanewise absolute difference. Every element becomes the absolute difference of self and second.

Examples

# #![feature(portable_simd)]
# #[cfg(feature = "as_crate")] use core_simd::simd;
# #[cfg(not(feature = "as_crate"))] use core::simd;
# use simd::prelude::*;
use core::u32::MAX;
let a = Simd::from_array([0, MAX, 100, 20]);
let b = Simd::from_array([MAX, 0, 80, 200]);
assert_eq!(a.abs_diff(b), Simd::from_array([MAX, MAX, 20, 180]));

fn reduce_sum(self) -> Self::Scalar

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

fn reduce_product(self) -> Self::Scalar

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

fn reduce_max(self) -> Self::Scalar

Returns the maximum element in the vector.

fn reduce_min(self) -> Self::Scalar

Returns the minimum element in the vector.

fn reduce_and(self) -> Self::Scalar

Returns the cumulative bitwise "and" across the elements of the vector.

fn reduce_or(self) -> Self::Scalar

Returns the cumulative bitwise "or" across the elements of the vector.

fn reduce_xor(self) -> Self::Scalar

Returns the cumulative bitwise "xor" across the elements of the vector.

fn swap_bytes(self) -> Self

Reverses the byte order of each element.

fn reverse_bits(self) -> Self

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.

fn count_ones(self) -> Self

Returns the number of ones in the binary representation of each element.

fn count_zeros(self) -> Self

Returns the number of zeros in the binary representation of each element.

fn leading_zeros(self) -> Self

Returns the number of leading zeros in the binary representation of each element.

fn trailing_zeros(self) -> Self

Returns the number of trailing zeros in the binary representation of each element.

fn leading_ones(self) -> Self

Returns the number of leading ones in the binary representation of each element.

fn trailing_ones(self) -> Self

Returns the number of trailing ones in the binary representation of each element.