Struct ultraviolet::f32x4

pub fn fast_max(self, rhs: f32x4) -> f32x4

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.

pub fn max(self, rhs: f32x4) -> f32x4

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.

pub fn fast_min(self, rhs: f32x4) -> f32x4

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.

pub fn min(self, rhs: f32x4) -> f32x4

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) -> f32x4

pub fn is_finite(self) -> f32x4

pub fn is_inf(self) -> f32x4

pub fn round(self) -> f32x4

pub fn fast_round_int(self) -> i32x4

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.

pub fn round_int(self) -> i32x4

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.

pub fn fast_trunc_int(self) -> i32x4

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.

pub fn trunc_int(self) -> i32x4

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: f32x4, a: f32x4) -> f32x4

pub fn mul_sub(self, m: f32x4, s: f32x4) -> f32x4

pub fn mul_neg_add(self, m: f32x4, a: f32x4) -> f32x4

pub fn mul_neg_sub(self, m: f32x4, a: f32x4) -> f32x4

pub fn flip_signs(self, signs: f32x4) -> f32x4

pub fn copysign(self, sign: f32x4) -> f32x4

pub fn asin_acos(self) -> (f32x4, f32x4)

pub fn asin(self) -> f32x4

pub fn acos(self) -> f32x4

pub fn atan(self) -> f32x4

pub fn atan2(self, x: f32x4) -> f32x4

pub fn sin_cos(self) -> (f32x4, f32x4)

pub fn sin(self) -> f32x4

pub fn cos(self) -> f32x4

pub fn tan(self) -> f32x4

pub fn to_degrees(self) -> f32x4

pub fn to_radians(self) -> f32x4

pub fn recip(self) -> f32x4

pub fn recip_sqrt(self) -> f32x4

pub fn sqrt(self) -> f32x4

pub fn move_mask(self) -> i32

pub fn any(self) -> bool

pub fn all(self) -> bool

pub fn none(self) -> bool

pub fn exp(self) -> f32x4

Calculate the exponent of a packed f32x4

pub fn sign_bit(self) -> f32x4

pub fn reduce_add(self) -> f32

pub fn ln(self) -> f32x4

Natural log (ln(x))

pub fn log2(self) -> f32x4

pub fn log10(self) -> f32x4

pub fn pow_f32x4(self, y: f32x4) -> f32x4

pub fn powf(self, y: f32) -> f32x4

pub fn to_array(self) -> [f32; 4]

pub fn as_array_ref(&self) -> &[f32; 4]

Trait Implementations§

impl Add<&f32x4> for f32x4

type Output = f32x4

The resulting type after applying the + operator.

fn add(self, rhs: &f32x4) -> <f32x4 as Add<&f32x4>>::Output

Performs the + operation. Read more

impl Add<f32> for f32x4

type Output = f32x4

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> <f32x4 as Add<f32>>::Output

Performs the + operation. Read more

impl Add<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the + operator.

fn add(self, rhs: f32x4) -> <f32x4 as Add<f32x4>>::Output

Performs the + operation. Read more

impl AddAssign<&f32x4> for f32x4

fn add_assign(&mut self, rhs: &f32x4)

Performs the += operation. Read more

impl AddAssign<f32x4> for f32x4

fn add_assign(&mut self, rhs: f32x4)

Performs the += operation. Read more

impl Binary for f32x4

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl BitAnd<&f32x4> for f32x4

type Output = f32x4

The resulting type after applying the & operator.

fn bitand(self, rhs: &f32x4) -> <f32x4 as BitAnd<&f32x4>>::Output

Performs the & operation. Read more

impl BitAnd<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the & operator.

fn bitand(self, rhs: f32x4) -> <f32x4 as BitAnd<f32x4>>::Output

Performs the & operation. Read more

impl BitAndAssign<&f32x4> for f32x4

fn bitand_assign(&mut self, rhs: &f32x4)

Performs the &= operation. Read more

impl BitAndAssign<f32x4> for f32x4

fn bitand_assign(&mut self, rhs: f32x4)

Performs the &= operation. Read more

impl BitOr<&f32x4> for f32x4

type Output = f32x4

The resulting type after applying the | operator.

fn bitor(self, rhs: &f32x4) -> <f32x4 as BitOr<&f32x4>>::Output

Performs the | operation. Read more

impl BitOr<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the | operator.

fn bitor(self, rhs: f32x4) -> <f32x4 as BitOr<f32x4>>::Output

Performs the | operation. Read more

impl BitOrAssign<&f32x4> for f32x4

fn bitor_assign(&mut self, rhs: &f32x4)

Performs the |= operation. Read more

impl BitOrAssign<f32x4> for f32x4

fn bitor_assign(&mut self, rhs: f32x4)

Performs the |= operation. Read more

impl BitXor<&f32x4> for f32x4

type Output = f32x4

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &f32x4) -> <f32x4 as BitXor<&f32x4>>::Output

Performs the ^ operation. Read more

impl BitXor<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: f32x4) -> <f32x4 as BitXor<f32x4>>::Output

Performs the ^ operation. Read more

impl BitXorAssign<&f32x4> for f32x4

fn bitxor_assign(&mut self, rhs: &f32x4)

Performs the ^= operation. Read more

impl BitXorAssign<f32x4> for f32x4

fn bitxor_assign(&mut self, rhs: f32x4)

Performs the ^= operation. Read more

impl Clone for f32x4

fn clone(&self) -> f32x4

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl Debug for f32x4

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

impl Default for f32x4

fn default() -> f32x4

Returns the “default value” for a type. Read more

impl Display for f32x4

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

impl Div<&f32x4> for f32x4

type Output = f32x4

The resulting type after applying the / operator.

fn div(self, rhs: &f32x4) -> <f32x4 as Div<&f32x4>>::Output

Performs the / operation. Read more

impl Div<f32> for f32x4

type Output = f32x4

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> <f32x4 as Div<f32>>::Output

Performs the / operation. Read more

impl Div<f32x4> for Bivec2x4

type Output = Bivec2x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Bivec2x4

Performs the / operation. Read more

impl Div<f32x4> for Bivec3x4

type Output = Bivec3x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Bivec3x4

Performs the / operation. Read more

impl Div<f32x4> for Rotor2x4

type Output = Rotor2x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Self

Performs the / operation. Read more

impl Div<f32x4> for Rotor3x4

type Output = Rotor3x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Self

Performs the / operation. Read more

impl Div<f32x4> for Vec2x4

type Output = Vec2x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Vec2x4

Performs the / operation. Read more

impl Div<f32x4> for Vec3x4

type Output = Vec3x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Vec3x4

Performs the / operation. Read more

impl Div<f32x4> for Vec4x4

type Output = Vec4x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> Vec4x4

Performs the / operation. Read more

impl Div<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the / operator.

fn div(self, rhs: f32x4) -> <f32x4 as Div<f32x4>>::Output

Performs the / operation. Read more

impl DivAssign<&f32x4> for f32x4

fn div_assign(&mut self, rhs: &f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for Bivec2x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for Bivec3x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for Rotor2x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for Rotor3x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for Vec2x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for Vec3x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for Vec4x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl DivAssign<f32x4> for f32x4

fn div_assign(&mut self, rhs: f32x4)

Performs the /= operation. Read more

impl From<&[f32]> for f32x4

fn from(src: &[f32]) -> f32x4

Converts to this type from the input type.

impl From<[f32; 4]> for f32x4

fn from(arr: [f32; 4]) -> f32x4

Converts to this type from the input type.

impl From<f32> for f32x4

fn from(elem: f32) -> f32x4

Splats the single value given across all lanes.

impl Lerp<f32x4> for Bivec2x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl Lerp<f32x4> for Bivec3x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl Lerp<f32x4> for Rotor2x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl Lerp<f32x4> for Rotor3x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl Lerp<f32x4> for Vec2x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl Lerp<f32x4> for Vec3x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl Lerp<f32x4> for Vec4x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl Lerp<f32x4> for f32x4

fn lerp(&self, end: Self, t: f32x4) -> 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 Rotors 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 Rotors to be of constant angular velocity. In this case, check out Slerp.

impl LowerExp for f32x4

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl LowerHex for f32x4

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Mul<&f32x4> for f32x4

type Output = f32x4

The resulting type after applying the * operator.

fn mul(self, rhs: &f32x4) -> <f32x4 as Mul<&f32x4>>::Output

Performs the * operation. Read more

impl Mul<Bivec2x4> for f32x4

type Output = Bivec2x4

The resulting type after applying the * operator.

fn mul(self, rhs: Bivec2x4) -> Bivec2x4

Performs the * operation. Read more

impl Mul<Bivec3x4> for f32x4

type Output = Bivec3x4

The resulting type after applying the * operator.

fn mul(self, rhs: Bivec3x4) -> Bivec3x4

Performs the * operation. Read more

impl Mul<Mat2x4> for f32x4

type Output = Mat2x4

The resulting type after applying the * operator.

fn mul(self, rhs: Mat2x4) -> Mat2x4

Performs the * operation. Read more

impl Mul<Mat3x4> for f32x4

type Output = Mat3x4

The resulting type after applying the * operator.

fn mul(self, rhs: Mat3x4) -> Mat3x4

Performs the * operation. Read more

impl Mul<Mat4x4> for f32x4

type Output = Mat4x4

The resulting type after applying the * operator.

fn mul(self, rhs: Mat4x4) -> Mat4x4

Performs the * operation. Read more

impl Mul<Rotor2x4> for f32x4

type Output = Rotor2x4

The resulting type after applying the * operator.

fn mul(self, rotor: Rotor2x4) -> Rotor2x4

Performs the * operation. Read more

impl Mul<Rotor3x4> for f32x4

type Output = Rotor3x4

The resulting type after applying the * operator.

fn mul(self, rotor: Rotor3x4) -> Rotor3x4

Performs the * operation. Read more

impl Mul<Vec2x4> for f32x4

type Output = Vec2x4

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2x4) -> Vec2x4

Performs the * operation. Read more

impl Mul<Vec3x4> for f32x4

type Output = Vec3x4

The resulting type after applying the * operator.

fn mul(self, rhs: Vec3x4) -> Vec3x4

Performs the * operation. Read more

impl Mul<Vec4x4> for f32x4

type Output = Vec4x4

The resulting type after applying the * operator.

fn mul(self, rhs: Vec4x4) -> Vec4x4

Performs the * operation. Read more

impl Mul<f32> for f32x4

type Output = f32x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> <f32x4 as Mul<f32>>::Output

Performs the * operation. Read more

impl Mul<f32x4> for Bivec2x4

type Output = Bivec2x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Self

Performs the * operation. Read more

impl Mul<f32x4> for Bivec3x4

type Output = Bivec3x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Self

Performs the * operation. Read more

impl Mul<f32x4> for Isometry2x4

type Output = Isometry2x4

The resulting type after applying the * operator.

fn mul(self, scalar: f32x4) -> Isometry2x4

Performs the * operation. Read more

impl Mul<f32x4> for Isometry3x4

type Output = Isometry3x4

The resulting type after applying the * operator.

fn mul(self, scalar: f32x4) -> Isometry3x4

Performs the * operation. Read more

impl Mul<f32x4> for Mat2x4

type Output = Mat2x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Mat2x4

Performs the * operation. Read more

impl Mul<f32x4> for Mat3x4

type Output = Mat3x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Mat3x4

Performs the * operation. Read more

impl Mul<f32x4> for Mat4x4

type Output = Mat4x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Mat4x4

Performs the * operation. Read more

impl Mul<f32x4> for Rotor2x4

type Output = Rotor2x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Self

Performs the * operation. Read more

impl Mul<f32x4> for Rotor3x4

type Output = Rotor3x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Self

Performs the * operation. Read more

impl Mul<f32x4> for Similarity2x4

type Output = Similarity2x4

The resulting type after applying the * operator.

fn mul(self, scalar: f32x4) -> Similarity2x4

Performs the * operation. Read more

impl Mul<f32x4> for Similarity3x4

type Output = Similarity3x4

The resulting type after applying the * operator.

fn mul(self, scalar: f32x4) -> Similarity3x4

Performs the * operation. Read more

impl Mul<f32x4> for Vec2x4

type Output = Vec2x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Vec2x4

Performs the * operation. Read more

impl Mul<f32x4> for Vec3x4

type Output = Vec3x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Vec3x4

Performs the * operation. Read more

impl Mul<f32x4> for Vec4x4

type Output = Vec4x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> Vec4x4

Performs the * operation. Read more

impl Mul<f32x4> for f32x4

type Output = f32x4

The resulting type after applying the * operator.

fn mul(self, rhs: f32x4) -> <f32x4 as Mul<f32x4>>::Output

Performs the * operation. Read more

impl MulAssign<&f32x4> for f32x4

fn mul_assign(&mut self, rhs: &f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for Bivec2x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for Bivec3x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for Rotor2x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for Rotor3x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for Vec2x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for Vec3x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for Vec4x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl MulAssign<f32x4> for f32x4

fn mul_assign(&mut self, rhs: f32x4)

Performs the *= operation. Read more

impl Neg for &f32x4

type Output = f32x4

The resulting type after applying the - operator.

fn neg(self) -> <&f32x4 as Neg>::Output

Performs the unary - operation. Read more

impl Neg for f32x4

type Output = f32x4

The resulting type after applying the - operator.

fn neg(self) -> <f32x4 as Neg>::Output

Performs the unary - operation. Read more

impl Not for &f32x4

type Output = f32x4

The resulting type after applying the ! operator.

fn not(self) -> <&f32x4 as Not>::Output

Performs the unary ! operation. Read more

impl Not for f32x4

type Output = f32x4

The resulting type after applying the ! operator.

fn not(self) -> <f32x4 as Not>::Output

Performs the unary ! operation. Read more

impl Octal for f32x4

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq<f32x4> for f32x4

fn eq(&self, other: &f32x4) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<RHS> Product<RHS> for f32x4where f32x4: MulAssign<RHS>,

fn product(iter: I) -> f32x4where I: Iterator<Item = RHS>,

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Slerp<f32x4> for Bivec2x4

fn slerp(&self, end: Self, t: f32x4) -> 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 Rotors, 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 Rotors, etc!

impl Slerp<f32x4> for Bivec3x4

fn slerp(&self, end: Self, t: f32x4) -> 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 Rotors, 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 Rotors, etc!

impl Slerp<f32x4> for Rotor2x4

fn slerp(&self, end: Self, t: f32x4) -> 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 Rotors, 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 Rotors, etc!

impl Slerp<f32x4> for Rotor3x4

fn slerp(&self, end: Self, t: f32x4) -> 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 Rotors, 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 Rotors, etc!

impl Slerp<f32x4> for Vec2x4

fn slerp(&self, end: Self, t: f32x4) -> 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 Rotors, 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 Rotors, etc!

impl Slerp<f32x4> for Vec3x4

fn slerp(&self, end: Self, t: f32x4) -> 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 Rotors, 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 Rotors, etc!

impl Slerp<f32x4> for Vec4x4

fn slerp(&self, end: Self, t: f32x4) -> 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 Rotors, 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 Rotors, etc!