Struct Vec8 

#[repr(C, align(32))]
pub struct Vec8(pub [f32; 8]);

An 8-lane SIMD vector of f32 values, backed by AVX2 256-bit registers.

Tuple Fields

0: [f32; 8]

Implementations

impl Vec8

pub const ZERO: Self

pub const ONE: Self

pub const fn splat(val: f32) -> Self

Creates a vector with all lanes set to val.

pub fn mul_add(self, a: Self, b: Self) -> Self

Computes fused multiply-add: self * a + b per lane.

pub fn sum(self) -> f32

Sums all lanes, returning a scalar.

pub fn dot(self, other: Self) -> f32

Computes the dot product of two vectors, returning a scalar.

pub fn abs(self) -> Self

Returns the absolute value of each lane.

pub fn sqrt(self) -> Self

Returns the square root of each lane.

pub fn floor(self) -> Self

Returns the floor (round toward negative infinity) of each lane.

pub fn ceil(self) -> Self

Returns the ceil (round toward positive infinity) of each lane.

pub fn round(self) -> Self

Returns the nearest integer (round half away from zero) of each lane.

pub fn sin(self) -> Self

Computes the sine of each lane (radians). SLEEF u10 precision (< 1 ULP).

pub fn cos(self) -> Self

Computes the cosine of each lane (radians). SLEEF u10 precision (< 1 ULP).

pub fn exp(self) -> Self

Computes e^x for each lane. SLEEF precision.

Trait Implementations

impl Add<Vec8> for f32

Adds a scalar to each lane of the vector (f32 + Vec8).

type Output = Vec8

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<f32> for Vec8

Adds a scalar to each lane of the vector.

type Output = Vec8

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Vec8

Element-wise addition of two vectors.

type Output = Vec8

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Vec8

fn clone(&self) -> Vec8

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Vec8

Formats the vector as Vec8([a, b, c, d, e, f, g, h]) for debug output.

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

Formats the value using the given formatter.

impl Div<Vec8> for f32

Divides a scalar by each lane of the vector (f32 / Vec8).

type Output = Vec8

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for Vec8

Divides each lane of the vector by a scalar.

type Output = Vec8

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Vec8

Element-wise division of two vectors.

type Output = Vec8

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<[f32; 8]> for Vec8

Creates a Vec8 from a [f32; 8] array.

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

Converts to this type from the input type.

impl From<Vec8> for [f32; 8]

Extracts the inner [f32; 8] array from a Vec8.

fn from(v: Vec8) -> Self

Converts to this type from the input type.

impl Index<usize> for Vec8

Indexes into the vector to retrieve a single f32 lane.

type Output = f32

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl Mul<Vec8> for f32

Multiplies a scalar by each lane of the vector (f32 * Vec8).

type Output = Vec8

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Vec8

Multiplies each lane of the vector by a scalar.

type Output = Vec8

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Vec8

Element-wise multiplication of two vectors.

type Output = Vec8

The resulting type after applying the * operator.

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

Performs the * operation.

impl Neg for Vec8

Negates each lane of the vector.

type Output = Vec8

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Vec8

Compares two vectors for exact element-wise equality.

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

Tests for self and other values to be equal, and is used by ==.

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 Sub<Vec8> for f32

Subtracts each lane of the vector from a scalar (f32 - Vec8).

type Output = Vec8

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<f32> for Vec8

Subtracts a scalar from each lane of the vector.

type Output = Vec8

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Vec8

Element-wise subtraction of two vectors.

type Output = Vec8

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sum for Vec8

Sums an iterator of Vec8 values element-wise, starting from zero.

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 Vec8