Struct ultraviolet::f64x4 [−][src]
#[repr(C, align(32))]pub struct f64x4 { /* fields omitted */ }
Implementations
impl f64x4
[src]
impl f64x4
[src]pub const ONE: f64x4
[src]
pub const ZERO: f64x4
[src]
pub const HALF: f64x4
[src]
pub const E: f64x4
[src]
pub const FRAC_1_PI: f64x4
[src]
pub const FRAC_2_PI: f64x4
[src]
pub const FRAC_2_SQRT_PI: f64x4
[src]
pub const FRAC_1_SQRT_2: f64x4
[src]
pub const FRAC_PI_2: f64x4
[src]
pub const FRAC_PI_3: f64x4
[src]
pub const FRAC_PI_4: f64x4
[src]
pub const FRAC_PI_6: f64x4
[src]
pub const FRAC_PI_8: f64x4
[src]
pub const LN_2: f64x4
[src]
pub const LN_10: f64x4
[src]
pub const LOG2_E: f64x4
[src]
pub const LOG10_E: f64x4
[src]
pub const LOG10_2: f64x4
[src]
pub const LOG2_10: f64x4
[src]
pub const PI: f64x4
[src]
pub const SQRT_2: f64x4
[src]
pub const TAU: f64x4
[src]
impl f64x4
[src]
impl f64x4
[src]#[must_use]pub fn blend(self, t: f64x4, f: f64x4) -> f64x4
[src]
#[must_use]pub fn abs(self) -> f64x4
[src]
#[must_use]pub fn max(self, rhs: f64x4) -> f64x4
[src]
#[must_use]pub fn min(self, rhs: f64x4) -> f64x4
[src]
#[must_use]pub fn is_nan(self) -> f64x4
[src]
#[must_use]pub fn is_finite(self) -> f64x4
[src]
#[must_use]pub fn is_inf(self) -> f64x4
[src]
#[must_use]pub fn round(self) -> f64x4
[src]
#[must_use]pub fn round_int(self) -> i64x4
[src]
#[must_use]pub fn mul_add(self, m: f64x4, a: f64x4) -> f64x4
[src]
#[must_use]pub fn mul_sub(self, m: f64x4, a: f64x4) -> f64x4
[src]
#[must_use]pub fn mul_neg_add(self, m: f64x4, a: f64x4) -> f64x4
[src]
#[must_use]pub fn mul_neg_sub(self, m: f64x4, a: f64x4) -> f64x4
[src]
#[must_use]pub fn flip_signs(self, signs: f64x4) -> f64x4
[src]
#[must_use]pub fn copysign(self, sign: f64x4) -> f64x4
[src]
pub fn asin_acos(self) -> (f64x4, f64x4)
[src]
pub fn acos(self) -> f64x4
[src]
#[must_use]pub fn asin(self) -> f64x4
[src]
pub fn atan(self) -> f64x4
[src]
pub fn atan2(self, x: f64x4) -> f64x4
[src]
#[must_use]pub fn sin_cos(self) -> (f64x4, f64x4)
[src]
#[must_use]pub fn sin(self) -> f64x4
[src]
#[must_use]pub fn cos(self) -> f64x4
[src]
#[must_use]pub fn tan(self) -> f64x4
[src]
#[must_use]pub fn to_degrees(self) -> f64x4
[src]
#[must_use]pub fn to_radians(self) -> f64x4
[src]
#[must_use]pub fn sqrt(self) -> f64x4
[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 reduce_add(self) -> f64
[src]
#[must_use]pub fn log2(self) -> f64x4
[src]
#[must_use]pub fn log10(self) -> f64x4
[src]
#[must_use]pub fn pow_f64x4(self, y: f64x4) -> f64x4
[src]
pub fn powf(self, y: f64) -> f64x4
[src]
Trait Implementations
impl<'_> AddAssign<&'_ f64x4> for f64x4
[src]
impl<'_> AddAssign<&'_ f64x4> for f64x4
[src]pub fn add_assign(&mut self, rhs: &f64x4)
[src]
pub fn add_assign(&mut self, rhs: &f64x4)
[src]Performs the +=
operation. Read more
impl AddAssign<f64x4> for f64x4
[src]
impl AddAssign<f64x4> for f64x4
[src]pub fn add_assign(&mut self, rhs: f64x4)
[src]
pub fn add_assign(&mut self, rhs: f64x4)
[src]Performs the +=
operation. Read more
impl<'_> BitAndAssign<&'_ f64x4> for f64x4
[src]
impl<'_> BitAndAssign<&'_ f64x4> for f64x4
[src]pub fn bitand_assign(&mut self, rhs: &f64x4)
[src]
pub fn bitand_assign(&mut self, rhs: &f64x4)
[src]Performs the &=
operation. Read more
impl BitAndAssign<f64x4> for f64x4
[src]
impl BitAndAssign<f64x4> for f64x4
[src]pub fn bitand_assign(&mut self, rhs: f64x4)
[src]
pub fn bitand_assign(&mut self, rhs: f64x4)
[src]Performs the &=
operation. Read more
impl<'_> BitOrAssign<&'_ f64x4> for f64x4
[src]
impl<'_> BitOrAssign<&'_ f64x4> for f64x4
[src]pub fn bitor_assign(&mut self, rhs: &f64x4)
[src]
pub fn bitor_assign(&mut self, rhs: &f64x4)
[src]Performs the |=
operation. Read more
impl BitOrAssign<f64x4> for f64x4
[src]
impl BitOrAssign<f64x4> for f64x4
[src]pub fn bitor_assign(&mut self, rhs: f64x4)
[src]
pub fn bitor_assign(&mut self, rhs: f64x4)
[src]Performs the |=
operation. Read more
impl<'_> BitXorAssign<&'_ f64x4> for f64x4
[src]
impl<'_> BitXorAssign<&'_ f64x4> for f64x4
[src]pub fn bitxor_assign(&mut self, rhs: &f64x4)
[src]
pub fn bitxor_assign(&mut self, rhs: &f64x4)
[src]Performs the ^=
operation. Read more
impl BitXorAssign<f64x4> for f64x4
[src]
impl BitXorAssign<f64x4> for f64x4
[src]pub fn bitxor_assign(&mut self, rhs: f64x4)
[src]
pub fn bitxor_assign(&mut self, rhs: f64x4)
[src]Performs the ^=
operation. Read more
impl<'_> DivAssign<&'_ f64x4> for f64x4
[src]
impl<'_> DivAssign<&'_ f64x4> for f64x4
[src]pub fn div_assign(&mut self, rhs: &f64x4)
[src]
pub fn div_assign(&mut self, rhs: &f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for f64x4
[src]
impl DivAssign<f64x4> for f64x4
[src]pub fn div_assign(&mut self, rhs: f64x4)
[src]
pub fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for DBivec2x4
[src]
impl DivAssign<f64x4> for DBivec2x4
[src]fn div_assign(&mut self, rhs: f64x4)
[src]
fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for DBivec3x4
[src]
impl DivAssign<f64x4> for DBivec3x4
[src]fn div_assign(&mut self, rhs: f64x4)
[src]
fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for DRotor2x4
[src]
impl DivAssign<f64x4> for DRotor2x4
[src]fn div_assign(&mut self, rhs: f64x4)
[src]
fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for DRotor3x4
[src]
impl DivAssign<f64x4> for DRotor3x4
[src]fn div_assign(&mut self, rhs: f64x4)
[src]
fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for DVec2x4
[src]
impl DivAssign<f64x4> for DVec2x4
[src]fn div_assign(&mut self, rhs: f64x4)
[src]
fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for DVec3x4
[src]
impl DivAssign<f64x4> for DVec3x4
[src]fn div_assign(&mut self, rhs: f64x4)
[src]
fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl DivAssign<f64x4> for DVec4x4
[src]
impl DivAssign<f64x4> for DVec4x4
[src]fn div_assign(&mut self, rhs: f64x4)
[src]
fn div_assign(&mut self, rhs: f64x4)
[src]Performs the /=
operation. Read more
impl Lerp<f64x4> for f64x4
[src]
impl Lerp<f64x4> for f64x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec2x4
[src]
impl Lerp<f64x4> for DVec2x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec3x4
[src]
impl Lerp<f64x4> for DVec3x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec4x4
[src]
impl Lerp<f64x4> for DVec4x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec2x4
[src]
impl Lerp<f64x4> for DBivec2x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec3x4
[src]
impl Lerp<f64x4> for DBivec3x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DRotor2x4
[src]
impl Lerp<f64x4> for DRotor2x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DRotor3x4
[src]
impl Lerp<f64x4> for DRotor3x4
[src]fn lerp(&self, end: Self, t: f64x4) -> Self
[src]
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DSimilarity2x4
[src]
impl Mul<f64x4> for DSimilarity2x4
[src]impl Mul<f64x4> for DSimilarity3x4
[src]
impl Mul<f64x4> for DSimilarity3x4
[src]impl Mul<f64x4> for DIsometry2x4
[src]
impl Mul<f64x4> for DIsometry2x4
[src]impl Mul<f64x4> for DIsometry3x4
[src]
impl Mul<f64x4> for DIsometry3x4
[src]impl<'_> MulAssign<&'_ f64x4> for f64x4
[src]
impl<'_> MulAssign<&'_ f64x4> for f64x4
[src]pub fn mul_assign(&mut self, rhs: &f64x4)
[src]
pub fn mul_assign(&mut self, rhs: &f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for f64x4
[src]
impl MulAssign<f64x4> for f64x4
[src]pub fn mul_assign(&mut self, rhs: f64x4)
[src]
pub fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for DBivec2x4
[src]
impl MulAssign<f64x4> for DBivec2x4
[src]fn mul_assign(&mut self, rhs: f64x4)
[src]
fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for DBivec3x4
[src]
impl MulAssign<f64x4> for DBivec3x4
[src]fn mul_assign(&mut self, rhs: f64x4)
[src]
fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for DRotor2x4
[src]
impl MulAssign<f64x4> for DRotor2x4
[src]fn mul_assign(&mut self, rhs: f64x4)
[src]
fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for DRotor3x4
[src]
impl MulAssign<f64x4> for DRotor3x4
[src]fn mul_assign(&mut self, rhs: f64x4)
[src]
fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for DVec2x4
[src]
impl MulAssign<f64x4> for DVec2x4
[src]fn mul_assign(&mut self, rhs: f64x4)
[src]
fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for DVec3x4
[src]
impl MulAssign<f64x4> for DVec3x4
[src]fn mul_assign(&mut self, rhs: f64x4)
[src]
fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl MulAssign<f64x4> for DVec4x4
[src]
impl MulAssign<f64x4> for DVec4x4
[src]fn mul_assign(&mut self, rhs: f64x4)
[src]
fn mul_assign(&mut self, rhs: f64x4)
[src]Performs the *=
operation. Read more
impl Slerp<f64x4> for DRotor3x4
[src]
impl Slerp<f64x4> for DRotor3x4
[src]fn slerp(&self, end: Self, t: f64x4) -> Self
[src]
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec2x4
[src]
impl Slerp<f64x4> for DVec2x4
[src]fn slerp(&self, end: Self, t: f64x4) -> Self
[src]
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec3x4
[src]
impl Slerp<f64x4> for DVec3x4
[src]fn slerp(&self, end: Self, t: f64x4) -> Self
[src]
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec4x4
[src]
impl Slerp<f64x4> for DVec4x4
[src]fn slerp(&self, end: Self, t: f64x4) -> Self
[src]
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec2x4
[src]
impl Slerp<f64x4> for DBivec2x4
[src]fn slerp(&self, end: Self, t: f64x4) -> Self
[src]
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec3x4
[src]
impl Slerp<f64x4> for DBivec3x4
[src]fn slerp(&self, end: Self, t: f64x4) -> Self
[src]
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DRotor2x4
[src]
impl Slerp<f64x4> for DRotor2x4
[src]fn slerp(&self, end: Self, t: f64x4) -> Self
[src]
fn slerp(&self, end: Self, t: f64x4) -> 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<&'_ f64x4> for f64x4
[src]
impl<'_> SubAssign<&'_ f64x4> for f64x4
[src]pub fn sub_assign(&mut self, rhs: &f64x4)
[src]
pub fn sub_assign(&mut self, rhs: &f64x4)
[src]Performs the -=
operation. Read more
impl SubAssign<f64x4> for f64x4
[src]
impl SubAssign<f64x4> for f64x4
[src]pub fn sub_assign(&mut self, rhs: f64x4)
[src]
pub fn sub_assign(&mut self, rhs: f64x4)
[src]Performs the -=
operation. Read more
impl Copy for f64x4
[src]
impl Pod for f64x4
[src]
impl StructuralPartialEq for f64x4
[src]
Auto Trait Implementations
impl RefUnwindSafe for f64x4
impl Send for f64x4
impl Sync for f64x4
impl Unpin for f64x4
impl UnwindSafe for f64x4
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