Struct Vec4f

pub struct Vec4f { /* private fields */ }

Represents a packed vector of 4 single-precision floating-point values. __m128 wrapper.

Implementations

impl Vec4f

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

Initializes elements of returned vector with given values.

Example

assert_eq!(
    Vec4f::new(1.0, 2.0, 3.0, 4.0),
    [1.0, 2.0, 3.0, 4.0].into()
);

pub unsafe fn load_ptr(addr: *const [f32; 4]) -> Self

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

Safety

addr must be a valid pointer.

Example

let array = [42.0; 4];
let vec = unsafe { Vec4f::load_ptr(&array) };

pub unsafe fn load_ptr_aligned(addr: *const [f32; 4]) -> Self

Loads vector from 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) };
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; 4]) };

pub fn load(data: &[f32; 4]) -> Self

Loads values of returned vector from given data.

Exmaple

assert_eq!(
    Vec4f::new(1.0, 2.0, 3.0, 4.0),
    Vec4f::load(&[1.0, 2.0, 3.0, 4.0])
);

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

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

Panics

Panics if data.len() isn’t 4.

Examples

assert_eq!(
    Vec4f::load_checked(&[1.0, 2.0, 3.0, 4.0]),
    Vec4f::new(1.0, 2.0, 3.0, 4.0)
);

Vec4f::load_checked(&[1.0, 2.0, 3.0]);

Vec4f::load_checked(&[1.0, 2.0, 3.0, 4.0, 5.0]);

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

Loads the first four elements of data into vector.

Panics

Panics if data contains less than four elements.

Exmaples

assert_eq!(
    Vec4f::load_prefix(&[1.0, 2.0, 3.0, 4.0, 5.0]),
    Vec4f::new(1.0, 2.0, 3.0, 4.0)
);

Vec4f::load_prefix(&[1.0, 2.0, 3.0]);

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

Loads first 4 elements of data if available otherwise initializes first elements of returned vector with values of data and rest elements with zeros.

Example

let values = [1.0, 2.0, 3.0, 4.0, 5.0];
assert_eq!(
    Vec4f::load_partial(&values),
    Vec4f::from(&values[..4].try_into().unwrap())
);
assert_eq!(
    Vec4f::load_partial(&values[..2]),
    Vec4f::new(1.0, 2.0, 0.0, 0.0)  // note zeros here
);

pub fn broadcast(value: f32) -> Self

Returns vector with all its elements initialized with a given value, i.e. broadcasts value to all elements of returned vector.

Example

assert_eq!(
    Vec4f::broadcast(42.0),
    [42.0; 4].into()
);

pub unsafe fn store_ptr(&self, addr: *mut [f32; 4])

Stores vector into array at given address.

Safety

addr must be a valid pointer.

pub unsafe fn store_ptr_aligned(&self, addr: *mut [f32; 4])

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; 4])

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.

pub fn store(&self, array: &mut [f32; 4])

Stores vector into given array.

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

Checkes that slice contains exactly four elements and store elements of vector there.

Panics

Panics if slice.len() isn’t 4.

Examples

let mut data = [-1.0; 4];
Vec4f::default().store_checked(&mut data);
assert_eq!(data, [0.0; 4]);

let mut data = [-1.0; 3];
Vec4f::default().store_checked(&mut data);

let mut data = [-1.0; 5];
Vec4f::default().store_checked(&mut data);

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

Stores elements of vector into the first four elements of slice.

Panics

Panics if slice contains less then four elements.

Exmaples

let mut data = [-1.0; 5];
Vec4f::broadcast(2.0).store_prefix(&mut data);
assert_eq!(data, [2.0, 2.0, 2.0, 2.0, -1.0]);

let mut data = [-1.0; 3];
Vec4f::default().store_prefix(&mut data);

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

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

Exmaples

let mut data = [0.0; 3];
Vec4f::broadcast(1.0).store_partial(&mut data);
assert_eq!(data, [1.0; 3]);

let mut data = [0.0; 5];
Vec4f::broadcast(1.0).store_partial(&mut data);
assert_eq!(data, [1.0, 1.0, 1.0, 1.0, 0.0]);  // note last zero

pub fn sum(self) -> f32

Calculates the sum of all elements of vector.

Exmaple

assert_eq!(Vec4f::new(1.0, 2.0, 3.0, 4.0).sum(), 10.0);

Trait Implementations

impl Add<<Vec4f as SIMDVector>::Element> for Vec4f

type Output = Vec4f

The resulting type after applying the + operator.

fn add(self, rhs: <Vec4f as SIMDVector>::Element) -> Self::Output

Performs the + operation.

impl Add<Vec4f> for <Vec4f as SIMDVector>::Element

type Output = Vec4f

The resulting type after applying the + operator.

fn add(self, rhs: Vec4f) -> 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

Initializes all elements of returned vector with zero.

Example

assert_eq!(Vec4f::default(), Vec4f::broadcast(0.0));

impl Div<<Vec4f as SIMDVector>::Element> for Vec4f

type Output = Vec4f

The resulting type after applying the / operator.

fn div(self, rhs: <Vec4f as SIMDVector>::Element) -> Self::Output

Performs the / operation.

impl Div<Vec4f> for <Vec4f as SIMDVector>::Element

type Output = Vec4f

The resulting type after applying the / operator.

fn div(self, rhs: Vec4f) -> 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(value: Vec4f) -> Self

Unwraps given vector into raw __m128 value.

impl From<__m128> for Vec4f

fn from(value: __m128) -> Self

Wraps given value into Vec4f.

impl Mul<<Vec4f as SIMDVector>::Element> for Vec4f

type Output = Vec4f

The resulting type after applying the * operator.

fn mul(self, rhs: <Vec4f as SIMDVector>::Element) -> Self::Output

Performs the * operation.

impl Mul<Vec4f> for <Vec4f as SIMDVector>::Element

type Output = Vec4f

The resulting type after applying the * operator.

fn mul(self, rhs: Vec4f) -> 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

fn neg(self) -> Self::Output

Flips sign bit of each element including non-finite ones.

type Output = Vec4f

The resulting type after applying the - operator.

impl PartialEq for Vec4f

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

Checks whether all elements of vectors are equal.

Note: when NaN is an element of one of the operands the result is always false.

Examples

let a = Vec4f::new(1.0, 2.0, 3.0, 4.0);
assert_eq!(a, a);
assert_ne!(a, Vec4f::default());

let a = Vec4f::broadcast(f32::NAN);
assert_ne!(a, a);

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

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

Takes an iterator and generates Self from the elements by multiplying the items.

impl SIMDVector for Vec4f

const ELEMENTS: usize = 4usize

Number of elements in SIMDVector.

type Underlying = __m128

Underlying intrinsic type or tuple of types implementing SIMDVector.

type Element = f32

Type of a single element of SIMDVector.

impl Sub<<Vec4f as SIMDVector>::Element> for Vec4f

type Output = Vec4f

The resulting type after applying the - operator.

fn sub(self, rhs: <Vec4f as SIMDVector>::Element) -> Self::Output

Performs the - operation.

impl Sub<Vec4f> for <Vec4f as SIMDVector>::Element

type Output = Vec4f

The resulting type after applying the - operator.

fn sub(self, rhs: Vec4f) -> 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

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for Vec4f