Struct ultraviolet::m32x4

source ·
#[repr(C, align(16))]
pub struct m32x4 { /* private fields */ }

Implementations§

source§

impl f32x4

source

pub const ONE: f32x4 = _

source

pub const ZERO: f32x4 = _

source

pub const HALF: f32x4 = _

source

pub const E: f32x4 = _

source

pub const FRAC_1_PI: f32x4 = _

source

pub const FRAC_2_PI: f32x4 = _

source

pub const FRAC_2_SQRT_PI: f32x4 = _

source

pub const FRAC_1_SQRT_2: f32x4 = _

source

pub const FRAC_PI_2: f32x4 = _

source

pub const FRAC_PI_3: f32x4 = _

source

pub const FRAC_PI_4: f32x4 = _

source

pub const FRAC_PI_6: f32x4 = _

source

pub const FRAC_PI_8: f32x4 = _

source

pub const LN_2: f32x4 = _

source

pub const LN_10: f32x4 = _

source

pub const LOG2_E: f32x4 = _

source

pub const LOG10_E: f32x4 = _

source

pub const LOG10_2: f32x4 = _

source

pub const LOG2_10: f32x4 = _

source

pub const PI: f32x4 = _

source

pub const SQRT_2: f32x4 = _

source

pub const TAU: f32x4 = _

source§

impl f32x4

source

pub fn new(array: [f32; 4]) -> f32x4

source

pub fn blend(self, t: f32x4, f: f32x4) -> f32x4

source

pub fn abs(self) -> f32x4

source

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

Calculates the lanewise maximum of both vectors. This is a faster implementation than max, but it doesn’t specify any behavior if NaNs are involved.

source

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

Calculates the lanewise maximum of both vectors. If either lane is NaN, the other lane gets chosen. Use fast_max for a faster implementation that doesn’t handle NaNs.

source

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

Calculates the lanewise minimum of both vectors. This is a faster implementation than min, but it doesn’t specify any behavior if NaNs are involved.

source

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

Calculates the lanewise minimum of both vectors. If either lane is NaN, the other lane gets chosen. Use fast_min for a faster implementation that doesn’t handle NaNs.

source

pub fn is_nan(self) -> f32x4

source

pub fn is_finite(self) -> f32x4

source

pub fn is_inf(self) -> f32x4

source

pub fn round(self) -> f32x4

source

pub fn fast_round_int(self) -> i32x4

Rounds each lane into an integer. This is a faster implementation than round_int, but it doesn’t handle out of range values or NaNs. For those values you get implementation defined behavior.

source

pub fn round_int(self) -> i32x4

Rounds each lane into an integer. This saturates out of range values and turns NaNs into 0. Use fast_round_int for a faster implementation that doesn’t handle out of range values or NaNs.

source

pub fn fast_trunc_int(self) -> i32x4

Truncates each lane into an integer. This is a faster implementation than trunc_int, but it doesn’t handle out of range values or NaNs. For those values you get implementation defined behavior.

source

pub fn trunc_int(self) -> i32x4

Truncates each lane into an integer. This saturates out of range values and turns NaNs into 0. Use fast_trunc_int for a faster implementation that doesn’t handle out of range values or NaNs.

source

pub fn mul_add(self, m: f32x4, a: f32x4) -> f32x4

source

pub fn mul_sub(self, m: f32x4, s: f32x4) -> f32x4

source

pub fn mul_neg_add(self, m: f32x4, a: f32x4) -> f32x4

source

pub fn mul_neg_sub(self, m: f32x4, a: f32x4) -> f32x4

source

pub fn flip_signs(self, signs: f32x4) -> f32x4

source

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

source

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

source

pub fn asin(self) -> f32x4

source

pub fn acos(self) -> f32x4

source

pub fn atan(self) -> f32x4

source

pub fn atan2(self, x: f32x4) -> f32x4

source

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

source

pub fn sin(self) -> f32x4

source

pub fn cos(self) -> f32x4

source

pub fn tan(self) -> f32x4

source

pub fn to_degrees(self) -> f32x4

source

pub fn to_radians(self) -> f32x4

source

pub fn recip(self) -> f32x4

source

pub fn recip_sqrt(self) -> f32x4

source

pub fn sqrt(self) -> f32x4

source

pub fn move_mask(self) -> i32

source

pub fn any(self) -> bool

source

pub fn all(self) -> bool

source

pub fn none(self) -> bool

source

pub fn exp(self) -> f32x4

Calculate the exponent of a packed f32x4

source

pub fn sign_bit(self) -> f32x4

source

pub fn reduce_add(self) -> f32

source

pub fn ln(self) -> f32x4

Natural log (ln(x))

source

pub fn log2(self) -> f32x4

source

pub fn log10(self) -> f32x4

source

pub fn pow_f32x4(self, y: f32x4) -> f32x4

source

pub fn powf(self, y: f32) -> f32x4

source

pub fn to_array(self) -> [f32; 4]

source

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

source§

impl f32x4

source

pub fn splat(elem: f32) -> f32x4

Trait Implementations§

source§

impl Add<&f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the + operator.
source§

fn add(self, rhs: &f32x4) -> <f32x4 as Add<&f32x4>>::Output

Performs the + operation. Read more
source§

impl Add<f32> for f32x4

§

type Output = f32x4

The resulting type after applying the + operator.
source§

fn add(self, rhs: f32) -> <f32x4 as Add<f32>>::Output

Performs the + operation. Read more
source§

impl Add<f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the + operator.
source§

fn add(self, rhs: f32x4) -> <f32x4 as Add<f32x4>>::Output

Performs the + operation. Read more
source§

impl AddAssign<&f32x4> for f32x4

source§

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

Performs the += operation. Read more
source§

impl AddAssign<f32x4> for f32x4

source§

fn add_assign(&mut self, rhs: f32x4)

Performs the += operation. Read more
source§

impl Binary for f32x4

source§

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

Formats the value using the given formatter.
source§

impl BitAnd<&f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the & operator.
source§

fn bitand(self, rhs: &f32x4) -> <f32x4 as BitAnd<&f32x4>>::Output

Performs the & operation. Read more
source§

impl BitAnd<f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the & operator.
source§

fn bitand(self, rhs: f32x4) -> <f32x4 as BitAnd<f32x4>>::Output

Performs the & operation. Read more
source§

impl BitAndAssign<&f32x4> for f32x4

source§

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

Performs the &= operation. Read more
source§

impl BitAndAssign<f32x4> for f32x4

source§

fn bitand_assign(&mut self, rhs: f32x4)

Performs the &= operation. Read more
source§

impl BitOr<&f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the | operator.
source§

fn bitor(self, rhs: &f32x4) -> <f32x4 as BitOr<&f32x4>>::Output

Performs the | operation. Read more
source§

impl BitOr<f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the | operator.
source§

fn bitor(self, rhs: f32x4) -> <f32x4 as BitOr<f32x4>>::Output

Performs the | operation. Read more
source§

impl BitOrAssign<&f32x4> for f32x4

source§

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

Performs the |= operation. Read more
source§

impl BitOrAssign<f32x4> for f32x4

source§

fn bitor_assign(&mut self, rhs: f32x4)

Performs the |= operation. Read more
source§

impl BitXor<&f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the ^ operator.
source§

fn bitxor(self, rhs: &f32x4) -> <f32x4 as BitXor<&f32x4>>::Output

Performs the ^ operation. Read more
source§

impl BitXor<f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the ^ operator.
source§

fn bitxor(self, rhs: f32x4) -> <f32x4 as BitXor<f32x4>>::Output

Performs the ^ operation. Read more
source§

impl BitXorAssign<&f32x4> for f32x4

source§

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

Performs the ^= operation. Read more
source§

impl BitXorAssign<f32x4> for f32x4

source§

fn bitxor_assign(&mut self, rhs: f32x4)

Performs the ^= operation. Read more
source§

impl Clone for f32x4

source§

fn clone(&self) -> f32x4

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl CmpEq<f32> for f32x4

§

type Output = f32x4

source§

fn cmp_eq(self, rhs: f32) -> <f32x4 as CmpEq<f32>>::Output

source§

impl CmpEq<f32x4> for f32x4

§

type Output = f32x4

source§

fn cmp_eq(self, rhs: f32x4) -> <f32x4 as CmpEq<f32x4>>::Output

source§

impl CmpGe<f32> for f32x4

§

type Output = f32x4

source§

fn cmp_ge(self, rhs: f32) -> <f32x4 as CmpGe<f32>>::Output

source§

impl CmpGe<f32x4> for f32x4

§

type Output = f32x4

source§

fn cmp_ge(self, rhs: f32x4) -> <f32x4 as CmpGe<f32x4>>::Output

source§

impl CmpGt<f32> for f32x4

§

type Output = f32x4

source§

fn cmp_gt(self, rhs: f32) -> <f32x4 as CmpGt<f32>>::Output

source§

impl CmpGt<f32x4> for f32x4

§

type Output = f32x4

source§

fn cmp_gt(self, rhs: f32x4) -> <f32x4 as CmpGt<f32x4>>::Output

source§

impl CmpLe<f32> for f32x4

§

type Output = f32x4

source§

fn cmp_le(self, rhs: f32) -> <f32x4 as CmpLe<f32>>::Output

source§

impl CmpLe<f32x4> for f32x4

§

type Output = f32x4

source§

fn cmp_le(self, rhs: f32x4) -> <f32x4 as CmpLe<f32x4>>::Output

source§

impl CmpLt<f32> for f32x4

§

type Output = f32x4

source§

fn cmp_lt(self, rhs: f32) -> <f32x4 as CmpLt<f32>>::Output

source§

impl CmpLt<f32x4> for f32x4

§

type Output = f32x4

source§

fn cmp_lt(self, rhs: f32x4) -> <f32x4 as CmpLt<f32x4>>::Output

source§

impl CmpNe<f32> for f32x4

§

type Output = f32x4

source§

fn cmp_ne(self, rhs: f32) -> <f32x4 as CmpNe<f32>>::Output

source§

impl CmpNe<f32x4> for f32x4

§

type Output = f32x4

source§

fn cmp_ne(self, rhs: f32x4) -> <f32x4 as CmpNe<f32x4>>::Output

source§

impl Debug for f32x4

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for f32x4

source§

fn default() -> f32x4

Returns the “default value” for a type. Read more
source§

impl Display for f32x4

source§

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

Formats the value using the given formatter. Read more
source§

impl Div<&f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the / operator.
source§

fn div(self, rhs: &f32x4) -> <f32x4 as Div<&f32x4>>::Output

Performs the / operation. Read more
source§

impl Div<f32> for f32x4

§

type Output = f32x4

The resulting type after applying the / operator.
source§

fn div(self, rhs: f32) -> <f32x4 as Div<f32>>::Output

Performs the / operation. Read more
source§

impl Div<f32x4> for Bivec2x4

§

type Output = Bivec2x4

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl Div<f32x4> for Bivec3x4

§

type Output = Bivec3x4

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl Div<f32x4> for Rotor2x4

§

type Output = Rotor2x4

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl Div<f32x4> for Rotor3x4

§

type Output = Rotor3x4

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl Div<f32x4> for Vec2x4

§

type Output = Vec2x4

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl Div<f32x4> for Vec3x4

§

type Output = Vec3x4

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl Div<f32x4> for Vec4x4

§

type Output = Vec4x4

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl Div<f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the / operator.
source§

fn div(self, rhs: f32x4) -> <f32x4 as Div<f32x4>>::Output

Performs the / operation. Read more
source§

impl DivAssign<&f32x4> for f32x4

source§

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

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for Bivec2x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for Bivec3x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for Rotor2x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for Rotor3x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for Vec2x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for Vec3x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for Vec4x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl DivAssign<f32x4> for f32x4

source§

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more
source§

impl From<&[f32]> for f32x4

source§

fn from(src: &[f32]) -> f32x4

Converts to this type from the input type.
source§

impl From<[f32; 4]> for f32x4

source§

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

Converts to this type from the input type.
source§

impl From<f32> for f32x4

source§

fn from(elem: f32) -> f32x4

Splats the single value given across all lanes.

source§

impl Lerp<f32x4> for Bivec2x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl Lerp<f32x4> for Bivec3x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl Lerp<f32x4> for Rotor2x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl Lerp<f32x4> for Rotor3x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl Lerp<f32x4> for Vec2x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl Lerp<f32x4> for Vec3x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl Lerp<f32x4> for Vec4x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl Lerp<f32x4> for f32x4

source§

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

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating Rotors with linear interpolation, you almost certainly want to normalize the returned Rotor. For example,

let interpolated_rotor = rotor1.lerp(rotor2, 0.5).normalized();

For most cases (especially where performance is the primary concern, like in animation interpolation for games, this ‘normalized lerp’ or ‘nlerp’ is probably what you want to use. However, there are situations in which you really want the interpolation between two Rotors to be of constant angular velocity. In this case, check out Slerp.

source§

impl LowerExp for f32x4

source§

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

Formats the value using the given formatter.
source§

impl LowerHex for f32x4

source§

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

Formats the value using the given formatter.
source§

impl Mul<&f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the * operator.
source§

fn mul(self, rhs: &f32x4) -> <f32x4 as Mul<&f32x4>>::Output

Performs the * operation. Read more
source§

impl Mul<Bivec2x4> for f32x4

§

type Output = Bivec2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Bivec3x4> for f32x4

§

type Output = Bivec3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Mat2x4> for f32x4

§

type Output = Mat2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Mat3x4> for f32x4

§

type Output = Mat3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Mat4x4> for f32x4

§

type Output = Mat4x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Rotor2x4> for f32x4

§

type Output = Rotor2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Rotor3x4> for f32x4

§

type Output = Rotor3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Vec2x4> for f32x4

§

type Output = Vec2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Vec3x4> for f32x4

§

type Output = Vec3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<Vec4x4> for f32x4

§

type Output = Vec4x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32> for f32x4

§

type Output = f32x4

The resulting type after applying the * operator.
source§

fn mul(self, rhs: f32) -> <f32x4 as Mul<f32>>::Output

Performs the * operation. Read more
source§

impl Mul<f32x4> for Bivec2x4

§

type Output = Bivec2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Bivec3x4

§

type Output = Bivec3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Isometry2x4

§

type Output = Isometry2x4

The resulting type after applying the * operator.
source§

fn mul(self, scalar: f32x4) -> Isometry2x4

Performs the * operation. Read more
source§

impl Mul<f32x4> for Isometry3x4

§

type Output = Isometry3x4

The resulting type after applying the * operator.
source§

fn mul(self, scalar: f32x4) -> Isometry3x4

Performs the * operation. Read more
source§

impl Mul<f32x4> for Mat2x4

§

type Output = Mat2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Mat3x4

§

type Output = Mat3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Mat4x4

§

type Output = Mat4x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Rotor2x4

§

type Output = Rotor2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Rotor3x4

§

type Output = Rotor3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Similarity2x4

§

type Output = Similarity2x4

The resulting type after applying the * operator.
source§

fn mul(self, scalar: f32x4) -> Similarity2x4

Performs the * operation. Read more
source§

impl Mul<f32x4> for Similarity3x4

§

type Output = Similarity3x4

The resulting type after applying the * operator.
source§

fn mul(self, scalar: f32x4) -> Similarity3x4

Performs the * operation. Read more
source§

impl Mul<f32x4> for Vec2x4

§

type Output = Vec2x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Vec3x4

§

type Output = Vec3x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for Vec4x4

§

type Output = Vec4x4

The resulting type after applying the * operator.
source§

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

Performs the * operation. Read more
source§

impl Mul<f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the * operator.
source§

fn mul(self, rhs: f32x4) -> <f32x4 as Mul<f32x4>>::Output

Performs the * operation. Read more
source§

impl MulAssign<&f32x4> for f32x4

source§

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

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for Bivec2x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for Bivec3x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for Rotor2x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for Rotor3x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for Vec2x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for Vec3x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for Vec4x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl MulAssign<f32x4> for f32x4

source§

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more
source§

impl Neg for &f32x4

§

type Output = f32x4

The resulting type after applying the - operator.
source§

fn neg(self) -> <&f32x4 as Neg>::Output

Performs the unary - operation. Read more
source§

impl Neg for f32x4

§

type Output = f32x4

The resulting type after applying the - operator.
source§

fn neg(self) -> <f32x4 as Neg>::Output

Performs the unary - operation. Read more
source§

impl Not for &f32x4

§

type Output = f32x4

The resulting type after applying the ! operator.
source§

fn not(self) -> <&f32x4 as Not>::Output

Performs the unary ! operation. Read more
source§

impl Not for f32x4

§

type Output = f32x4

The resulting type after applying the ! operator.
source§

fn not(self) -> <f32x4 as Not>::Output

Performs the unary ! operation. Read more
source§

impl Octal for f32x4

source§

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

Formats the value using the given formatter.
source§

impl PartialEq<f32x4> for f32x4

source§

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

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

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.
source§

impl<RHS> Product<RHS> for f32x4where f32x4: MulAssign<RHS>,

source§

fn product<I>(iter: I) -> f32x4where I: Iterator<Item = RHS>,

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

impl Slerp<f32x4> for Bivec2x4

source§

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

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for Rotors, and it can also be used to interpolate other things, one example being interpolation of 3d normal vectors.

Note that you should often normalize the result returned by this operation, when working with Rotors, etc!

source§

impl Slerp<f32x4> for Bivec3x4

source§

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

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for Rotors, and it can also be used to interpolate other things, one example being interpolation of 3d normal vectors.

Note that you should often normalize the result returned by this operation, when working with Rotors, etc!

source§

impl Slerp<f32x4> for Rotor2x4

source§

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

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for Rotors, and it can also be used to interpolate other things, one example being interpolation of 3d normal vectors.

Note that you should often normalize the result returned by this operation, when working with Rotors, etc!

source§

impl Slerp<f32x4> for Rotor3x4

source§

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

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for Rotors, and it can also be used to interpolate other things, one example being interpolation of 3d normal vectors.

Note that you should often normalize the result returned by this operation, when working with Rotors, etc!

source§

impl Slerp<f32x4> for Vec2x4

source§

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

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for Rotors, and it can also be used to interpolate other things, one example being interpolation of 3d normal vectors.

Note that you should often normalize the result returned by this operation, when working with Rotors, etc!

source§

impl Slerp<f32x4> for Vec3x4

source§

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

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for Rotors, and it can also be used to interpolate other things, one example being interpolation of 3d normal vectors.

Note that you should often normalize the result returned by this operation, when working with Rotors, etc!

source§

impl Slerp<f32x4> for Vec4x4

source§

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

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for Rotors, and it can also be used to interpolate other things, one example being interpolation of 3d normal vectors.

Note that you should often normalize the result returned by this operation, when working with Rotors, etc!

source§

impl Sub<&f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the - operator.
source§

fn sub(self, rhs: &f32x4) -> <f32x4 as Sub<&f32x4>>::Output

Performs the - operation. Read more
source§

impl Sub<f32> for f32x4

§

type Output = f32x4

The resulting type after applying the - operator.
source§

fn sub(self, rhs: f32) -> <f32x4 as Sub<f32>>::Output

Performs the - operation. Read more
source§

impl Sub<f32x4> for f32x4

§

type Output = f32x4

The resulting type after applying the - operator.
source§

fn sub(self, rhs: f32x4) -> <f32x4 as Sub<f32x4>>::Output

Performs the - operation. Read more
source§

impl SubAssign<&f32x4> for f32x4

source§

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

Performs the -= operation. Read more
source§

impl SubAssign<f32x4> for f32x4

source§

fn sub_assign(&mut self, rhs: f32x4)

Performs the -= operation. Read more
source§

impl<RHS> Sum<RHS> for f32x4where f32x4: AddAssign<RHS>,

source§

fn sum<I>(iter: I) -> f32x4where I: Iterator<Item = RHS>,

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

impl UpperExp for f32x4

source§

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

Formats the value using the given formatter.
source§

impl UpperHex for f32x4

source§

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

Formats the value using the given formatter.
source§

impl Zeroable for f32x4

source§

fn zeroed() -> Self

source§

impl Copy for f32x4

source§

impl Pod for f32x4

source§

impl StructuralPartialEq for f32x4

Auto Trait Implementations§

§

impl RefUnwindSafe for f32x4

§

impl Send for f32x4

§

impl Sync for f32x4

§

impl Unpin for f32x4

§

impl UnwindSafe for f32x4

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CheckedBitPattern for Twhere T: AnyBitPattern,

§

type Bits = T

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.
source§

fn is_valid_bit_pattern(_bits: &T) -> bool

If this function returns true, then it must be valid to reinterpret bits as &Self.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> AnyBitPattern for Twhere T: Pod,

source§

impl<T> NoUninit for Twhere T: Pod,