Struct vrl::Vec8f

pub struct Vec8f(/* private fields */);

Trait Implementations

impl Add<Vec8f> for f32

type Output = Vec8f

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f32> for Vec8f

type Output = Vec8f

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Vec8f

type Output = Vec8f

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign<T> for Vec8f

where Self: Add<T, Output = Self>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl Clone for Vec8f

fn clone(&self) -> Vec8f

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vec8f

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

Formats the value using the given formatter.

impl Default for Vec8f

fn default() -> Self

Returns the “default value” for a type.

impl Div<Vec8f> for f32

type Output = Vec8f

The resulting type after applying the / operator.

fn div(self, rhs: Vec8f) -> Self::Output

Performs the / operation.

impl Div<f32> for Vec8f

type Output = Vec8f

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Self::Output

Performs the / operation.

impl Div for Vec8f

type Output = Vec8f

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign<T> for Vec8f

where Self: Div<T, Output = Self>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl From<&[f32; 8]> for Vec8f

fn from(value: &[f32; 8]) -> Self

Does same as load.

impl From<&Vec8f> for [f32; 8]

fn from(value: &Vec8f) -> Self

Converts to this type from the input type.

impl From<[f32; 8]> for Vec8f

fn from(value: [f32; 8]) -> Self

Converts to this type from the input type.

impl From<(Vec4f, Vec4f)> for Vec8f

fn from((low, high): (Vec4f, Vec4f)) -> Self

Does same as join.

impl From<Vec8f> for [f32; 8]

fn from(value: Vec8f) -> Self

Converts to this type from the input type.

impl From<Vec8f> for (Vec4f, Vec4f)

fn from(vec: Vec8f) -> (Vec4f, Vec4f)

Does same as split.

impl From<Vec8f> for __m256

fn from(original: Vec8f) -> Self

Converts to this type from the input type.

impl From<__m256> for Vec8f

fn from(original: __m256) -> Vec8f

Converts to this type from the input type.

impl Index<usize> for Vec8f

type Output = f32

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Vec8f

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl Mul<Vec8f> for f32

type Output = Vec8f

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Vec8f

type Output = Vec8f

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Vec8f

type Output = Vec8f

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<T> for Vec8f

where Self: Mul<T, Output = Self>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl Neg for Vec8f

type Output = Vec8f

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Vec8f

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Product for Vec8f

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl SIMDBase<8> for Vec8f

type Underlying = __m256

Underlying intrinsic type or tuple of types.

type Element = f32

Type of a single element of packed vector.

fn broadcast(value: f32) -> Self

Initializes all values of returned vector with a given value.

unsafe fn load_ptr(addr: *const f32) -> Self

Loads vector from an array pointed by addr. addr is not required to be aligned.

unsafe fn store_ptr(self, addr: *mut Self::Element)

Stores vector into array at given address.

fn sum(self) -> Self::Element

Calculates the sum of all elements of vector.

const N: usize = N

Number of elements in vector.

fn load(data: &[Self::Element; N]) -> Self

Loads vector from a given array.

fn load_checked(data: &[Self::Element]) -> Self

Checks that data contains exactly N elements and loads them into vector.

fn load_prefix(data: &[Self::Element]) -> Self

Loads first N elements of data into vector.

fn store(self, array: &mut [Self::Element; N])

Stores vector into given array.

fn store_checked(self, slice: &mut [Self::Element])

Checks that slice contains exactly N elements and stores elements of vector there.

fn store_prefix(self, slice: &mut [Self::Element])

Stores elements of the vector into prefix of slice.

fn extract(self, index: usize) -> Self::Element

Extracts index-th element of the vector. Index 0 corresponds to the “most left” element.

fn extract_wrapping(self, index: usize) -> Self::Element

Extracts index % N-th element of the vector. This corresponds to the original extract function from VCL.

fn extract_const<const INDEX: i32>(self) -> Self::Element

Extracts INDEX-th element of the vector. Does same as extract with compile-time known index.

impl SIMDFloat for Vec8f

fn round(self) -> Self

Rounds values of the vector to the nearest integers. In case of two integers are equally close (i.e. fractional part of a number equals 0.5) the behavior depends on platform.

impl SIMDPartialLoad<f32> for Vec8f

fn load_partial(data: &[f32]) -> Self

Loads first min(N, data.len()) elements of data into vector.

impl SIMDPartialStore<f32> for Vec8f

fn store_partial(&self, slice: &mut [f32])

Stores min(N, slice.len()) elements of vector into prefix of slice.

impl Sub<Vec8f> for f32

type Output = Vec8f

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f32> for Vec8f

type Output = Vec8f

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Vec8f

type Output = Vec8f

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign<T> for Vec8f

where Self: Sub<T, Output = Self>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl Sum for Vec8f

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Vec8fBase for Vec8f

fn new( v0: f32, v1: f32, v2: f32, v3: f32, v4: f32, v5: f32, v6: f32, v7: f32 ) -> Self

Initializes elements of returned vector with given values.

fn join(low: Vec4f, high: Vec4f) -> Self

Joins two Vec4f into a single Vec8f. The first four elements of returned vector are elements of a and the last four elements are elements of b.

fn low(self) -> Vec4f

Returns the first four elements of vector.

fn high(self) -> Vec4f

Returns the last four elements of vector.

unsafe fn load_ptr_aligned(addr: *const f32) -> Self

Loads vector from aligned array pointed by addr.

unsafe fn store_ptr_aligned(self, addr: *mut f32)

Stores vector into aligned array at given address.

unsafe fn store_ptr_non_temporal(self, addr: *mut f32)

Stores vector into aligned array at given address in uncached memory (non-temporal store). This may be more efficient than store_ptr_aligned if it is unlikely that stored data will stay in cache until it is read again, for instance, when storing large blocks of memory.

fn split(self) -> (Vec4f, Vec4f)

Splits vector into low and high halfs.

impl Copy for Vec8f

impl SIMDVector<8> for Vec8f