Struct ultraviolet::f32x4

#[repr(C)]
pub struct f32x4 { /* fields omitted */ }

Four f32 values packed together.

Methods

impl f32x4

Wide Methods

pub fn andnot(self, rhs: f32x4) -> f32x4

Bitwise (!self) & rhs

pub fn is_nan(self) -> f32x4

Lanewise "is the value a NaN value?"

pub fn is_ordinary(self) -> f32x4

Lanewise "is the value a non-NaN value?"

pub fn merge(self, a: f32x4, b: f32x4) -> f32x4

Use self (a boolish value) to merge a and b.

For each lane index, if the self lane is "true" then the a value will be used in the output, otherwise the b value will be used in the output.

If sse4.1 is enabled, then "true" only checks the sign bit. With less features enabled the entire bit pattern of the lane will matter. This is not normally a problem, because the comparison methods naturally return all 1s or all 0s anyway.

pub fn move_mask(self) -> i32

use wide::f32x4;
let a = f32x4::new(1.0, 2.0, 3.0, 4.0);
let b = f32x4::from(2.5);
assert_eq!(a.cmp_lt(b).move_mask(), 0b0011);

pub fn cmp_eq(self, rhs: f32x4) -> f32x4

Lanewise ==

pub fn cmp_ge(self, rhs: f32x4) -> f32x4

Lanewise >=

pub fn cmp_gt(self, rhs: f32x4) -> f32x4

Lanewise >

pub fn cmp_le(self, rhs: f32x4) -> f32x4

Lanewise <=

pub fn cmp_lt(self, rhs: f32x4) -> f32x4

Lanewise <

pub fn cmp_nan(self, rhs: f32x4) -> f32x4

Lanewise "self.is_nan() | other.is_nan()"

pub fn cmp_ne(self, rhs: f32x4) -> f32x4

Lanewise !=

pub fn cmp_nge(self, rhs: f32x4) -> f32x4

Lanewise !(a >= b)

If you call this method it triggers Third Impact

pub fn cmp_ngt(self, rhs: f32x4) -> f32x4

Lanewise !(a > b)

pub fn cmp_nle(self, rhs: f32x4) -> f32x4

Lanewise !(a <= b)

pub fn cmp_nlt(self, rhs: f32x4) -> f32x4

Lanewise !(a < b)

pub fn ceil(self) -> f32x4

Lanewise ceiling (next larger whole number)

pub fn floor(self) -> f32x4

Lanewise floor (next smaller whole number)

pub fn abs(self) -> f32x4

Lanewise absolute value

pub fn cos(self) -> f32x4

Lanewise cosine

pub fn round(self) -> f32x4

Lanewise round to nearest whole number.

pub fn sin(self) -> f32x4

Lanewise sine.

"We called it 'Sin'."

pub fn mul_add(self, b: f32x4, c: f32x4) -> f32x4

Performs a "fused multiply-add", (self * b) + c

This is only different from a normal mul and then add if the fma target_feature is enabled during the build. This is not on by default, you must enable it yourself. To be clear, this is not a cargo feature, this is a CPU feature. Read the guide for info on how to enable CPU features if you haven't done that before.

pub fn negated_mul_add(self, b: f32x4, c: f32x4) -> f32x4

Negated "mul_add", c - (self * b).

Fused if fma feature is enabled, see (mul_add)f32x4::mul_add.

pub fn recip(self) -> f32x4

Lanewise reciprocal, 1.0/lane

pub fn max(self, b: f32x4) -> f32x4

Lanewise maximum

pub fn min(self, b: f32x4) -> f32x4

Lanewise minimum

pub fn round_i32(self) -> i32x4

Lanewise round and get i32x4 output

pub fn is_finite(self) -> f32x4

If it's some finite value.

• True for normal, denormal, and zero.
• False for +/- INF, NaN
• boolish

pub fn cast_i32x4(self) -> i32x4

Cast directly to i32x4 (no change in bit pattern).

pub fn copysign(self, b: f32x4) -> f32x4

Copy the sign of b onto the value of self.

pub fn clamp(self, min: f32x4, max: f32x4) -> f32x4

Lanewise clamp to a per-lane min and max.

pub fn signum(self) -> f32x4

Lanewise sign-number (-1.0 if < 0.0, otherwise 1.0)

pub fn tan(self) -> f32x4

Lanewise tangent

pub fn sin_cos(self) -> (f32x4, f32x4)

Sine and Cosine as a single operation.

pub fn to_degrees(self) -> f32x4

Lanewise radians -> degrees.

pub fn to_radians(self) -> f32x4

Lanewise degrees -> radians.

pub fn fract(self) -> f32x4

Lanewise fractional part.

pub fn sqrt(self) -> f32x4

Lanewise sqrt

impl f32x4

pub const EPSILON: f32x4

Machine epsilon value for f32.

pub const INFINITY: f32x4

Positive Infinity (∞).

pub const MAX: f32x4

Largest finite f32 value.

pub const MIN: f32x4

Smallest finite f32 value.

pub const MIN_POSITIVE: f32x4

Smallest positive normal f32 value.

pub const NAN: f32x4

Not a Number (NaN).

Reminder: This is one possible NaN value, but there are many NaN bit patterns within the f32 space.

pub const NEG_INFINITY: f32x4

Negative infinity (-∞).

pub const E: f32x4

Euler's number (e)

pub const FRAC_1_PI: f32x4

1/π

pub const FRAC_2_PI: f32x4

2/π

pub const FRAC_2_SQRT_PI: f32x4

2/sqrt(π)

pub const FRAC_1_SQRT_2: f32x4

1/sqrt(2)

pub const FRAC_PI_2: f32x4

π/2

pub const FRAC_PI_3: f32x4

π/3

pub const FRAC_PI_4: f32x4

π/4

pub const FRAC_PI_6: f32x4

π/6

pub const FRAC_PI_8: f32x4

π/8

pub const LN_2: f32x4

ln(2)

pub const LN_10: f32x4

ln(10)

pub const LOG2_E: f32x4

log2(e)

pub const LOG10_E: f32x4

log10(e)

pub const PI: f32x4

Archimedes' constant (π)

pub const SQRT_2: f32x4

sqrt(2)

pub const ALL_BITS_ACTIVE: f32x4

All bits active.

pub const ALL_EXCEPT_SIGN: f32x4

All bits active.

pub const ZERO: f32x4

0.0

pub const NEGATIVE_ZERO: f32x4

-0.0

pub const HALF: f32x4

0.5

pub const ONE: f32x4

1.0

pub const NEGATIVE_ONE: f32x4

1.0

pub const TWO_PI: f32x4

2.0 * π, the number of radians in a circle.

impl f32x4

pub fn new(a: f32, b: f32, c: f32, d: f32) -> f32x4

Makes a new f32x4.

impl f32x4

pub fn trunc(self) -> f32x4

Truncate the fractional part.

pub fn classify(self) -> [FpCategory; 4]

As f32::classify

Trait Implementations

impl LowerHex for f32x4

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

Formats the value using the given formatter.

impl RemAssign<f32x4> for f32x4

fn rem_assign(&mut self, rhs: f32x4)

Performs the %= operation.

impl<'_> RemAssign<&'_ f32x4> for f32x4

fn rem_assign(&mut self, rhs: &f32x4)

Performs the %= operation.

impl Product<f32x4> for f32x4

fn product<I>(iter: I) -> f32x4 where
    I: Iterator<Item = f32x4>, 

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

impl<'a> Product<&'a f32x4> for f32x4

fn product<I>(iter: I) -> f32x4 where
    I: Iterator<Item = &'a f32x4>, 

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

impl<'_> SubAssign<&'_ f32x4> for f32x4

fn sub_assign(&mut self, rhs: &f32x4)

Performs the -= operation.

impl SubAssign<f32x4> for f32x4

fn sub_assign(&mut self, rhs: f32x4)

Performs the -= operation.

impl Copy for f32x4

impl Clone for f32x4

fn clone(&self) -> f32x4

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Pod for f32x4

impl Div<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> f32x4

Performs the / operation.

impl<'_> Div<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the / operator.

fn div(self, rhs: &f32x4) -> f32x4

Performs the / operation.

impl IndexMut<usize> for f32x4

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

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

impl<'_> BitAnd<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the & operator.

fn bitand(self, rhs: &f32x4) -> f32x4

Performs the & operation.

impl BitAnd<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the & operator.

fn bitand(self, rhs: f32x4) -> f32x4

Performs the & operation.

impl<'_> Add<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the + operator.

fn add(self, rhs: &f32x4) -> f32x4

Performs the + operation.

impl Add<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the + operator.

fn add(self, rhs: f32x4) -> f32x4

Performs the + operation.

impl AsMut<[f32; 4]> for f32x4

fn as_mut(&mut self) -> &mut [f32; 4]

Performs the conversion.

impl Neg for f32x4

type Output = f32x4

The resulting type after applying the - operator.

fn neg(self) -> f32x4

Performs the unary - operation.

impl<'_> Neg for &'_ f32x4

type Output = f32x4

The resulting type after applying the - operator.

fn neg(self) -> f32x4

Performs the unary - operation.

impl<'_> BitOrAssign<&'_ f32x4> for f32x4

fn bitor_assign(&mut self, rhs: &f32x4)

Performs the |= operation.

impl BitOrAssign<f32x4> for f32x4

fn bitor_assign(&mut self, rhs: f32x4)

Performs the |= operation.

impl Debug for f32x4

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

Formats the value using the given formatter.

impl<'_> Mul<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the * operator.

fn mul(self, rhs: &f32x4) -> f32x4

Performs the * operation.

impl Mul<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> f32x4

Performs the * operation.

impl AsRef<[f32; 4]> for f32x4

fn as_ref(&self) -> &[f32; 4]

Performs the conversion.

impl LowerExp for f32x4

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

Formats the value using the given formatter.

impl BitXor<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: f32x4) -> f32x4

Performs the ^ operation.

impl<'_> BitXor<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &f32x4) -> f32x4

Performs the ^ operation.

impl Sub<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the - operator.

fn sub(self, rhs: f32x4) -> f32x4

Performs the - operation.

impl<'_> Sub<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the - operator.

fn sub(self, rhs: &f32x4) -> f32x4

Performs the - operation.

impl Display for f32x4

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

Formats the value using the given formatter.

impl<'_> MulAssign<&'_ f32x4> for f32x4

fn mul_assign(&mut self, rhs: &f32x4)

Performs the *= operation.

impl MulAssign<f32x4> for f32x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl Zeroable for f32x4

fn zeroed() -> Self

Calls zeroed.

impl Binary for f32x4

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

Formats the value using the given formatter.

impl Not for f32x4

type Output = f32x4

The resulting type after applying the ! operator.

fn not(self) -> f32x4

Bitwise negation

impl BitXorAssign<f32x4> for f32x4

fn bitxor_assign(&mut self, rhs: f32x4)

Performs the ^= operation.

impl<'_> BitXorAssign<&'_ f32x4> for f32x4

fn bitxor_assign(&mut self, rhs: &f32x4)

Performs the ^= operation.

impl Sum<f32x4> for f32x4

fn sum<I>(iter: I) -> f32x4 where
    I: Iterator<Item = f32x4>, 

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

impl<'a> Sum<&'a f32x4> for f32x4

fn sum<I>(iter: I) -> f32x4 where
    I: Iterator<Item = &'a f32x4>, 

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

impl Default for f32x4

fn default() -> f32x4

Returns the "default value" for a type.

impl AddAssign<f32x4> for f32x4

fn add_assign(&mut self, rhs: f32x4)

Performs the += operation.

impl<'_> AddAssign<&'_ f32x4> for f32x4

fn add_assign(&mut self, rhs: &f32x4)

Performs the += operation.

impl From<[u16; 4]> for f32x4

fn from([u16; 4]) -> f32x4

Performs the conversion.

impl From<(f32, f32, f32, f32)> for f32x4

fn from((f32, f32, f32, f32)) -> f32x4

Performs the conversion.

impl From<[u8; 4]> for f32x4

fn from([u8; 4]) -> f32x4

Performs the conversion.

impl From<f32> for f32x4

fn from(val: f32) -> f32x4

Performs the conversion.

impl From<[f32; 4]> for f32x4

fn from(arr: [f32; 4]) -> f32x4

Performs the conversion.

impl From<[i16; 4]> for f32x4

fn from([i16; 4]) -> f32x4

Performs the conversion.

impl From<[i8; 4]> for f32x4

fn from([i8; 4]) -> f32x4

Performs the conversion.

impl BitAndAssign<f32x4> for f32x4

fn bitand_assign(&mut self, rhs: f32x4)

Performs the &= operation.

impl<'_> BitAndAssign<&'_ f32x4> for f32x4

fn bitand_assign(&mut self, rhs: &f32x4)

Performs the &= operation.

impl<'_> Rem<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the % operator.

fn rem(self, rhs: &f32x4) -> f32x4

Performs the % operation.

impl Rem<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the % operator.

fn rem(self, rhs: f32x4) -> f32x4

Performs the % operation.

impl Index<usize> for f32x4

type Output = f32

The returned type after indexing.

fn index(&self, index: usize) -> &f32

Performs the indexing (container[index]) operation.

impl UpperExp for f32x4

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

Formats the value using the given formatter.

impl BitOr<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the | operator.

fn bitor(self, rhs: f32x4) -> f32x4

Performs the | operation.

impl<'_> BitOr<&'_ f32x4> for f32x4

type Output = f32x4

The resulting type after applying the | operator.

fn bitor(self, rhs: &f32x4) -> f32x4

Performs the | operation.

impl DivAssign<f32x4> for f32x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation.

impl<'_> DivAssign<&'_ f32x4> for f32x4

fn div_assign(&mut self, rhs: &f32x4)

Performs the /= operation.

impl Octal for f32x4

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

Formats the value using the given formatter.

impl UpperHex for f32x4

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

Formats the value using the given formatter.

impl Lerp<f32x4> for Wec2

fn lerp(&self, end: Self, t: f32x4) -> Self

impl Lerp<f32x4> for Wec3

fn lerp(&self, end: Self, t: f32x4) -> Self

impl Lerp<f32x4> for Wec4

fn lerp(&self, end: Self, t: f32x4) -> Self

impl Lerp<f32x4> for WBivec2

fn lerp(&self, end: Self, t: f32x4) -> Self

impl Lerp<f32x4> for WBivec3

fn lerp(&self, end: Self, t: f32x4) -> Self

impl Lerp<f32x4> for WRotor2

fn lerp(&self, end: Self, t: f32x4) -> Self

impl Lerp<f32x4> for WRotor3

fn lerp(&self, end: Self, t: f32x4) -> Self

impl Div<f32x4> for WBivec2

type Output = WBivec2

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> WBivec2

Performs the / operation.

impl Div<f32x4> for WBivec3

type Output = WBivec3

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> WBivec3

Performs the / operation.

impl Div<f32x4> for Wec2

type Output = Wec2

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Wec2

Performs the / operation.

impl Div<f32x4> for Wec3

type Output = Wec3

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Wec3

Performs the / operation.

impl Div<f32x4> for Wec4

type Output = Wec4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Wec4

Performs the / operation.

impl Mul<WBivec2> for f32x4

type Output = WBivec2

The resulting type after applying the * operator.

fn mul(self, rhs: WBivec2) -> WBivec2

Performs the * operation.

impl Mul<f32x4> for WBivec2

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<WBivec3> for f32x4

type Output = WBivec3

The resulting type after applying the * operator.

fn mul(self, rhs: WBivec3) -> WBivec3

Performs the * operation.

impl Mul<f32x4> for WBivec3

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32x4> for Wat4

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32x4> for WRotor2

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<WRotor2> for f32x4

type Output = WRotor2

The resulting type after applying the * operator.

fn mul(self, rotor: WRotor2) -> WRotor2

Performs the * operation.

impl Mul<f32x4> for WRotor3

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<WRotor3> for f32x4

type Output = WRotor3

The resulting type after applying the * operator.

fn mul(self, rotor: WRotor3) -> WRotor3

Performs the * operation.

impl Mul<Wec2> for f32x4

type Output = Wec2

The resulting type after applying the * operator.

fn mul(self, rhs: Wec2) -> Wec2

Performs the * operation.

impl Mul<f32x4> for Wec2

type Output = Wec2

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Wec2

Performs the * operation.

impl Mul<Wec3> for f32x4

type Output = Wec3

The resulting type after applying the * operator.

fn mul(self, rhs: Wec3) -> Wec3

Performs the * operation.

impl Mul<f32x4> for Wec3

type Output = Wec3

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Wec3

Performs the * operation.

impl Mul<Wec4> for f32x4

type Output = Wec4

The resulting type after applying the * operator.

fn mul(self, rhs: Wec4) -> Wec4

Performs the * operation.

impl Mul<f32x4> for Wec4

type Output = Wec4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Wec4

Performs the * operation.

impl MulAssign<f32x4> for WBivec2

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl MulAssign<f32x4> for WBivec3

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl MulAssign<f32x4> for WRotor2

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl MulAssign<f32x4> for WRotor3

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl MulAssign<f32x4> for Wec2

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl MulAssign<f32x4> for Wec3

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl MulAssign<f32x4> for Wec4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation.

impl DivAssign<f32x4> for WBivec2

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation.

impl DivAssign<f32x4> for WBivec3

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation.

impl DivAssign<f32x4> for Wec2

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation.

impl DivAssign<f32x4> for Wec3

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation.

impl DivAssign<f32x4> for Wec4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation.