Struct vrl::Vec4f

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

Implementations

impl Vec4f

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

Loads vector from an aligned array pointed by addr.

Safety

Like load, requires addr to be valid. Unlike load, requires addr to be divisible by 16, i.e. to be a 16-bytes aligned address.

Examples

#[repr(align(16))]
struct AlignedArray([f32; 4]);

let array = AlignedArray([42.0; 4]);
let vec = unsafe { Vec4f::load_ptr_aligned(array.0.as_ptr()) };
assert_eq!(vec, Vec4f::broadcast(42.0));

In the following example zeros is aligned 2-bytes aligned. Therefore zeros.as_ptr().byte_add(1) is an odd address and hence not divisible by 16.

let zeros = unsafe { std::mem::zeroed::<[u16; 10]>() };
unsafe { Vec4f::load_ptr_aligned(zeros.as_ptr().byte_add(1) as *const f32) };

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

Stores vector into aligned array at given address.

Safety

Like store_ptr, requires addr to be valid. Unlike store_ptr, requires addr to be divisible by 16, i.e. to be a 16-bytes aligned address.

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

Safety

Has same requirements as store_ptr_aligned: addr must be valid and divisible by 16, i.e. to be a 16-bytes aligned address.

Trait Implementations

impl Add<Vec4f> for f32

type Output = Vec4f

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f32> for Vec4f

type Output = Vec4f

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Vec4f

type Output = Vec4f

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AddAssign<T> for Vec4f

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

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl Clone for Vec4f

fn clone(&self) -> Vec4f

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vec4f

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

Formats the value using the given formatter.

impl Default for Vec4f

fn default() -> Self

Returns the “default value” for a type.

impl Div<Vec4f> for f32

type Output = Vec4f

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for Vec4f

type Output = Vec4f

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Vec4f

type Output = Vec4f

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> DivAssign<T> for Vec4f

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

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl From<&[f32; 4]> for Vec4f

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

Does same as load.

impl From<&Vec4f> for [f32; 4]

fn from(value: &Vec4f) -> Self

Converts to this type from the input type.

impl From<[f32; 4]> for Vec4f

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

Converts to this type from the input type.

impl From<Vec4f> for [f32; 4]

fn from(value: Vec4f) -> Self

Converts to this type from the input type.

impl From<Vec4f> for __m128

fn from(original: Vec4f) -> Self

Converts to this type from the input type.

impl From<__m128> for Vec4f

fn from(original: __m128) -> Vec4f

Converts to this type from the input type.

impl Index<usize> for Vec4f

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 Vec4f

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

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

impl Mul<Vec4f> for f32

type Output = Vec4f

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Vec4f

type Output = Vec4f

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Vec4f

type Output = Vec4f

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<T> for Vec4f

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

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl Neg for Vec4f

type Output = Vec4f

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Vec4f

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 Vec4f

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<4> for Vec4f

type Underlying = __m128

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

Stores vector into array at given address.

fn sum(self) -> f32

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 Vec4f

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 Vec4f

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

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

impl SIMDPartialStore<f32> for Vec4f

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

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

impl Sub<Vec4f> for f32

type Output = Vec4f

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f32> for Vec4f

type Output = Vec4f

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Vec4f

type Output = Vec4f

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> SubAssign<T> for Vec4f

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

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl Sum for Vec4f

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 Vec4fBase for Vec4f

fn new(v0: f32, v1: f32, v2: f32, v3: f32) -> Self

Initializes elements of returned vector with given values.

impl Copy for Vec4f

impl SIMDVector<4> for Vec4f