Struct ultraviolet::m32x8 [−][src]
#[repr(C, align(32))]pub struct m32x8 { /* fields omitted */ }
Implementations
impl f32x8
[src]
impl f32x8
[src]pub const ONE: f32x8
[src]
pub const HALF: f32x8
[src]
pub const ZERO: f32x8
[src]
pub const E: f32x8
[src]
pub const FRAC_1_PI: f32x8
[src]
pub const FRAC_2_PI: f32x8
[src]
pub const FRAC_2_SQRT_PI: f32x8
[src]
pub const FRAC_1_SQRT_2: f32x8
[src]
pub const FRAC_PI_2: f32x8
[src]
pub const FRAC_PI_3: f32x8
[src]
pub const FRAC_PI_4: f32x8
[src]
pub const FRAC_PI_6: f32x8
[src]
pub const FRAC_PI_8: f32x8
[src]
pub const LN_2: f32x8
[src]
pub const LN_10: f32x8
[src]
pub const LOG2_E: f32x8
[src]
pub const LOG10_E: f32x8
[src]
pub const LOG10_2: f32x8
[src]
pub const LOG2_10: f32x8
[src]
pub const PI: f32x8
[src]
pub const SQRT_2: f32x8
[src]
pub const TAU: f32x8
[src]
impl f32x8
[src]
impl f32x8
[src]#[must_use]pub fn blend(self, t: f32x8, f: f32x8) -> f32x8
[src]
#[must_use]pub fn abs(self) -> f32x8
[src]
#[must_use]pub fn max(self, rhs: f32x8) -> f32x8
[src]
#[must_use]pub fn min(self, rhs: f32x8) -> f32x8
[src]
#[must_use]pub fn is_nan(self) -> f32x8
[src]
#[must_use]pub fn is_finite(self) -> f32x8
[src]
#[must_use]pub fn is_inf(self) -> f32x8
[src]
#[must_use]pub fn round(self) -> f32x8
[src]
#[must_use]pub fn round_int(self) -> i32x8
[src]
#[must_use]pub fn mul_add(self, m: f32x8, a: f32x8) -> f32x8
[src]
#[must_use]pub fn mul_sub(self, m: f32x8, a: f32x8) -> f32x8
[src]
#[must_use]pub fn mul_neg_add(self, m: f32x8, a: f32x8) -> f32x8
[src]
#[must_use]pub fn mul_neg_sub(self, m: f32x8, a: f32x8) -> f32x8
[src]
#[must_use]pub fn flip_signs(self, signs: f32x8) -> f32x8
[src]
#[must_use]pub fn copysign(self, sign: f32x8) -> f32x8
[src]
pub fn asin_acos(self) -> (f32x8, f32x8)
[src]
#[must_use]pub fn asin(self) -> f32x8
[src]
#[must_use]pub fn acos(self) -> f32x8
[src]
pub fn atan(self) -> f32x8
[src]
pub fn atan2(self, x: f32x8) -> f32x8
[src]
#[must_use]pub fn sin_cos(self) -> (f32x8, f32x8)
[src]
#[must_use]pub fn sin(self) -> f32x8
[src]
#[must_use]pub fn cos(self) -> f32x8
[src]
#[must_use]pub fn tan(self) -> f32x8
[src]
#[must_use]pub fn to_degrees(self) -> f32x8
[src]
#[must_use]pub fn to_radians(self) -> f32x8
[src]
#[must_use]pub fn recip(self) -> f32x8
[src]
#[must_use]pub fn recip_sqrt(self) -> f32x8
[src]
#[must_use]pub fn sqrt(self) -> f32x8
[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]
pub fn sign_bit(self) -> f32x8
[src]
pub fn reduce_add(self) -> f32
[src]
#[must_use]pub fn log2(self) -> f32x8
[src]
#[must_use]pub fn log10(self) -> f32x8
[src]
#[must_use]pub fn pow_f32x8(self, y: f32x8) -> f32x8
[src]
pub fn powf(self, y: f32) -> f32x8
[src]
Trait Implementations
impl<'_> AddAssign<&'_ f32x8> for f32x8
[src]
impl<'_> AddAssign<&'_ f32x8> for f32x8
[src]pub fn add_assign(&mut self, rhs: &f32x8)
[src]
pub fn add_assign(&mut self, rhs: &f32x8)
[src]Performs the +=
operation. Read more
impl AddAssign<f32x8> for f32x8
[src]
impl AddAssign<f32x8> for f32x8
[src]pub fn add_assign(&mut self, rhs: f32x8)
[src]
pub fn add_assign(&mut self, rhs: f32x8)
[src]Performs the +=
operation. Read more
impl<'_> BitAndAssign<&'_ f32x8> for f32x8
[src]
impl<'_> BitAndAssign<&'_ f32x8> for f32x8
[src]pub fn bitand_assign(&mut self, rhs: &f32x8)
[src]
pub fn bitand_assign(&mut self, rhs: &f32x8)
[src]Performs the &=
operation. Read more
impl BitAndAssign<f32x8> for f32x8
[src]
impl BitAndAssign<f32x8> for f32x8
[src]pub fn bitand_assign(&mut self, rhs: f32x8)
[src]
pub fn bitand_assign(&mut self, rhs: f32x8)
[src]Performs the &=
operation. Read more
impl<'_> BitOrAssign<&'_ f32x8> for f32x8
[src]
impl<'_> BitOrAssign<&'_ f32x8> for f32x8
[src]pub fn bitor_assign(&mut self, rhs: &f32x8)
[src]
pub fn bitor_assign(&mut self, rhs: &f32x8)
[src]Performs the |=
operation. Read more
impl BitOrAssign<f32x8> for f32x8
[src]
impl BitOrAssign<f32x8> for f32x8
[src]pub fn bitor_assign(&mut self, rhs: f32x8)
[src]
pub fn bitor_assign(&mut self, rhs: f32x8)
[src]Performs the |=
operation. Read more
impl<'_> BitXorAssign<&'_ f32x8> for f32x8
[src]
impl<'_> BitXorAssign<&'_ f32x8> for f32x8
[src]pub fn bitxor_assign(&mut self, rhs: &f32x8)
[src]
pub fn bitxor_assign(&mut self, rhs: &f32x8)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<f32x8> for f32x8
[src]
impl BitXorAssign<f32x8> for f32x8
[src]pub fn bitxor_assign(&mut self, rhs: f32x8)
[src]
pub fn bitxor_assign(&mut self, rhs: f32x8)
[src]Performs the ^=
operation. Read more
impl<'_> DivAssign<&'_ f32x8> for f32x8
[src]
impl<'_> DivAssign<&'_ f32x8> for f32x8
[src]pub fn div_assign(&mut self, rhs: &f32x8)
[src]
pub fn div_assign(&mut self, rhs: &f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for f32x8
[src]
impl DivAssign<f32x8> for f32x8
[src]pub fn div_assign(&mut self, rhs: f32x8)
[src]
pub fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for Bivec2x8
[src]
impl DivAssign<f32x8> for Bivec2x8
[src]fn div_assign(&mut self, rhs: f32x8)
[src]
fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for Bivec3x8
[src]
impl DivAssign<f32x8> for Bivec3x8
[src]fn div_assign(&mut self, rhs: f32x8)
[src]
fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for Rotor2x8
[src]
impl DivAssign<f32x8> for Rotor2x8
[src]fn div_assign(&mut self, rhs: f32x8)
[src]
fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for Rotor3x8
[src]
impl DivAssign<f32x8> for Rotor3x8
[src]fn div_assign(&mut self, rhs: f32x8)
[src]
fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for Vec2x8
[src]
impl DivAssign<f32x8> for Vec2x8
[src]fn div_assign(&mut self, rhs: f32x8)
[src]
fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for Vec3x8
[src]
impl DivAssign<f32x8> for Vec3x8
[src]fn div_assign(&mut self, rhs: f32x8)
[src]
fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl DivAssign<f32x8> for Vec4x8
[src]
impl DivAssign<f32x8> for Vec4x8
[src]fn div_assign(&mut self, rhs: f32x8)
[src]
fn div_assign(&mut self, rhs: f32x8)
[src]Performs the /=
operation. Read more
impl Lerp<f32x8> for f32x8
[src]
impl Lerp<f32x8> for f32x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Vec2x8
[src]
impl Lerp<f32x8> for Vec2x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Vec3x8
[src]
impl Lerp<f32x8> for Vec3x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Vec4x8
[src]
impl Lerp<f32x8> for Vec4x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Bivec2x8
[src]
impl Lerp<f32x8> for Bivec2x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Bivec3x8
[src]
impl Lerp<f32x8> for Bivec3x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Rotor2x8
[src]
impl Lerp<f32x8> for Rotor2x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Rotor3x8
[src]
impl Lerp<f32x8> for Rotor3x8
[src]fn lerp(&self, end: Self, t: f32x8) -> Self
[src]
fn lerp(&self, end: Self, t: f32x8) -> 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 Mul<f32x8> for Similarity2x8
[src]
impl Mul<f32x8> for Similarity2x8
[src]impl Mul<f32x8> for Similarity3x8
[src]
impl Mul<f32x8> for Similarity3x8
[src]impl Mul<f32x8> for Isometry2x8
[src]
impl Mul<f32x8> for Isometry2x8
[src]impl Mul<f32x8> for Isometry3x8
[src]
impl Mul<f32x8> for Isometry3x8
[src]impl<'_> MulAssign<&'_ f32x8> for f32x8
[src]
impl<'_> MulAssign<&'_ f32x8> for f32x8
[src]pub fn mul_assign(&mut self, rhs: &f32x8)
[src]
pub fn mul_assign(&mut self, rhs: &f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for f32x8
[src]
impl MulAssign<f32x8> for f32x8
[src]pub fn mul_assign(&mut self, rhs: f32x8)
[src]
pub fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for Bivec2x8
[src]
impl MulAssign<f32x8> for Bivec2x8
[src]fn mul_assign(&mut self, rhs: f32x8)
[src]
fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for Bivec3x8
[src]
impl MulAssign<f32x8> for Bivec3x8
[src]fn mul_assign(&mut self, rhs: f32x8)
[src]
fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for Rotor2x8
[src]
impl MulAssign<f32x8> for Rotor2x8
[src]fn mul_assign(&mut self, rhs: f32x8)
[src]
fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for Rotor3x8
[src]
impl MulAssign<f32x8> for Rotor3x8
[src]fn mul_assign(&mut self, rhs: f32x8)
[src]
fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for Vec2x8
[src]
impl MulAssign<f32x8> for Vec2x8
[src]fn mul_assign(&mut self, rhs: f32x8)
[src]
fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for Vec3x8
[src]
impl MulAssign<f32x8> for Vec3x8
[src]fn mul_assign(&mut self, rhs: f32x8)
[src]
fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl MulAssign<f32x8> for Vec4x8
[src]
impl MulAssign<f32x8> for Vec4x8
[src]fn mul_assign(&mut self, rhs: f32x8)
[src]
fn mul_assign(&mut self, rhs: f32x8)
[src]Performs the *=
operation. Read more
impl Slerp<f32x8> for Rotor3x8
[src]
impl Slerp<f32x8> for Rotor3x8
[src]fn slerp(&self, end: Self, t: f32x8) -> Self
[src]
fn slerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Vec2x8
[src]
impl Slerp<f32x8> for Vec2x8
[src]fn slerp(&self, end: Self, t: f32x8) -> Self
[src]
fn slerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Vec3x8
[src]
impl Slerp<f32x8> for Vec3x8
[src]fn slerp(&self, end: Self, t: f32x8) -> Self
[src]
fn slerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Vec4x8
[src]
impl Slerp<f32x8> for Vec4x8
[src]fn slerp(&self, end: Self, t: f32x8) -> Self
[src]
fn slerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Bivec2x8
[src]
impl Slerp<f32x8> for Bivec2x8
[src]fn slerp(&self, end: Self, t: f32x8) -> Self
[src]
fn slerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Bivec3x8
[src]
impl Slerp<f32x8> for Bivec3x8
[src]fn slerp(&self, end: Self, t: f32x8) -> Self
[src]
fn slerp(&self, end: Self, t: f32x8) -> 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<f32x8> for Rotor2x8
[src]
impl Slerp<f32x8> for Rotor2x8
[src]fn slerp(&self, end: Self, t: f32x8) -> Self
[src]
fn slerp(&self, end: Self, t: f32x8) -> 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<'_> SubAssign<&'_ f32x8> for f32x8
[src]
impl<'_> SubAssign<&'_ f32x8> for f32x8
[src]pub fn sub_assign(&mut self, rhs: &f32x8)
[src]
pub fn sub_assign(&mut self, rhs: &f32x8)
[src]Performs the -=
operation. Read more
impl SubAssign<f32x8> for f32x8
[src]
impl SubAssign<f32x8> for f32x8
[src]pub fn sub_assign(&mut self, rhs: f32x8)
[src]
pub fn sub_assign(&mut self, rhs: f32x8)
[src]Performs the -=
operation. Read more
impl Copy for f32x8
[src]
impl Pod for f32x8
[src]
impl StructuralPartialEq for f32x8
[src]
Auto Trait Implementations
impl RefUnwindSafe for f32x8
impl Send for f32x8
impl Sync for f32x8
impl Unpin for f32x8
impl UnwindSafe for f32x8
Blanket Implementations
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]pub fn borrow_mut(&mut self) -> &mut T
[src]
pub fn borrow_mut(&mut self) -> &mut T
[src]Mutably borrows from an owned value. Read more
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
[src]type Owned = T
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn to_owned(&self) -> T
[src]Creates owned data from borrowed data, usually by cloning. Read more
pub fn clone_into(&self, target: &mut T)
[src]
pub fn clone_into(&self, target: &mut T)
[src]🔬 This is a nightly-only experimental API. (toowned_clone_into
)
recently added
Uses borrowed data to replace owned data, usually by cloning. Read more