Struct faster::vecs::f32x8

#[repr(simd)]
pub struct f32x8(_, _, _, _, _, _, _, _);

Methods

impl f32x8

pub const fn new(
    x0: f32,
    x1: f32,
    x2: f32,
    x3: f32,
    x4: f32,
    x5: f32,
    x6: f32,
    x7: f32
) -> f32x8

pub fn len() -> i32

pub fn splat(value: f32) -> f32x8

pub fn extract(self, idx: u32) -> f32

pub unsafe fn extract_unchecked(self, idx: u32) -> f32

pub fn replace(self, idx: u32, val: f32) -> f32x8

pub unsafe fn replace_unchecked(self, idx: u32, val: f32) -> f32x8

pub fn store(self, slice: &mut [f32], offset: usize)

pub unsafe fn store_unchecked(self, slice: &mut [f32], offset: usize)

pub fn load(slice: &[f32], offset: usize) -> f32x8

pub unsafe fn load_unchecked(slice: &[f32], offset: usize) -> f32x8

pub fn eq(self, other: f32x8) -> i32x8

pub fn ne(self, other: f32x8) -> i32x8

pub fn lt(self, other: f32x8) -> i32x8

pub fn le(self, other: f32x8) -> i32x8

pub fn gt(self, other: f32x8) -> i32x8

pub fn ge(self, other: f32x8) -> i32x8

impl f32x8

pub fn as_u32x8(self) -> u32x8

impl f32x8

pub fn as_i32x8(self) -> i32x8

Trait Implementations

impl Copy for f32x8

impl AddAssign<f32x8> for f32x8

fn add_assign(&mut self, other: f32x8)

Performs the += operation.

impl Neg for f32x8

type Output = f32x8

The resulting type after applying the - operator.

fn neg(self) -> f32x8

Performs the unary - operation.

impl Rem<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the % operator.

fn rem(self, other: f32x8) -> f32x8

Performs the % operation.

impl Sub<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the - operator.

fn sub(self, other: f32x8) -> f32x8

Performs the - operation.

impl Add<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the + operator.

fn add(self, other: f32x8) -> f32x8

Performs the + operation.

impl Clone for f32x8

fn clone(&self) -> f32x8

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Div<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the / operator.

fn div(self, other: f32x8) -> f32x8

Performs the / operation.

impl DivAssign<f32x8> for f32x8

fn div_assign(&mut self, other: f32x8)

Performs the /= operation.

impl Mul<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the * operator.

fn mul(self, other: f32x8) -> f32x8

Performs the * operation.

impl Debug for f32x8

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl RemAssign<f32x8> for f32x8

fn rem_assign(&mut self, other: f32x8)

Performs the %= operation.

impl SubAssign<f32x8> for f32x8

fn sub_assign(&mut self, other: f32x8)

Performs the -= operation.

impl MulAssign<f32x8> for f32x8

fn mul_assign(&mut self, other: f32x8)

Performs the *= operation.

impl PartialEq<f32x8> for f32x8

fn eq(&self, __arg_0: &f32x8) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &f32x8) -> bool

This method tests for !=.

impl Packed for f32x8

type Scalar = f32

The type which fits into this SIMD vector

const WIDTH: usize

WIDTH: usize = 8

The number of elements in this vector

fn load(data: &[f32], offset: usize) -> f32x8

Create a new vector with Self::WIDTH elements from data, beginning at offset.

unsafe fn load_unchecked(data: &[f32], offset: usize) -> f32x8

Create a new vector with Self::WIDTH elements from data, beginning at offset, without asserting length of data.

fn store(self, data: &mut [f32], offset: usize)

Write Self::WIDTH elements from this vector to data, beginning at offset.

fn coalesce(self) -> Self::Scalar

Assert all elements of the vector are equal, then return the element. Opposiite operation of Self::splat.

fn extract(&self, idx: usize) -> Self::Scalar

Return the idxth element of this vector.

fn replace(&mut self, idx: usize, data: Self::Scalar) -> Self

Replace the idxth element of this vector with data.

fn splat(data: f32) -> Self

Return a vector with all elements initialized to data. Opposite operation for Self::coalesce.

fn default() -> Self

Return a vector with all elements initialized to the default value for the underlying element type.

fn product(&self) -> Self::Scalar

Return a scalar equivalent to the product of all elements of this vector.

fn sum(&self) -> Self::Scalar

Return a scalar equivalent to the sum of all elements of this vector.

fn scalar_reduce<T, F>(&self, acc: T, func: F) -> T where
    F: FnMut(T, Self::Scalar) -> T, 

Return the result of a scalar reduction over this vector

fn width(&self) -> usize

Return the number of elements in this vector

impl PackedPattern for f32x8

fn halfs(hi: Self::Scalar, lo: Self::Scalar) -> Self

Return a vector whose first Self::WIDTH / 2 elements are hi, and whose last Self::WIDTH / 2 elements are lo.

fn interleave(hi: Self::Scalar, lo: Self::Scalar) -> Self

Return a vector containing hi at every even index, and lo at every odd index.

fn partition_mask(off: usize) -> Self

Return a vector whose first off elements are memset to 0x00, and whose last Self::WIDTH - off elements are memset to 0xFF.

fn partition(hi: Self::Scalar, lo: Self::Scalar, off: usize) -> Self

Return a vector whose first off elements are hi, and whose last Self::WIDTH - off elements are lo.

impl PackedAbs for f32x8

type Out = f32x8

fn abs(&self) -> Self::Out

Return a vector the absolute value of the elements of self.

impl PackedSqrt for f32x8

fn sqrt(&self) -> Self

Return a vector the containing square roots of the elements of self.

impl PackedTransmute for f32x8

type i8s = i8x32

type u8s = u8x32

type i16s = i16x16

type u16s = u16x16

type i32s = i32x8

type u32s = u32x8

type f32s = f32x8

type i64s = i64x4

type u64s = u64x4

type f64s = f64x4

fn be_i8s(&self) -> Self::i8s

fn be_u8s(&self) -> Self::u8s

fn be_i16s(&self) -> Self::i16s

fn be_u16s(&self) -> Self::u16s

fn be_i32s(&self) -> Self::i32s

fn be_u32s(&self) -> Self::u32s

unsafe fn be_f32s_unchecked(&self) -> Self::f32s

fn be_i64s(&self) -> Self::i64s

fn be_u64s(&self) -> Self::u64s

unsafe fn be_f64s_unchecked(&self) -> Self::f64s

impl Asu32s for f32x8

type Cast = u32x8

fn as_u32s(self) -> Self::Cast

Return a vector containing all elements of self cast to u32s.

impl Asi32s for f32x8

type Cast = i32x8

fn as_i32s(self) -> Self::Cast

Return a vector containing all elements of self cast to i32s.

impl Upcast<f64x4> for f32x8

fn upcast(self) -> (f64x4, f64x4)

Return two vectors containing elements of the same value, but different type. The first vector contains the first half of self, and the second vector contains the second half. Both returned vectors are equal in size to self.

impl Downcast<f32x8> for f64x4

fn saturating_downcast(self, other: Self) -> f32x8

Return a vector containing elements of the same value as self and other, but different type. The first half of the returned vector contains the downcast values of self, whereas the second half of the returned vector contains the downcast values of other. The returned vector is equal in size to self and other. If an element exceeds the maximum or minimum value of the downcast type, it is saturated.

impl PackedRound for f32x8

fn round(&self) -> Self

Return a vector with all elements of self rounded to the nearest integer.

fn ceil(&self) -> Self

Return a vector with all elements of self rounded up to the nearest integer.

fn floor(&self) -> Self

Return a vector with all elements of self rounded down to the nearest integer.

fn trunc(&self) -> Self

Return a vector with all elements of self truncated. Effectively rounds the elements towards zero.

impl PackedRecip for f32x8

fn recip(&self) -> Self

Return a vector containing an estimation of the reciprocal of the corresponding elements of self.

impl PackedHadd for f32x8

fn hadd(&self, other: Self) -> Self

Return a vector containing the interleaved sums of elements in self and other. The returned vector will begin with the sum of the first two elements in self, and end with the sum of the last two elements in other

impl PackedHsub for f32x8

fn hsub(&self, other: Self) -> Self

Return a vector containing the interleaved differences of elements in self and other. The returned vector will begin with the difference of the first two elements in self, and end with the difference of the last two elements in other

impl PackedRsqrt for f32x8

fn rsqrt(&self) -> Self

Return a vector containing an approximation of the reciprocals of the square-roots of elements in self. May contain significant float error past 10^-3.

impl PackedCmp for f32x8

fn min(&self, other: Self) -> Self

Return a vector where each element at an index i is the minimum of the elements at index i in self and other.

fn max(&self, other: Self) -> Self

Return a vector where each element at an index i is the maximum of the elements at index i in self and other.

impl PackedEq for f32x8

fn eq(&self, other: &Self) -> Self

Return a vector where each element at an index i is filled with 1s if the elements of self and other at index i are equal, and filled with zeroes otherwise.

impl PackedMerge for f32x8

fn merge_halves(&self, other: Self) -> Self

Return a vector with the first half populated by the first half of self, and the second half populated by the second half of other.

fn merge_interleaved(&self, other: Self) -> Self

Return a vector containing the even elements of self interleaved with the odd elements of other, starting with the first element of self.

fn merge_partitioned(&self, other: Self, offset: usize) -> Self

Return a vector containing the first offset elements of self, then the last (Self::WIDTH - offset) elements of other.

impl PackedSwizzle for f32x8

fn flip(&self) -> Self

Return a vector containing elements of self, but with even and odd elements swapped in-place. For (n = 0, 2, ... Self::WIDTH), elements at indices n and n + 1 are swapped.