Struct ultraviolet::m64x4
source · #[repr(C, align(32))]pub struct m64x4 { /* private fields */ }
Implementations§
source§impl 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 = _
source§impl 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§
source§impl AddAssign<&f64x4> for f64x4
impl AddAssign<&f64x4> for f64x4
source§fn add_assign(&mut self, rhs: &f64x4)
fn add_assign(&mut self, rhs: &f64x4)
+=
operation. Read moresource§impl AddAssign<f64x4> for f64x4
impl AddAssign<f64x4> for f64x4
source§fn add_assign(&mut self, rhs: f64x4)
fn add_assign(&mut self, rhs: f64x4)
+=
operation. Read moresource§impl BitAndAssign<&f64x4> for f64x4
impl BitAndAssign<&f64x4> for f64x4
source§fn bitand_assign(&mut self, rhs: &f64x4)
fn bitand_assign(&mut self, rhs: &f64x4)
&=
operation. Read moresource§impl BitAndAssign<f64x4> for f64x4
impl BitAndAssign<f64x4> for f64x4
source§fn bitand_assign(&mut self, rhs: f64x4)
fn bitand_assign(&mut self, rhs: f64x4)
&=
operation. Read moresource§impl BitOrAssign<&f64x4> for f64x4
impl BitOrAssign<&f64x4> for f64x4
source§fn bitor_assign(&mut self, rhs: &f64x4)
fn bitor_assign(&mut self, rhs: &f64x4)
|=
operation. Read moresource§impl BitOrAssign<f64x4> for f64x4
impl BitOrAssign<f64x4> for f64x4
source§fn bitor_assign(&mut self, rhs: f64x4)
fn bitor_assign(&mut self, rhs: f64x4)
|=
operation. Read moresource§impl BitXorAssign<&f64x4> for f64x4
impl BitXorAssign<&f64x4> for f64x4
source§fn bitxor_assign(&mut self, rhs: &f64x4)
fn bitxor_assign(&mut self, rhs: &f64x4)
^=
operation. Read moresource§impl BitXorAssign<f64x4> for f64x4
impl BitXorAssign<f64x4> for f64x4
source§fn bitxor_assign(&mut self, rhs: f64x4)
fn bitxor_assign(&mut self, rhs: f64x4)
^=
operation. Read moresource§impl DivAssign<&f64x4> for f64x4
impl DivAssign<&f64x4> for f64x4
source§fn div_assign(&mut self, rhs: &f64x4)
fn div_assign(&mut self, rhs: &f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for DBivec2x4
impl DivAssign<f64x4> for DBivec2x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for DBivec3x4
impl DivAssign<f64x4> for DBivec3x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for DRotor2x4
impl DivAssign<f64x4> for DRotor2x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for DRotor3x4
impl DivAssign<f64x4> for DRotor3x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for DVec2x4
impl DivAssign<f64x4> for DVec2x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for DVec3x4
impl DivAssign<f64x4> for DVec3x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for DVec4x4
impl DivAssign<f64x4> for DVec4x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl DivAssign<f64x4> for f64x4
impl DivAssign<f64x4> for f64x4
source§fn div_assign(&mut self, rhs: f64x4)
fn div_assign(&mut self, rhs: f64x4)
/=
operation. Read moresource§impl Lerp<f64x4> for DBivec2x4
impl Lerp<f64x4> for DBivec2x4
source§fn 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
.
source§impl Lerp<f64x4> for DBivec3x4
impl Lerp<f64x4> for DBivec3x4
source§fn 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
.
source§impl Lerp<f64x4> for DRotor2x4
impl Lerp<f64x4> for DRotor2x4
source§fn 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
.
source§impl Lerp<f64x4> for DRotor3x4
impl Lerp<f64x4> for DRotor3x4
source§fn 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
.
source§impl Lerp<f64x4> for DVec2x4
impl Lerp<f64x4> for DVec2x4
source§fn 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
.
source§impl Lerp<f64x4> for DVec3x4
impl Lerp<f64x4> for DVec3x4
source§fn 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
.
source§impl Lerp<f64x4> for DVec4x4
impl Lerp<f64x4> for DVec4x4
source§fn 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
.
source§impl Lerp<f64x4> for f64x4
impl Lerp<f64x4> for f64x4
source§fn 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
.
source§impl Mul<f64x4> for DIsometry2x4
impl Mul<f64x4> for DIsometry2x4
§type Output = DIsometry2x4
type Output = DIsometry2x4
*
operator.source§impl Mul<f64x4> for DIsometry3x4
impl Mul<f64x4> for DIsometry3x4
§type Output = DIsometry3x4
type Output = DIsometry3x4
*
operator.source§impl Mul<f64x4> for DSimilarity2x4
impl Mul<f64x4> for DSimilarity2x4
§type Output = DSimilarity2x4
type Output = DSimilarity2x4
*
operator.source§impl Mul<f64x4> for DSimilarity3x4
impl Mul<f64x4> for DSimilarity3x4
§type Output = DSimilarity3x4
type Output = DSimilarity3x4
*
operator.source§impl MulAssign<&f64x4> for f64x4
impl MulAssign<&f64x4> for f64x4
source§fn mul_assign(&mut self, rhs: &f64x4)
fn mul_assign(&mut self, rhs: &f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for DBivec2x4
impl MulAssign<f64x4> for DBivec2x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for DBivec3x4
impl MulAssign<f64x4> for DBivec3x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for DRotor2x4
impl MulAssign<f64x4> for DRotor2x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for DRotor3x4
impl MulAssign<f64x4> for DRotor3x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for DVec2x4
impl MulAssign<f64x4> for DVec2x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for DVec3x4
impl MulAssign<f64x4> for DVec3x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for DVec4x4
impl MulAssign<f64x4> for DVec4x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl MulAssign<f64x4> for f64x4
impl MulAssign<f64x4> for f64x4
source§fn mul_assign(&mut self, rhs: f64x4)
fn mul_assign(&mut self, rhs: f64x4)
*=
operation. Read moresource§impl PartialEq<f64x4> for f64x4
impl PartialEq<f64x4> for f64x4
source§impl Slerp<f64x4> for DBivec2x4
impl Slerp<f64x4> for DBivec2x4
source§fn 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!
source§impl Slerp<f64x4> for DBivec3x4
impl Slerp<f64x4> for DBivec3x4
source§fn 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!
source§impl Slerp<f64x4> for DRotor2x4
impl Slerp<f64x4> for DRotor2x4
source§fn 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!
source§impl Slerp<f64x4> for DRotor3x4
impl Slerp<f64x4> for DRotor3x4
source§fn 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!
source§impl Slerp<f64x4> for DVec2x4
impl Slerp<f64x4> for DVec2x4
source§fn 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!
source§impl Slerp<f64x4> for DVec3x4
impl Slerp<f64x4> for DVec3x4
source§fn 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!
source§impl Slerp<f64x4> for DVec4x4
impl Slerp<f64x4> for DVec4x4
source§fn 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!
source§impl SubAssign<&f64x4> for f64x4
impl SubAssign<&f64x4> for f64x4
source§fn sub_assign(&mut self, rhs: &f64x4)
fn sub_assign(&mut self, rhs: &f64x4)
-=
operation. Read moresource§impl SubAssign<f64x4> for f64x4
impl SubAssign<f64x4> for f64x4
source§fn sub_assign(&mut self, rhs: f64x4)
fn sub_assign(&mut self, rhs: f64x4)
-=
operation. Read moreimpl 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§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CheckedBitPattern for Twhere
T: AnyBitPattern,
impl<T> CheckedBitPattern for Twhere T: AnyBitPattern,
§type Bits = T
type Bits = T
Self
must have the same layout as the specified Bits
except for
the possible invalid bit patterns being checked during
is_valid_bit_pattern
.source§fn is_valid_bit_pattern(_bits: &T) -> bool
fn is_valid_bit_pattern(_bits: &T) -> bool
bits
as &Self
.