Struct ultraviolet::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.

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.

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.

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 exp(self) -> f64x4

Calculate the exponent of a packed f64x4

pub fn reduce_add(self) -> f64

pub fn ln(self) -> f64x4

Natural log (ln(x))

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§

impl Add<&f64x4> for f64x4

type Output = f64x4

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<f64> for f64x4

type Output = f64x4

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl Add<f64x4> for f64x4

type Output = f64x4

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl AddAssign<&f64x4> for f64x4

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

Performs the += operation. Read more

impl AddAssign<f64x4> for f64x4

fn add_assign(&mut self, rhs: f64x4)

Performs the += operation. Read more

impl Binary for f64x4

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

Formats the value using the given formatter.

impl BitAnd<&f64x4> for f64x4

type Output = f64x4

The resulting type after applying the & operator.

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

Performs the & operation. Read more

impl BitAnd<f64x4> for f64x4

type Output = f64x4

The resulting type after applying the & operator.

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

Performs the & operation. Read more

impl BitAndAssign<&f64x4> for f64x4

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

Performs the &= operation. Read more

impl BitAndAssign<f64x4> for f64x4

fn bitand_assign(&mut self, rhs: f64x4)

Performs the &= operation. Read more

impl BitOr<&f64x4> for f64x4

type Output = f64x4

The resulting type after applying the | operator.

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

Performs the | operation. Read more

impl BitOr<f64x4> for f64x4

type Output = f64x4

The resulting type after applying the | operator.

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

Performs the | operation. Read more

impl BitOrAssign<&f64x4> for f64x4

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

Performs the |= operation. Read more

impl BitOrAssign<f64x4> for f64x4

fn bitor_assign(&mut self, rhs: f64x4)

Performs the |= operation. Read more

impl BitXor<&f64x4> for f64x4

type Output = f64x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation. Read more

impl BitXor<f64x4> for f64x4

type Output = f64x4

The resulting type after applying the ^ operator.

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

Performs the ^ operation. Read more

impl BitXorAssign<&f64x4> for f64x4

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

Performs the ^= operation. Read more

impl BitXorAssign<f64x4> for f64x4

fn bitxor_assign(&mut self, rhs: f64x4)

Performs the ^= operation. Read more

impl Clone for f64x4

fn clone(&self) -> f64x4

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 f64x4

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

Formats the value using the given formatter. Read more

impl Default for f64x4

fn default() -> f64x4

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

impl Display for f64x4

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

Formats the value using the given formatter. Read more

impl Div<&f64x4> for f64x4

type Output = f64x4

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f64> for f64x4

type Output = f64x4

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f64x4> for DBivec2x4

type Output = DBivec2x4

The resulting type after applying the / operator.

fn div(self, rhs: f64x4) -> DBivec2x4

Performs the / operation. Read more

impl Div<f64x4> for DBivec3x4

type Output = DBivec3x4

The resulting type after applying the / operator.

fn div(self, rhs: f64x4) -> DBivec3x4

Performs the / operation. Read more

impl Div<f64x4> for DRotor2x4

type Output = DRotor2x4

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f64x4> for DRotor3x4

type Output = DRotor3x4

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl Div<f64x4> for DVec2x4

type Output = DVec2x4

The resulting type after applying the / operator.

fn div(self, rhs: f64x4) -> DVec2x4

Performs the / operation. Read more

impl Div<f64x4> for DVec3x4

type Output = DVec3x4

The resulting type after applying the / operator.

fn div(self, rhs: f64x4) -> DVec3x4

Performs the / operation. Read more

impl Div<f64x4> for DVec4x4

type Output = DVec4x4

The resulting type after applying the / operator.

fn div(self, rhs: f64x4) -> DVec4x4

Performs the / operation. Read more

impl Div<f64x4> for f64x4

type Output = f64x4

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl DivAssign<&f64x4> for f64x4

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

Performs the /= operation. Read more

impl DivAssign<f64x4> for DBivec2x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl DivAssign<f64x4> for DBivec3x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl DivAssign<f64x4> for DRotor2x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl DivAssign<f64x4> for DRotor3x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl DivAssign<f64x4> for DVec2x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl DivAssign<f64x4> for DVec3x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl DivAssign<f64x4> for DVec4x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl DivAssign<f64x4> for f64x4

fn div_assign(&mut self, rhs: f64x4)

Performs the /= operation. Read more

impl From<&[f64]> for f64x4

fn from(src: &[f64]) -> f64x4

Converts to this type from the input type.

impl From<[f64; 4]> for f64x4

fn from(arr: [f64; 4]) -> f64x4

Converts to this type from the input type.

impl From<f64> for f64x4

fn from(elem: f64) -> f64x4

Splats the single value given across all lanes.

impl Lerp<f64x4> for DBivec2x4

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 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<f64x4> for DBivec3x4

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 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<f64x4> for DRotor2x4

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 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<f64x4> for DRotor3x4

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 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<f64x4> for DVec2x4

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 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<f64x4> for DVec3x4

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 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<f64x4> for DVec4x4

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 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<f64x4> for f64x4

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 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 f64x4

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

Formats the value using the given formatter.

impl LowerHex for f64x4

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

Formats the value using the given formatter.

impl Mul<&f64x4> for f64x4

type Output = f64x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DBivec2x4> for f64x4

type Output = DBivec2x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DBivec3x4> for f64x4

type Output = DBivec3x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DMat2x4> for f64x4

type Output = DMat2x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DMat3x4> for f64x4

type Output = DMat3x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DMat4x4> for f64x4

type Output = DMat4x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DRotor2x4> for f64x4

type Output = DRotor2x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DRotor3x4> for f64x4

type Output = DRotor3x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DVec2x4> for f64x4

type Output = DVec2x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DVec3x4> for f64x4

type Output = DVec3x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<DVec4x4> for f64x4

type Output = DVec4x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f64> for f64x4

type Output = f64x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f64x4> for DBivec2x4

type Output = DBivec2x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f64x4> for DBivec3x4

type Output = DBivec3x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f64x4> for DIsometry2x4

type Output = DIsometry2x4

The resulting type after applying the * operator.

fn mul(self, scalar: f64x4) -> DIsometry2x4

Performs the * operation. Read more

impl Mul<f64x4> for DIsometry3x4

type Output = DIsometry3x4

The resulting type after applying the * operator.

fn mul(self, scalar: f64x4) -> DIsometry3x4

Performs the * operation. Read more

impl Mul<f64x4> for DMat2x4

type Output = DMat2x4

The resulting type after applying the * operator.

fn mul(self, rhs: f64x4) -> DMat2x4

Performs the * operation. Read more

impl Mul<f64x4> for DMat3x4

type Output = DMat3x4

The resulting type after applying the * operator.

fn mul(self, rhs: f64x4) -> DMat3x4

Performs the * operation. Read more

impl Mul<f64x4> for DMat4x4

type Output = DMat4x4

The resulting type after applying the * operator.

fn mul(self, rhs: f64x4) -> DMat4x4

Performs the * operation. Read more

impl Mul<f64x4> for DRotor2x4

type Output = DRotor2x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f64x4> for DRotor3x4

type Output = DRotor3x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl Mul<f64x4> for DSimilarity2x4

type Output = DSimilarity2x4

The resulting type after applying the * operator.

fn mul(self, scalar: f64x4) -> DSimilarity2x4

Performs the * operation. Read more

impl Mul<f64x4> for DSimilarity3x4

type Output = DSimilarity3x4

The resulting type after applying the * operator.

fn mul(self, scalar: f64x4) -> DSimilarity3x4

Performs the * operation. Read more

impl Mul<f64x4> for DVec2x4

type Output = DVec2x4

The resulting type after applying the * operator.

fn mul(self, rhs: f64x4) -> DVec2x4

Performs the * operation. Read more

impl Mul<f64x4> for DVec3x4

type Output = DVec3x4

The resulting type after applying the * operator.

fn mul(self, rhs: f64x4) -> DVec3x4

Performs the * operation. Read more

impl Mul<f64x4> for DVec4x4

type Output = DVec4x4

The resulting type after applying the * operator.

fn mul(self, rhs: f64x4) -> DVec4x4

Performs the * operation. Read more

impl Mul<f64x4> for f64x4

type Output = f64x4

The resulting type after applying the * operator.

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

Performs the * operation. Read more

impl MulAssign<&f64x4> for f64x4

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

Performs the *= operation. Read more

impl MulAssign<f64x4> for DBivec2x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl MulAssign<f64x4> for DBivec3x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl MulAssign<f64x4> for DRotor2x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl MulAssign<f64x4> for DRotor3x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl MulAssign<f64x4> for DVec2x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl MulAssign<f64x4> for DVec3x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl MulAssign<f64x4> for DVec4x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl MulAssign<f64x4> for f64x4

fn mul_assign(&mut self, rhs: f64x4)

Performs the *= operation. Read more

impl Neg for &f64x4

type Output = f64x4

The resulting type after applying the - operator.

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

Performs the unary - operation. Read more

impl Neg for f64x4

type Output = f64x4

The resulting type after applying the - operator.

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

Performs the unary - operation. Read more

impl Not for f64x4

type Output = f64x4

The resulting type after applying the ! operator.

fn not(self) -> f64x4

Performs the unary ! operation. Read more

impl Octal for f64x4

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

Formats the value using the given formatter.

impl PartialEq<f64x4> for f64x4

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

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

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

impl Slerp<f64x4> for DBivec2x4

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 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<f64x4> for DBivec3x4

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 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<f64x4> for DRotor2x4

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 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<f64x4> for DRotor3x4

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 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<f64x4> for DVec2x4

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 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<f64x4> for DVec3x4

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 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<f64x4> for DVec4x4

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 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!