Struct ultraviolet::m32x4 [−][src]
Implementations
impl f32x4
[src]
pub const ONE: f32x4
[src]
pub const ZERO: f32x4
[src]
pub const HALF: f32x4
[src]
pub const E: f32x4
[src]
pub const FRAC_1_PI: f32x4
[src]
pub const FRAC_2_PI: f32x4
[src]
pub const FRAC_2_SQRT_PI: f32x4
[src]
pub const FRAC_1_SQRT_2: f32x4
[src]
pub const FRAC_PI_2: f32x4
[src]
pub const FRAC_PI_3: f32x4
[src]
pub const FRAC_PI_4: f32x4
[src]
pub const FRAC_PI_6: f32x4
[src]
pub const FRAC_PI_8: f32x4
[src]
pub const LN_2: f32x4
[src]
pub const LN_10: f32x4
[src]
pub const LOG2_E: f32x4
[src]
pub const LOG10_E: f32x4
[src]
pub const LOG10_2: f32x4
[src]
pub const LOG2_10: f32x4
[src]
pub const PI: f32x4
[src]
pub const SQRT_2: f32x4
[src]
pub const TAU: f32x4
[src]
impl f32x4
[src]
#[must_use]pub fn blend(self, t: f32x4, f: f32x4) -> f32x4
[src]
#[must_use]pub fn abs(self) -> f32x4
[src]
#[must_use]pub fn max(self, rhs: f32x4) -> f32x4
[src]
#[must_use]pub fn min(self, rhs: f32x4) -> f32x4
[src]
#[must_use]pub fn is_nan(self) -> f32x4
[src]
#[must_use]pub fn is_finite(self) -> f32x4
[src]
#[must_use]pub fn is_inf(self) -> f32x4
[src]
#[must_use]pub fn round(self) -> f32x4
[src]
#[must_use]pub fn round_int(self) -> i32x4
[src]
#[must_use]pub fn trunc_int(self) -> i32x4
[src]
#[must_use]pub fn mul_add(self, m: f32x4, a: f32x4) -> f32x4
[src]
#[must_use]pub fn mul_sub(self, m: f32x4, s: f32x4) -> f32x4
[src]
#[must_use]pub fn mul_neg_add(self, m: f32x4, a: f32x4) -> f32x4
[src]
#[must_use]pub fn mul_neg_sub(self, m: f32x4, a: f32x4) -> f32x4
[src]
#[must_use]pub fn flip_signs(self, signs: f32x4) -> f32x4
[src]
#[must_use]pub fn copysign(self, sign: f32x4) -> f32x4
[src]
pub fn asin_acos(self) -> (f32x4, f32x4)
[src]
pub fn asin(self) -> f32x4
[src]
#[must_use]pub fn acos(self) -> f32x4
[src]
pub fn atan(self) -> f32x4
[src]
pub fn atan2(self, x: f32x4) -> f32x4
[src]
#[must_use]pub fn sin_cos(self) -> (f32x4, f32x4)
[src]
#[must_use]pub fn sin(self) -> f32x4
[src]
#[must_use]pub fn cos(self) -> f32x4
[src]
#[must_use]pub fn tan(self) -> f32x4
[src]
#[must_use]pub fn to_degrees(self) -> f32x4
[src]
#[must_use]pub fn to_radians(self) -> f32x4
[src]
#[must_use]pub fn recip(self) -> f32x4
[src]
#[must_use]pub fn recip_sqrt(self) -> f32x4
[src]
#[must_use]pub fn sqrt(self) -> f32x4
[src]
#[must_use]pub fn move_mask(self) -> i32
[src]
#[must_use]pub fn any(self) -> bool
[src]
#[must_use]pub fn all(self) -> bool
[src]
#[must_use]pub fn none(self) -> bool
[src]
#[must_use]pub fn exp(self) -> f32x4
[src]
Calculate the exponent of a packed f32x4
pub fn sign_bit(self) -> f32x4
[src]
pub fn reduce_add(self) -> f32
[src]
#[must_use]pub fn ln(self) -> f32x4
[src]
Natural log (ln(x))
#[must_use]pub fn log2(self) -> f32x4
[src]
#[must_use]pub fn log10(self) -> f32x4
[src]
#[must_use]pub fn pow_f32x4(self, y: f32x4) -> f32x4
[src]
pub fn powf(self, y: f32) -> f32x4
[src]
impl f32x4
[src]
Trait Implementations
impl<'_> Add<&'_ f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the +
operator.
#[must_use]pub fn add(self, rhs: &f32x4) -> <f32x4 as Add<&'_ f32x4>>::Output
[src]
impl Add<f32> for f32x4
[src]
type Output = f32x4
The resulting type after applying the +
operator.
#[must_use]pub fn add(self, rhs: f32) -> <f32x4 as Add<f32>>::Output
[src]
impl Add<f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the +
operator.
#[must_use]pub fn add(self, rhs: f32x4) -> <f32x4 as Add<f32x4>>::Output
[src]
impl<'_> AddAssign<&'_ f32x4> for f32x4
[src]
pub fn add_assign(&mut self, rhs: &f32x4)
[src]
impl AddAssign<f32x4> for f32x4
[src]
pub fn add_assign(&mut self, rhs: f32x4)
[src]
impl Binary for f32x4
[src]
impl<'_> BitAnd<&'_ f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the &
operator.
#[must_use]pub fn bitand(self, rhs: &f32x4) -> <f32x4 as BitAnd<&'_ f32x4>>::Output
[src]
impl BitAnd<f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the &
operator.
#[must_use]pub fn bitand(self, rhs: f32x4) -> <f32x4 as BitAnd<f32x4>>::Output
[src]
impl<'_> BitAndAssign<&'_ f32x4> for f32x4
[src]
pub fn bitand_assign(&mut self, rhs: &f32x4)
[src]
impl BitAndAssign<f32x4> for f32x4
[src]
pub fn bitand_assign(&mut self, rhs: f32x4)
[src]
impl<'_> BitOr<&'_ f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the |
operator.
#[must_use]pub fn bitor(self, rhs: &f32x4) -> <f32x4 as BitOr<&'_ f32x4>>::Output
[src]
impl BitOr<f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the |
operator.
#[must_use]pub fn bitor(self, rhs: f32x4) -> <f32x4 as BitOr<f32x4>>::Output
[src]
impl<'_> BitOrAssign<&'_ f32x4> for f32x4
[src]
pub fn bitor_assign(&mut self, rhs: &f32x4)
[src]
impl BitOrAssign<f32x4> for f32x4
[src]
pub fn bitor_assign(&mut self, rhs: f32x4)
[src]
impl<'_> BitXor<&'_ f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the ^
operator.
#[must_use]pub fn bitxor(self, rhs: &f32x4) -> <f32x4 as BitXor<&'_ f32x4>>::Output
[src]
impl BitXor<f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the ^
operator.
#[must_use]pub fn bitxor(self, rhs: f32x4) -> <f32x4 as BitXor<f32x4>>::Output
[src]
impl<'_> BitXorAssign<&'_ f32x4> for f32x4
[src]
pub fn bitxor_assign(&mut self, rhs: &f32x4)
[src]
impl BitXorAssign<f32x4> for f32x4
[src]
pub fn bitxor_assign(&mut self, rhs: f32x4)
[src]
impl Clone for f32x4
[src]
impl CmpEq<f32> for f32x4
[src]
impl CmpEq<f32x4> for f32x4
[src]
type Output = f32x4
#[must_use]pub fn cmp_eq(self, rhs: f32x4) -> <f32x4 as CmpEq<f32x4>>::Output
[src]
impl CmpGe<f32> for f32x4
[src]
impl CmpGe<f32x4> for f32x4
[src]
type Output = f32x4
#[must_use]pub fn cmp_ge(self, rhs: f32x4) -> <f32x4 as CmpGe<f32x4>>::Output
[src]
impl CmpGt<f32> for f32x4
[src]
impl CmpGt<f32x4> for f32x4
[src]
type Output = f32x4
#[must_use]pub fn cmp_gt(self, rhs: f32x4) -> <f32x4 as CmpGt<f32x4>>::Output
[src]
impl CmpLe<f32> for f32x4
[src]
impl CmpLe<f32x4> for f32x4
[src]
type Output = f32x4
#[must_use]pub fn cmp_le(self, rhs: f32x4) -> <f32x4 as CmpLe<f32x4>>::Output
[src]
impl CmpLt<f32> for f32x4
[src]
impl CmpLt<f32x4> for f32x4
[src]
type Output = f32x4
#[must_use]pub fn cmp_lt(self, rhs: f32x4) -> <f32x4 as CmpLt<f32x4>>::Output
[src]
impl CmpNe<f32> for f32x4
[src]
impl CmpNe<f32x4> for f32x4
[src]
type Output = f32x4
#[must_use]pub fn cmp_ne(self, rhs: f32x4) -> <f32x4 as CmpNe<f32x4>>::Output
[src]
impl Copy for f32x4
[src]
impl Debug for f32x4
[src]
impl Default for f32x4
[src]
impl Display for f32x4
[src]
impl<'_> Div<&'_ f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the /
operator.
#[must_use]pub fn div(self, rhs: &f32x4) -> <f32x4 as Div<&'_ f32x4>>::Output
[src]
impl Div<f32> for f32x4
[src]
type Output = f32x4
The resulting type after applying the /
operator.
#[must_use]pub fn div(self, rhs: f32) -> <f32x4 as Div<f32>>::Output
[src]
impl Div<f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the /
operator.
#[must_use]pub fn div(self, rhs: f32x4) -> <f32x4 as Div<f32x4>>::Output
[src]
impl Div<f32x4> for Bivec2x4
[src]
type Output = Bivec2x4
The resulting type after applying the /
operator.
fn div(self, rhs: f32x4) -> Bivec2x4
[src]
impl Div<f32x4> for Bivec3x4
[src]
type Output = Bivec3x4
The resulting type after applying the /
operator.
fn div(self, rhs: f32x4) -> Bivec3x4
[src]
impl Div<f32x4> for Rotor2x4
[src]
type Output = Self
The resulting type after applying the /
operator.
fn div(self, rhs: f32x4) -> Self
[src]
impl Div<f32x4> for Rotor3x4
[src]
type Output = Self
The resulting type after applying the /
operator.
fn div(self, rhs: f32x4) -> Self
[src]
impl Div<f32x4> for Vec2x4
[src]
type Output = Vec2x4
The resulting type after applying the /
operator.
fn div(self, rhs: f32x4) -> Vec2x4
[src]
impl Div<f32x4> for Vec3x4
[src]
type Output = Vec3x4
The resulting type after applying the /
operator.
fn div(self, rhs: f32x4) -> Vec3x4
[src]
impl Div<f32x4> for Vec4x4
[src]
type Output = Vec4x4
The resulting type after applying the /
operator.
fn div(self, rhs: f32x4) -> Vec4x4
[src]
impl<'_> DivAssign<&'_ f32x4> for f32x4
[src]
pub fn div_assign(&mut self, rhs: &f32x4)
[src]
impl DivAssign<f32x4> for f32x4
[src]
pub fn div_assign(&mut self, rhs: f32x4)
[src]
impl DivAssign<f32x4> for Bivec2x4
[src]
fn div_assign(&mut self, rhs: f32x4)
[src]
impl DivAssign<f32x4> for Bivec3x4
[src]
fn div_assign(&mut self, rhs: f32x4)
[src]
impl DivAssign<f32x4> for Rotor2x4
[src]
fn div_assign(&mut self, rhs: f32x4)
[src]
impl DivAssign<f32x4> for Rotor3x4
[src]
fn div_assign(&mut self, rhs: f32x4)
[src]
impl DivAssign<f32x4> for Vec2x4
[src]
fn div_assign(&mut self, rhs: f32x4)
[src]
impl DivAssign<f32x4> for Vec3x4
[src]
fn div_assign(&mut self, rhs: f32x4)
[src]
impl DivAssign<f32x4> for Vec4x4
[src]
fn div_assign(&mut self, rhs: f32x4)
[src]
impl<'_> From<&'_ [f32]> for f32x4
[src]
impl From<[f32; 4]> for f32x4
[src]
impl From<f32> for f32x4
[src]
impl Lerp<f32x4> for f32x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl Lerp<f32x4> for Vec2x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl Lerp<f32x4> for Vec3x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl Lerp<f32x4> for Vec4x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl Lerp<f32x4> for Bivec2x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl Lerp<f32x4> for Bivec3x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl Lerp<f32x4> for Rotor2x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl Lerp<f32x4> for Rotor3x4
[src]
fn lerp(&self, end: Self, t: f32x4) -> Self
[src]
Linearly interpolate between self
and end
by t
between 0.0 and 1.0.
i.e. (1.0 - t) * self + (t) * end
.
For interpolating Rotor
s 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 Rotor
s to be of constant angular velocity. In this
case, check out Slerp
.
impl LowerExp for f32x4
[src]
impl LowerHex for f32x4
[src]
impl<'_> Mul<&'_ f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the *
operator.
#[must_use]pub fn mul(self, rhs: &f32x4) -> <f32x4 as Mul<&'_ f32x4>>::Output
[src]
impl Mul<Bivec2x4> for f32x4
[src]
type Output = Bivec2x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Bivec2x4) -> Bivec2x4
[src]
impl Mul<Bivec3x4> for f32x4
[src]
type Output = Bivec3x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Bivec3x4) -> Bivec3x4
[src]
impl Mul<Mat2x4> for f32x4
[src]
type Output = Mat2x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Mat2x4) -> Mat2x4
[src]
impl Mul<Mat3x4> for f32x4
[src]
type Output = Mat3x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Mat3x4) -> Mat3x4
[src]
impl Mul<Mat4x4> for f32x4
[src]
type Output = Mat4x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Mat4x4) -> Mat4x4
[src]
impl Mul<Rotor2x4> for f32x4
[src]
type Output = Rotor2x4
The resulting type after applying the *
operator.
fn mul(self, rotor: Rotor2x4) -> Rotor2x4
[src]
impl Mul<Rotor3x4> for f32x4
[src]
type Output = Rotor3x4
The resulting type after applying the *
operator.
fn mul(self, rotor: Rotor3x4) -> Rotor3x4
[src]
impl Mul<Vec2x4> for f32x4
[src]
type Output = Vec2x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Vec2x4) -> Vec2x4
[src]
impl Mul<Vec3x4> for f32x4
[src]
type Output = Vec3x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Vec3x4) -> Vec3x4
[src]
impl Mul<Vec4x4> for f32x4
[src]
type Output = Vec4x4
The resulting type after applying the *
operator.
fn mul(self, rhs: Vec4x4) -> Vec4x4
[src]
impl Mul<f32> for f32x4
[src]
type Output = f32x4
The resulting type after applying the *
operator.
#[must_use]pub fn mul(self, rhs: f32) -> <f32x4 as Mul<f32>>::Output
[src]
impl Mul<f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the *
operator.
#[must_use]pub fn mul(self, rhs: f32x4) -> <f32x4 as Mul<f32x4>>::Output
[src]
impl Mul<f32x4> for Bivec2x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Self
[src]
impl Mul<f32x4> for Similarity2x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, scalar: f32x4) -> Similarity2x4
[src]
impl Mul<f32x4> for Similarity3x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, scalar: f32x4) -> Similarity3x4
[src]
impl Mul<f32x4> for Vec2x4
[src]
type Output = Vec2x4
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Vec2x4
[src]
impl Mul<f32x4> for Vec3x4
[src]
type Output = Vec3x4
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Vec3x4
[src]
impl Mul<f32x4> for Vec4x4
[src]
type Output = Vec4x4
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Vec4x4
[src]
impl Mul<f32x4> for Bivec3x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Self
[src]
impl Mul<f32x4> for Mat2x4
[src]
type Output = Mat2x4
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Mat2x4
[src]
impl Mul<f32x4> for Mat3x4
[src]
type Output = Mat3x4
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Mat3x4
[src]
impl Mul<f32x4> for Mat4x4
[src]
type Output = Mat4x4
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Mat4x4
[src]
impl Mul<f32x4> for Rotor2x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Self
[src]
impl Mul<f32x4> for Rotor3x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, rhs: f32x4) -> Self
[src]
impl Mul<f32x4> for Isometry2x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, scalar: f32x4) -> Isometry2x4
[src]
impl Mul<f32x4> for Isometry3x4
[src]
type Output = Self
The resulting type after applying the *
operator.
fn mul(self, scalar: f32x4) -> Isometry3x4
[src]
impl<'_> MulAssign<&'_ f32x4> for f32x4
[src]
pub fn mul_assign(&mut self, rhs: &f32x4)
[src]
impl MulAssign<f32x4> for f32x4
[src]
pub fn mul_assign(&mut self, rhs: f32x4)
[src]
impl MulAssign<f32x4> for Bivec2x4
[src]
fn mul_assign(&mut self, rhs: f32x4)
[src]
impl MulAssign<f32x4> for Bivec3x4
[src]
fn mul_assign(&mut self, rhs: f32x4)
[src]
impl MulAssign<f32x4> for Rotor2x4
[src]
fn mul_assign(&mut self, rhs: f32x4)
[src]
impl MulAssign<f32x4> for Rotor3x4
[src]
fn mul_assign(&mut self, rhs: f32x4)
[src]
impl MulAssign<f32x4> for Vec2x4
[src]
fn mul_assign(&mut self, rhs: f32x4)
[src]
impl MulAssign<f32x4> for Vec3x4
[src]
fn mul_assign(&mut self, rhs: f32x4)
[src]
impl MulAssign<f32x4> for Vec4x4
[src]
fn mul_assign(&mut self, rhs: f32x4)
[src]
impl<'_> Neg for &'_ f32x4
[src]
type Output = f32x4
The resulting type after applying the -
operator.
#[must_use]pub fn neg(self) -> <&'_ f32x4 as Neg>::Output
[src]
impl Neg for f32x4
[src]
type Output = f32x4
The resulting type after applying the -
operator.
#[must_use]pub fn neg(self) -> <f32x4 as Neg>::Output
[src]
impl<'_> Not for &'_ f32x4
[src]
type Output = f32x4
The resulting type after applying the !
operator.
#[must_use]pub fn not(self) -> <&'_ f32x4 as Not>::Output
[src]
impl Not for f32x4
[src]
type Output = f32x4
The resulting type after applying the !
operator.
#[must_use]pub fn not(self) -> <f32x4 as Not>::Output
[src]
impl Octal for f32x4
[src]
impl PartialEq<f32x4> for f32x4
[src]
impl Pod for f32x4
[src]
impl<RHS> Product<RHS> for f32x4 where
f32x4: MulAssign<RHS>,
[src]
f32x4: MulAssign<RHS>,
impl Slerp<f32x4> for Rotor3x4
[src]
fn slerp(&self, end: Self, t: f32x4) -> Self
[src]
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 Rotor
s, 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 Rotor
s, etc!
impl Slerp<f32x4> for Vec2x4
[src]
fn slerp(&self, end: Self, t: f32x4) -> Self
[src]
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 Rotor
s, 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 Rotor
s, etc!
impl Slerp<f32x4> for Vec3x4
[src]
fn slerp(&self, end: Self, t: f32x4) -> Self
[src]
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 Rotor
s, 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 Rotor
s, etc!
impl Slerp<f32x4> for Vec4x4
[src]
fn slerp(&self, end: Self, t: f32x4) -> Self
[src]
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 Rotor
s, 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 Rotor
s, etc!
impl Slerp<f32x4> for Bivec2x4
[src]
fn slerp(&self, end: Self, t: f32x4) -> Self
[src]
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 Rotor
s, 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 Rotor
s, etc!
impl Slerp<f32x4> for Bivec3x4
[src]
fn slerp(&self, end: Self, t: f32x4) -> Self
[src]
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 Rotor
s, 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 Rotor
s, etc!
impl Slerp<f32x4> for Rotor2x4
[src]
fn slerp(&self, end: Self, t: f32x4) -> Self
[src]
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 Rotor
s, 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 Rotor
s, etc!
impl StructuralPartialEq for f32x4
[src]
impl<'_> Sub<&'_ f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the -
operator.
#[must_use]pub fn sub(self, rhs: &f32x4) -> <f32x4 as Sub<&'_ f32x4>>::Output
[src]
impl Sub<f32> for f32x4
[src]
type Output = f32x4
The resulting type after applying the -
operator.
#[must_use]pub fn sub(self, rhs: f32) -> <f32x4 as Sub<f32>>::Output
[src]
impl Sub<f32x4> for f32x4
[src]
type Output = f32x4
The resulting type after applying the -
operator.
#[must_use]pub fn sub(self, rhs: f32x4) -> <f32x4 as Sub<f32x4>>::Output
[src]
impl<'_> SubAssign<&'_ f32x4> for f32x4
[src]
pub fn sub_assign(&mut self, rhs: &f32x4)
[src]
impl SubAssign<f32x4> for f32x4
[src]
pub fn sub_assign(&mut self, rhs: f32x4)
[src]
impl<RHS> Sum<RHS> for f32x4 where
f32x4: AddAssign<RHS>,
[src]
f32x4: AddAssign<RHS>,
impl UpperExp for f32x4
[src]
impl UpperHex for f32x4
[src]
impl Zeroable for f32x4
[src]
pub fn zeroed() -> Self
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
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,