Struct NormalizedQuat 

pub struct NormalizedQuat<L, T>(/* private fields */)
where
    L: Layout,
    T: Transform;

A quaternion witnessed to have unit norm at construction time.

Witnesses are invalidated silently by arithmetic on the inner data, so this type exposes no mutable accessor — all transformations that could denormalize go through re-normalizing constructors.

Implementations

impl<L, T> NormalizedQuat<L, T>

where L: Layout, T: Transform,

pub const DEFAULT_TOLERANCE: f64 = 1e-12

Default tolerance: norm must lie within 1 ± 1e-12.

pub fn new(q: Quat<L, T>) -> Result<NormalizedQuat<L, T>, NotNormalized>

Wrap a quaternion iff its norm is within Self::DEFAULT_TOLERANCE of 1.

pub fn new_with_tolerance( q: Quat<L, T>, tolerance: f64, ) -> Result<NormalizedQuat<L, T>, NotNormalized>

Wrap a quaternion iff its norm is within the given tolerance of 1.

pub fn renormalize(q: Quat<L, T>) -> Option<NormalizedQuat<L, T>>

Renormalize an arbitrary quaternion into this witness.

Returns None if the norm is not finite and strictly positive — i.e. the input is all zeros, contains any NaN, or has components so large that ‖q‖ overflows to infinity. All three cases would otherwise produce a non-unit witness.

pub const fn inner(self) -> Quat<L, T>

Read-only view of the underlying quaternion.

impl NormalizedQuat<ScalarFirst, LeftTransform>

pub fn left_quat_to_transformation(&self) -> DMat3

Build the 3x3 rotation (transformation) matrix from a witnessed unit-norm left quaternion.

Preferred over JeodQuat::left_quat_to_transformation because the witness proves the unit-norm precondition at the type level.

pub fn left_quat_transform(&self, v: DVec3) -> DVec3

Transform a vector using a witnessed unit-norm left quaternion.

Trait Implementations

impl<L, T> Clone for NormalizedQuat<L, T>

where L: Clone + Layout, T: Clone + Transform,

fn clone(&self) -> NormalizedQuat<L, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L, T> Debug for NormalizedQuat<L, T>

where L: Debug + Layout, T: Debug + Transform,

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

Formats the value using the given formatter.

impl<L, T> PartialEq for NormalizedQuat<L, T>

where L: PartialEq + Layout, T: PartialEq + Transform,

fn eq(&self, other: &NormalizedQuat<L, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<L, T> Copy for NormalizedQuat<L, T>

where L: Copy + Layout, T: Copy + Transform,

impl<L, T> RequiresNormalizedQuat for NormalizedQuat<L, T>

where L: Layout, T: Transform,

impl<L, T> StructuralPartialEq for NormalizedQuat<L, T>

where L: Layout, T: Transform,