Struct ultraviolet::m32x8

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

Calculates the lanewise maximum of both vectors. This is a faster implementation than max, but it doesn’t specify any behavior if NaNs are involved.

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

Calculates the lanewise maximum of both vectors. This doesn’t match IEEE-754 and instead is defined as self < rhs ? rhs : self.

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

Calculates the lanewise minimum of both vectors. This is a faster implementation than min, but it doesn’t specify any behavior if NaNs are involved.

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

Calculates the lanewise minimum of both vectors. If either lane is NaN, the other lane gets chosen. Use fast_min for a faster implementation that doesn’t handle NaNs.

pub fn is_nan(self) -> f32x8

pub fn is_finite(self) -> f32x8

pub fn is_inf(self) -> f32x8

pub fn round(self) -> f32x8

pub fn fast_round_int(self) -> i32x8

Rounds each lane into an integer. This is a faster implementation than round_int, but it doesn’t handle out of range values or NaNs. For those values you get implementation defined behavior.

pub fn round_int(self) -> i32x8

Rounds each lane into an integer. This saturates out of range values and turns NaNs into 0. Use fast_round_int for a faster implementation that doesn’t handle out of range values or NaNs.

pub fn fast_trunc_int(self) -> i32x8

Truncates each lane into an integer. This is a faster implementation than trunc_int, but it doesn’t handle out of range values or NaNs. For those values you get implementation defined behavior.

pub fn trunc_int(self) -> i32x8

Truncates each lane into an integer. This saturates out of range values and turns NaNs into 0. Use fast_trunc_int for a faster implementation that doesn’t handle out of range values or NaNs.

pub fn mul_add(self, m: f32x8, a: f32x8) -> f32x8

pub fn mul_sub(self, m: f32x8, a: f32x8) -> f32x8

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

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

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

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

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

pub fn asin(self) -> f32x8

pub fn acos(self) -> f32x8

pub fn atan(self) -> f32x8

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

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

pub fn sin(self) -> f32x8

pub fn cos(self) -> f32x8

pub fn tan(self) -> f32x8

pub fn to_degrees(self) -> f32x8

pub fn to_radians(self) -> f32x8

pub fn recip(self) -> f32x8

pub fn recip_sqrt(self) -> f32x8

pub fn sqrt(self) -> f32x8

pub fn move_mask(self) -> i32

pub fn any(self) -> bool

pub fn all(self) -> bool

pub fn none(self) -> bool

pub fn exp(self) -> f32x8

Calculate the exponent of a packed f32x8

pub fn sign_bit(self) -> f32x8

pub fn reduce_add(self) -> f32

pub fn ln(self) -> f32x8

Natural log (ln(x))

pub fn log2(self) -> f32x8

pub fn log10(self) -> f32x8

pub fn pow_f32x8(self, y: f32x8) -> f32x8

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

pub fn transpose(data: [f32x8; 8]) -> [f32x8; 8]

Transpose matrix of 8x8 f32 matrix. Currently only accelerated on AVX.

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

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

Trait Implementations§

impl Add<&f32x8> for f32x8

type Output = f32x8

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<f32> for f32x8

type Output = f32x8

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl AddAssign<&f32x8> for f32x8

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

Performs the += operation. Read more

impl AddAssign<f32x8> for f32x8

fn add_assign(&mut self, rhs: f32x8)

Performs the += operation. Read more

impl Binary for f32x8

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

Formats the value using the given formatter.

impl BitAnd<&f32x8> for f32x8

type Output = f32x8

The resulting type after applying the & operator.

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

Performs the & operation. Read more

impl BitAnd<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the & operator.

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

Performs the & operation. Read more

impl BitAndAssign<&f32x8> for f32x8

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

Performs the &= operation. Read more

impl BitAndAssign<f32x8> for f32x8

fn bitand_assign(&mut self, rhs: f32x8)

Performs the &= operation. Read more

impl BitOr<&f32x8> for f32x8

type Output = f32x8

The resulting type after applying the | operator.

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

Performs the | operation. Read more

impl BitOr<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the | operator.

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

Performs the | operation. Read more

impl BitOrAssign<&f32x8> for f32x8

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

Performs the |= operation. Read more

impl BitOrAssign<f32x8> for f32x8

fn bitor_assign(&mut self, rhs: f32x8)

Performs the |= operation. Read more

impl BitXor<&f32x8> for f32x8

type Output = f32x8

The resulting type after applying the ^ operator.

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

Performs the ^ operation. Read more

impl BitXor<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the ^ operator.

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

Performs the ^ operation. Read more

impl BitXorAssign<&f32x8> for f32x8

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

Performs the ^= operation. Read more

impl BitXorAssign<f32x8> for f32x8

fn bitxor_assign(&mut self, rhs: f32x8)

Performs the ^= operation. Read more

impl Clone for f32x8

fn clone(&self) -> f32x8

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 f32x8

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

Formats the value using the given formatter. Read more

impl Default for f32x8

fn default() -> f32x8

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

impl Display for f32x8

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

Formats the value using the given formatter. Read more

impl Div<&f32x8> for f32x8

type Output = f32x8

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f32> for f32x8

type Output = f32x8

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f32x8> for Bivec2x8

type Output = Bivec2x8

The resulting type after applying the / operator.

fn div(self, rhs: f32x8) -> Bivec2x8

Performs the / operation. Read more

impl Div<f32x8> for Bivec3x8

type Output = Bivec3x8

The resulting type after applying the / operator.

fn div(self, rhs: f32x8) -> Bivec3x8

Performs the / operation. Read more

impl Div<f32x8> for Rotor2x8

type Output = Rotor2x8

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f32x8> for Rotor3x8

type Output = Rotor3x8

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f32x8> for Vec2x8

type Output = Vec2x8

The resulting type after applying the / operator.

fn div(self, rhs: f32x8) -> Vec2x8

Performs the / operation. Read more

impl Div<f32x8> for Vec3x8

type Output = Vec3x8

The resulting type after applying the / operator.

fn div(self, rhs: f32x8) -> Vec3x8

Performs the / operation. Read more

impl Div<f32x8> for Vec4x8

type Output = Vec4x8

The resulting type after applying the / operator.

fn div(self, rhs: f32x8) -> Vec4x8

Performs the / operation. Read more

impl Div<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl DivAssign<&f32x8> for f32x8

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

Performs the /= operation. Read more

impl DivAssign<f32x8> for Bivec2x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl DivAssign<f32x8> for Bivec3x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl DivAssign<f32x8> for Rotor2x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl DivAssign<f32x8> for Rotor3x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl DivAssign<f32x8> for Vec2x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl DivAssign<f32x8> for Vec3x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl DivAssign<f32x8> for Vec4x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl DivAssign<f32x8> for f32x8

fn div_assign(&mut self, rhs: f32x8)

Performs the /= operation. Read more

impl From<&[f32]> for f32x8

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

Converts to this type from the input type.

impl From<[f32; 8]> for f32x8

fn from(arr: [f32; 8]) -> f32x8

Converts to this type from the input type.

impl From<f32> for f32x8

fn from(elem: f32) -> f32x8

Splats the single value given across all lanes.

impl Lerp<f32x8> for Bivec2x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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<f32x8> for Bivec3x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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<f32x8> for Rotor2x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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<f32x8> for Rotor3x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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<f32x8> for Vec2x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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<f32x8> for Vec3x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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<f32x8> for Vec4x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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<f32x8> for f32x8

fn lerp(&self, end: Self, t: f32x8) -> Self

Linearly interpolate between self and end by t between 0.0 and 1.0. i.e. (1.0 - t) * self + (t) * end.

For interpolating 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 f32x8

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

Formats the value using the given formatter.

impl LowerHex for f32x8

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

Formats the value using the given formatter.

impl Mul<&f32x8> for f32x8

type Output = f32x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Bivec2x8> for f32x8

type Output = Bivec2x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Bivec3x8> for f32x8

type Output = Bivec3x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Mat2x8> for f32x8

type Output = Mat2x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Mat3x8> for f32x8

type Output = Mat3x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Mat4x8> for f32x8

type Output = Mat4x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Rotor2x8> for f32x8

type Output = Rotor2x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Rotor3x8> for f32x8

type Output = Rotor3x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Vec2x8> for f32x8

type Output = Vec2x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Vec3x8> for f32x8

type Output = Vec3x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<Vec4x8> for f32x8

type Output = Vec4x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f32> for f32x8

type Output = f32x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f32x8> for Bivec2x8

type Output = Bivec2x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f32x8> for Bivec3x8

type Output = Bivec3x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f32x8> for Isometry2x8

type Output = Isometry2x8

The resulting type after applying the * operator.

fn mul(self, scalar: f32x8) -> Isometry2x8

Performs the * operation. Read more

impl Mul<f32x8> for Isometry3x8

type Output = Isometry3x8

The resulting type after applying the * operator.

fn mul(self, scalar: f32x8) -> Isometry3x8

Performs the * operation. Read more

impl Mul<f32x8> for Mat2x8

type Output = Mat2x8

The resulting type after applying the * operator.

fn mul(self, rhs: f32x8) -> Mat2x8

Performs the * operation. Read more

impl Mul<f32x8> for Mat3x8

type Output = Mat3x8

The resulting type after applying the * operator.

fn mul(self, rhs: f32x8) -> Mat3x8

Performs the * operation. Read more

impl Mul<f32x8> for Mat4x8

type Output = Mat4x8

The resulting type after applying the * operator.

fn mul(self, rhs: f32x8) -> Mat4x8

Performs the * operation. Read more

impl Mul<f32x8> for Rotor2x8

type Output = Rotor2x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f32x8> for Rotor3x8

type Output = Rotor3x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f32x8> for Similarity2x8

type Output = Similarity2x8

The resulting type after applying the * operator.

fn mul(self, scalar: f32x8) -> Similarity2x8

Performs the * operation. Read more

impl Mul<f32x8> for Similarity3x8

type Output = Similarity3x8

The resulting type after applying the * operator.

fn mul(self, scalar: f32x8) -> Similarity3x8

Performs the * operation. Read more

impl Mul<f32x8> for Vec2x8

type Output = Vec2x8

The resulting type after applying the * operator.

fn mul(self, rhs: f32x8) -> Vec2x8

Performs the * operation. Read more

impl Mul<f32x8> for Vec3x8

type Output = Vec3x8

The resulting type after applying the * operator.

fn mul(self, rhs: f32x8) -> Vec3x8

Performs the * operation. Read more

impl Mul<f32x8> for Vec4x8

type Output = Vec4x8

The resulting type after applying the * operator.

fn mul(self, rhs: f32x8) -> Vec4x8

Performs the * operation. Read more

impl Mul<f32x8> for f32x8

type Output = f32x8

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl MulAssign<&f32x8> for f32x8

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

Performs the *= operation. Read more

impl MulAssign<f32x8> for Bivec2x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl MulAssign<f32x8> for Bivec3x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl MulAssign<f32x8> for Rotor2x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl MulAssign<f32x8> for Rotor3x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl MulAssign<f32x8> for Vec2x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl MulAssign<f32x8> for Vec3x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl MulAssign<f32x8> for Vec4x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl MulAssign<f32x8> for f32x8

fn mul_assign(&mut self, rhs: f32x8)

Performs the *= operation. Read more

impl Neg for &f32x8

type Output = f32x8

The resulting type after applying the - operator.

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

Performs the unary - operation. Read more

impl Neg for f32x8

type Output = f32x8

The resulting type after applying the - operator.

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

Performs the unary - operation. Read more

impl Not for f32x8

type Output = f32x8

The resulting type after applying the ! operator.

fn not(self) -> f32x8

Performs the unary ! operation. Read more

impl Octal for f32x8

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

Formats the value using the given formatter.

impl PartialEq<f32x8> for f32x8

fn eq(&self, other: &f32x8) -> 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 f32x8where f32x8: MulAssign<RHS>,

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

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

impl Slerp<f32x8> for Bivec2x8

fn slerp(&self, end: Self, t: f32x8) -> Self

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for 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<f32x8> for Bivec3x8

fn slerp(&self, end: Self, t: f32x8) -> Self

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for 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<f32x8> for Rotor2x8

fn slerp(&self, end: Self, t: f32x8) -> Self

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for 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<f32x8> for Rotor3x8

fn slerp(&self, end: Self, t: f32x8) -> Self

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for 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<f32x8> for Vec2x8

fn slerp(&self, end: Self, t: f32x8) -> Self

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for 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<f32x8> for Vec3x8

fn slerp(&self, end: Self, t: f32x8) -> Self

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for 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<f32x8> for Vec4x8

fn slerp(&self, end: Self, t: f32x8) -> Self

Spherical-linear interpolation between self and end based on t from 0.0 to 1.0.

self and end should both be normalized or something bad will happen!

The implementation for SIMD types also requires that the two things being interpolated between are not exactly aligned, or else the result is undefined.

Basically, interpolation that maintains a constant angular velocity from one orientation on a unit hypersphere to another. This is sorta the “high quality” interpolation for 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!