Struct ultraviolet::f32x8
source · [−]#[repr(C, align(32))]pub struct f32x8 { /* private fields */ }
Implementations
sourceimpl f32x8
impl f32x8
pub const ONE: f32x8
pub const HALF: f32x8
pub const ZERO: f32x8
pub const E: f32x8
pub const FRAC_1_PI: f32x8
pub const FRAC_2_PI: f32x8
pub const FRAC_2_SQRT_PI: f32x8
pub const FRAC_1_SQRT_2: f32x8
pub const FRAC_PI_2: f32x8
pub const FRAC_PI_3: f32x8
pub const FRAC_PI_4: f32x8
pub const FRAC_PI_6: f32x8
pub const FRAC_PI_8: f32x8
pub const LN_2: f32x8
pub const LN_10: f32x8
pub const LOG2_E: f32x8
pub const LOG10_E: f32x8
pub const LOG10_2: f32x8
pub const LOG2_10: f32x8
pub const PI: f32x8
pub const SQRT_2: f32x8
pub const TAU: f32x8
sourceimpl f32x8
impl f32x8
pub fn new(array: [f32; 8]) -> f32x8
pub fn blend(self, t: f32x8, f: f32x8) -> f32x8
pub fn abs(self) -> f32x8
sourcepub fn fast_max(self, rhs: f32x8) -> f32x8
pub fn fast_max(self, rhs: f32x8) -> f32x8
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.
sourcepub fn max(self, rhs: f32x8) -> f32x8
pub fn max(self, rhs: f32x8) -> f32x8
Calculates the lanewise maximum of both vectors. This doesn’t match
IEEE-754 and instead is defined as self < rhs ? rhs : self
.
sourcepub fn fast_min(self, rhs: f32x8) -> f32x8
pub fn fast_min(self, rhs: f32x8) -> f32x8
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.
sourcepub fn min(self, rhs: f32x8) -> f32x8
pub fn min(self, rhs: f32x8) -> f32x8
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.
pub fn is_nan(self) -> f32x8
pub fn is_finite(self) -> f32x8
pub fn is_inf(self) -> f32x8
pub fn round(self) -> f32x8
sourcepub fn fast_round_int(self) -> i32x8
pub fn fast_round_int(self) -> i32x8
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.
sourcepub fn round_int(self) -> i32x8
pub fn round_int(self) -> i32x8
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.
sourcepub fn fast_trunc_int(self) -> i32x8
pub fn fast_trunc_int(self) -> i32x8
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.
sourcepub fn trunc_int(self) -> i32x8
pub fn trunc_int(self) -> i32x8
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.
pub fn mul_add(self, m: f32x8, a: f32x8) -> f32x8
pub fn mul_sub(self, m: f32x8, a: f32x8) -> f32x8
pub fn mul_neg_add(self, m: f32x8, a: f32x8) -> f32x8
pub fn mul_neg_sub(self, m: f32x8, a: f32x8) -> f32x8
pub fn flip_signs(self, signs: f32x8) -> f32x8
pub fn copysign(self, sign: f32x8) -> f32x8
pub fn asin_acos(self) -> (f32x8, f32x8)
pub fn asin(self) -> f32x8
pub fn acos(self) -> f32x8
pub fn atan(self) -> f32x8
pub fn atan2(self, x: f32x8) -> f32x8
pub fn sin_cos(self) -> (f32x8, f32x8)
pub fn sin(self) -> f32x8
pub fn cos(self) -> f32x8
pub fn tan(self) -> f32x8
pub fn to_degrees(self) -> f32x8
pub fn to_radians(self) -> f32x8
pub fn recip(self) -> f32x8
pub fn recip_sqrt(self) -> f32x8
pub fn sqrt(self) -> f32x8
pub fn move_mask(self) -> i32
pub fn any(self) -> bool
pub fn all(self) -> bool
pub fn none(self) -> bool
pub fn sign_bit(self) -> f32x8
pub fn reduce_add(self) -> f32
pub fn log2(self) -> f32x8
pub fn log10(self) -> f32x8
pub fn pow_f32x8(self, y: f32x8) -> f32x8
pub fn powf(self, y: f32) -> f32x8
pub fn to_array(self) -> [f32; 8]
pub fn as_array_ref(&self) -> &[f32; 8]
Trait Implementations
sourceimpl<'_> AddAssign<&'_ f32x8> for f32x8
impl<'_> AddAssign<&'_ f32x8> for f32x8
sourcefn add_assign(&mut self, rhs: &f32x8)
fn add_assign(&mut self, rhs: &f32x8)
Performs the +=
operation. Read more
sourceimpl AddAssign<f32x8> for f32x8
impl AddAssign<f32x8> for f32x8
sourcefn add_assign(&mut self, rhs: f32x8)
fn add_assign(&mut self, rhs: f32x8)
Performs the +=
operation. Read more
sourceimpl<'_> BitAndAssign<&'_ f32x8> for f32x8
impl<'_> BitAndAssign<&'_ f32x8> for f32x8
sourcefn bitand_assign(&mut self, rhs: &f32x8)
fn bitand_assign(&mut self, rhs: &f32x8)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<f32x8> for f32x8
impl BitAndAssign<f32x8> for f32x8
sourcefn bitand_assign(&mut self, rhs: f32x8)
fn bitand_assign(&mut self, rhs: f32x8)
Performs the &=
operation. Read more
sourceimpl<'_> BitOrAssign<&'_ f32x8> for f32x8
impl<'_> BitOrAssign<&'_ f32x8> for f32x8
sourcefn bitor_assign(&mut self, rhs: &f32x8)
fn bitor_assign(&mut self, rhs: &f32x8)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<f32x8> for f32x8
impl BitOrAssign<f32x8> for f32x8
sourcefn bitor_assign(&mut self, rhs: f32x8)
fn bitor_assign(&mut self, rhs: f32x8)
Performs the |=
operation. Read more
sourceimpl<'_> BitXorAssign<&'_ f32x8> for f32x8
impl<'_> BitXorAssign<&'_ f32x8> for f32x8
sourcefn bitxor_assign(&mut self, rhs: &f32x8)
fn bitxor_assign(&mut self, rhs: &f32x8)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<f32x8> for f32x8
impl BitXorAssign<f32x8> for f32x8
sourcefn bitxor_assign(&mut self, rhs: f32x8)
fn bitxor_assign(&mut self, rhs: f32x8)
Performs the ^=
operation. Read more
sourceimpl<'_> DivAssign<&'_ f32x8> for f32x8
impl<'_> DivAssign<&'_ f32x8> for f32x8
sourcefn div_assign(&mut self, rhs: &f32x8)
fn div_assign(&mut self, rhs: &f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for f32x8
impl DivAssign<f32x8> for f32x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for Bivec2x8
impl DivAssign<f32x8> for Bivec2x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for Bivec3x8
impl DivAssign<f32x8> for Bivec3x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for Rotor2x8
impl DivAssign<f32x8> for Rotor2x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for Rotor3x8
impl DivAssign<f32x8> for Rotor3x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for Vec2x8
impl DivAssign<f32x8> for Vec2x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for Vec3x8
impl DivAssign<f32x8> for Vec3x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl DivAssign<f32x8> for Vec4x8
impl DivAssign<f32x8> for Vec4x8
sourcefn div_assign(&mut self, rhs: f32x8)
fn div_assign(&mut self, rhs: f32x8)
Performs the /=
operation. Read more
sourceimpl Lerp<f32x8> for f32x8
impl Lerp<f32x8> for f32x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Lerp<f32x8> for Vec2x8
impl Lerp<f32x8> for Vec2x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Lerp<f32x8> for Vec3x8
impl Lerp<f32x8> for Vec3x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Lerp<f32x8> for Vec4x8
impl Lerp<f32x8> for Vec4x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Lerp<f32x8> for Bivec2x8
impl Lerp<f32x8> for Bivec2x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Lerp<f32x8> for Bivec3x8
impl Lerp<f32x8> for Bivec3x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Lerp<f32x8> for Rotor2x8
impl Lerp<f32x8> for Rotor2x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Lerp<f32x8> for Rotor3x8
impl Lerp<f32x8> for Rotor3x8
sourcefn lerp(&self, end: Self, t: f32x8) -> Self
fn lerp(&self, end: Self, t: f32x8) -> 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 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
.
sourceimpl Mul<f32x8> for Similarity2x8
impl Mul<f32x8> for Similarity2x8
sourceimpl Mul<f32x8> for Similarity3x8
impl Mul<f32x8> for Similarity3x8
sourceimpl Mul<f32x8> for Isometry2x8
impl Mul<f32x8> for Isometry2x8
sourceimpl Mul<f32x8> for Isometry3x8
impl Mul<f32x8> for Isometry3x8
sourceimpl<'_> MulAssign<&'_ f32x8> for f32x8
impl<'_> MulAssign<&'_ f32x8> for f32x8
sourcefn mul_assign(&mut self, rhs: &f32x8)
fn mul_assign(&mut self, rhs: &f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for f32x8
impl MulAssign<f32x8> for f32x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for Bivec2x8
impl MulAssign<f32x8> for Bivec2x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for Bivec3x8
impl MulAssign<f32x8> for Bivec3x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for Rotor2x8
impl MulAssign<f32x8> for Rotor2x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for Rotor3x8
impl MulAssign<f32x8> for Rotor3x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for Vec2x8
impl MulAssign<f32x8> for Vec2x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for Vec3x8
impl MulAssign<f32x8> for Vec3x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl MulAssign<f32x8> for Vec4x8
impl MulAssign<f32x8> for Vec4x8
sourcefn mul_assign(&mut self, rhs: f32x8)
fn mul_assign(&mut self, rhs: f32x8)
Performs the *=
operation. Read more
sourceimpl Slerp<f32x8> for Rotor3x8
impl Slerp<f32x8> for Rotor3x8
sourcefn slerp(&self, end: Self, t: f32x8) -> Self
fn slerp(&self, end: Self, t: f32x8) -> 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 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!
sourceimpl Slerp<f32x8> for Vec2x8
impl Slerp<f32x8> for Vec2x8
sourcefn slerp(&self, end: Self, t: f32x8) -> Self
fn slerp(&self, end: Self, t: f32x8) -> 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 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!
sourceimpl Slerp<f32x8> for Vec3x8
impl Slerp<f32x8> for Vec3x8
sourcefn slerp(&self, end: Self, t: f32x8) -> Self
fn slerp(&self, end: Self, t: f32x8) -> 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 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!
sourceimpl Slerp<f32x8> for Vec4x8
impl Slerp<f32x8> for Vec4x8
sourcefn slerp(&self, end: Self, t: f32x8) -> Self
fn slerp(&self, end: Self, t: f32x8) -> 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 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!
sourceimpl Slerp<f32x8> for Bivec2x8
impl Slerp<f32x8> for Bivec2x8
sourcefn slerp(&self, end: Self, t: f32x8) -> Self
fn slerp(&self, end: Self, t: f32x8) -> 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 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!
sourceimpl Slerp<f32x8> for Bivec3x8
impl Slerp<f32x8> for Bivec3x8
sourcefn slerp(&self, end: Self, t: f32x8) -> Self
fn slerp(&self, end: Self, t: f32x8) -> 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 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!
sourceimpl Slerp<f32x8> for Rotor2x8
impl Slerp<f32x8> for Rotor2x8
sourcefn slerp(&self, end: Self, t: f32x8) -> Self
fn slerp(&self, end: Self, t: f32x8) -> 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 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!
sourceimpl<'_> SubAssign<&'_ f32x8> for f32x8
impl<'_> SubAssign<&'_ f32x8> for f32x8
sourcefn sub_assign(&mut self, rhs: &f32x8)
fn sub_assign(&mut self, rhs: &f32x8)
Performs the -=
operation. Read more
sourceimpl SubAssign<f32x8> for f32x8
impl SubAssign<f32x8> for f32x8
sourcefn sub_assign(&mut self, rhs: f32x8)
fn sub_assign(&mut self, rhs: f32x8)
Performs the -=
operation. Read more
impl Copy for f32x8
impl Pod for f32x8
impl StructuralPartialEq for f32x8
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
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more