Struct ultraviolet::f64x4
source · [−]#[repr(C, align(32))]pub struct f64x4 { /* private fields */ }
Implementations
sourceimpl f64x4
impl f64x4
pub const ONE: f64x4
pub const ZERO: f64x4
pub const HALF: f64x4
pub const E: f64x4
pub const FRAC_1_PI: f64x4
pub const FRAC_2_PI: f64x4
pub const FRAC_2_SQRT_PI: f64x4
pub const FRAC_1_SQRT_2: f64x4
pub const FRAC_PI_2: f64x4
pub const FRAC_PI_3: f64x4
pub const FRAC_PI_4: f64x4
pub const FRAC_PI_6: f64x4
pub const FRAC_PI_8: f64x4
pub const LN_2: f64x4
pub const LN_10: f64x4
pub const LOG2_E: f64x4
pub const LOG10_E: f64x4
pub const LOG10_2: f64x4
pub const LOG2_10: f64x4
pub const PI: f64x4
pub const SQRT_2: f64x4
pub const TAU: f64x4
sourceimpl f64x4
impl f64x4
pub fn new(array: [f64; 4]) -> f64x4
pub fn blend(self, t: f64x4, f: f64x4) -> f64x4
pub fn abs(self) -> f64x4
sourcepub fn fast_max(self, rhs: f64x4) -> f64x4
pub fn fast_max(self, rhs: f64x4) -> f64x4
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: f64x4) -> f64x4
pub fn max(self, rhs: f64x4) -> f64x4
Calculates the lanewise maximum of both vectors. If either lane is NaN,
the other lane gets chosen. Use fast_max
for a faster implementation
that doesn’t handle NaNs.
sourcepub fn fast_min(self, rhs: f64x4) -> f64x4
pub fn fast_min(self, rhs: f64x4) -> f64x4
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: f64x4) -> f64x4
pub fn min(self, rhs: f64x4) -> f64x4
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) -> f64x4
pub fn is_finite(self) -> f64x4
pub fn is_inf(self) -> f64x4
pub fn round(self) -> f64x4
pub fn round_int(self) -> i64x4
pub fn mul_add(self, m: f64x4, a: f64x4) -> f64x4
pub fn mul_sub(self, m: f64x4, a: f64x4) -> f64x4
pub fn mul_neg_add(self, m: f64x4, a: f64x4) -> f64x4
pub fn mul_neg_sub(self, m: f64x4, a: f64x4) -> f64x4
pub fn flip_signs(self, signs: f64x4) -> f64x4
pub fn copysign(self, sign: f64x4) -> f64x4
pub fn asin_acos(self) -> (f64x4, f64x4)
pub fn acos(self) -> f64x4
pub fn asin(self) -> f64x4
pub fn atan(self) -> f64x4
pub fn atan2(self, x: f64x4) -> f64x4
pub fn sin_cos(self) -> (f64x4, f64x4)
pub fn sin(self) -> f64x4
pub fn cos(self) -> f64x4
pub fn tan(self) -> f64x4
pub fn to_degrees(self) -> f64x4
pub fn to_radians(self) -> f64x4
pub fn sqrt(self) -> f64x4
pub fn move_mask(self) -> i32
pub fn any(self) -> bool
pub fn all(self) -> bool
pub fn none(self) -> bool
pub fn reduce_add(self) -> f64
pub fn log2(self) -> f64x4
pub fn log10(self) -> f64x4
pub fn pow_f64x4(self, y: f64x4) -> f64x4
pub fn powf(self, y: f64) -> f64x4
pub fn to_array(self) -> [f64; 4]
pub fn as_array_ref(&self) -> &[f64; 4]
Trait Implementations
sourceimpl<'_> AddAssign<&'_ f64x4> for f64x4
impl<'_> AddAssign<&'_ f64x4> for f64x4
sourcefn add_assign(&mut self, rhs: &f64x4)
fn add_assign(&mut self, rhs: &f64x4)
Performs the +=
operation. Read more
sourceimpl AddAssign<f64x4> for f64x4
impl AddAssign<f64x4> for f64x4
sourcefn add_assign(&mut self, rhs: f64x4)
fn add_assign(&mut self, rhs: f64x4)
Performs the +=
operation. Read more
sourceimpl<'_> BitAndAssign<&'_ f64x4> for f64x4
impl<'_> BitAndAssign<&'_ f64x4> for f64x4
sourcefn bitand_assign(&mut self, rhs: &f64x4)
fn bitand_assign(&mut self, rhs: &f64x4)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<f64x4> for f64x4
impl BitAndAssign<f64x4> for f64x4
sourcefn bitand_assign(&mut self, rhs: f64x4)
fn bitand_assign(&mut self, rhs: f64x4)
Performs the &=
operation. Read more
sourceimpl<'_> BitOrAssign<&'_ f64x4> for f64x4
impl<'_> BitOrAssign<&'_ f64x4> for f64x4
sourcefn bitor_assign(&mut self, rhs: &f64x4)
fn bitor_assign(&mut self, rhs: &f64x4)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<f64x4> for f64x4
impl BitOrAssign<f64x4> for f64x4
sourcefn bitor_assign(&mut self, rhs: f64x4)
fn bitor_assign(&mut self, rhs: f64x4)
Performs the |=
operation. Read more
sourceimpl<'_> BitXorAssign<&'_ f64x4> for f64x4
impl<'_> BitXorAssign<&'_ f64x4> for f64x4
sourcefn bitxor_assign(&mut self, rhs: &f64x4)
fn bitxor_assign(&mut self, rhs: &f64x4)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<f64x4> for f64x4
impl BitXorAssign<f64x4> for f64x4
sourcefn bitxor_assign(&mut self, rhs: f64x4)
fn bitxor_assign(&mut self, rhs: f64x4)
Performs the ^=
operation. Read more
sourceimpl<'_> DivAssign<&'_ f64x4> for f64x4
impl<'_> DivAssign<&'_ f64x4> for f64x4
sourcefn div_assign(&mut self, rhs: &f64x4)
fn div_assign(&mut self, rhs: &f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for f64x4
impl DivAssign<f64x4> for f64x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for DBivec2x4
impl DivAssign<f64x4> for DBivec2x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for DBivec3x4
impl DivAssign<f64x4> for DBivec3x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for DRotor2x4
impl DivAssign<f64x4> for DRotor2x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for DRotor3x4
impl DivAssign<f64x4> for DRotor3x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for DVec2x4
impl DivAssign<f64x4> for DVec2x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for DVec3x4
impl DivAssign<f64x4> for DVec3x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl DivAssign<f64x4> for DVec4x4
impl DivAssign<f64x4> for DVec4x4
sourcefn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
Performs the /=
operation. Read more
sourceimpl Lerp<f64x4> for f64x4
impl Lerp<f64x4> for f64x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec2x4
impl Lerp<f64x4> for DVec2x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec3x4
impl Lerp<f64x4> for DVec3x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec4x4
impl Lerp<f64x4> for DVec4x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec2x4
impl Lerp<f64x4> for DBivec2x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec3x4
impl Lerp<f64x4> for DBivec3x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DRotor2x4
impl Lerp<f64x4> for DRotor2x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DRotor3x4
impl Lerp<f64x4> for DRotor3x4
sourcefn lerp(&self, end: Self, t: f64x4) -> Self
fn lerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DSimilarity2x4
impl Mul<f64x4> for DSimilarity2x4
sourceimpl Mul<f64x4> for DSimilarity3x4
impl Mul<f64x4> for DSimilarity3x4
sourceimpl Mul<f64x4> for DIsometry2x4
impl Mul<f64x4> for DIsometry2x4
sourceimpl Mul<f64x4> for DIsometry3x4
impl Mul<f64x4> for DIsometry3x4
sourceimpl<'_> MulAssign<&'_ f64x4> for f64x4
impl<'_> MulAssign<&'_ f64x4> for f64x4
sourcefn mul_assign(&mut self, rhs: &f64x4)
fn mul_assign(&mut self, rhs: &f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for f64x4
impl MulAssign<f64x4> for f64x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for DBivec2x4
impl MulAssign<f64x4> for DBivec2x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for DBivec3x4
impl MulAssign<f64x4> for DBivec3x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for DRotor2x4
impl MulAssign<f64x4> for DRotor2x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for DRotor3x4
impl MulAssign<f64x4> for DRotor3x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for DVec2x4
impl MulAssign<f64x4> for DVec2x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for DVec3x4
impl MulAssign<f64x4> for DVec3x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl MulAssign<f64x4> for DVec4x4
impl MulAssign<f64x4> for DVec4x4
sourcefn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
Performs the *=
operation. Read more
sourceimpl Slerp<f64x4> for DRotor3x4
impl Slerp<f64x4> for DRotor3x4
sourcefn slerp(&self, end: Self, t: f64x4) -> Self
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec2x4
impl Slerp<f64x4> for DVec2x4
sourcefn slerp(&self, end: Self, t: f64x4) -> Self
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec3x4
impl Slerp<f64x4> for DVec3x4
sourcefn slerp(&self, end: Self, t: f64x4) -> Self
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DVec4x4
impl Slerp<f64x4> for DVec4x4
sourcefn slerp(&self, end: Self, t: f64x4) -> Self
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec2x4
impl Slerp<f64x4> for DBivec2x4
sourcefn slerp(&self, end: Self, t: f64x4) -> Self
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DBivec3x4
impl Slerp<f64x4> for DBivec3x4
sourcefn slerp(&self, end: Self, t: f64x4) -> Self
fn slerp(&self, end: Self, t: f64x4) -> 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<f64x4> for DRotor2x4
impl Slerp<f64x4> for DRotor2x4
sourcefn slerp(&self, end: Self, t: f64x4) -> Self
fn slerp(&self, end: Self, t: f64x4) -> 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<&'_ f64x4> for f64x4
impl<'_> SubAssign<&'_ f64x4> for f64x4
sourcefn sub_assign(&mut self, rhs: &f64x4)
fn sub_assign(&mut self, rhs: &f64x4)
Performs the -=
operation. Read more
sourceimpl SubAssign<f64x4> for f64x4
impl SubAssign<f64x4> for f64x4
sourcefn sub_assign(&mut self, rhs: f64x4)
fn sub_assign(&mut self, rhs: f64x4)
Performs the -=
operation. Read more
impl Copy for f64x4
impl Pod for f64x4
impl StructuralPartialEq for f64x4
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
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