Struct Rotation 

pub struct Rotation { /* private fields */ }

Représente une rotation dans l’espace 3D (Groupe SO(3)).

Stocke un quaternion unitaire q = [w, x, y, z] où :

• w = cos(θ/2)
• (x, y, z) = sin(θ/2) · û avec û l’axe de rotation unitaire

L’invariant w² + x² + y² + z² = 1 est garanti à la construction et maintenu après chaque composition via re-normalisation automatique.

Implementations

impl Rotation

pub const IDENTITY: Self

Identité : aucune rotation (quaternion [1, 0, 0, 0]).

pub fn new(w: f32, x: f32, y: f32, z: f32) -> Result<Self, So3Error>

Crée une rotation à partir d’un quaternion brut [w, x, y, z].

Les composants sont normalisés automatiquement.

Erreurs

• So3Error::NonFiniteValue si l’un des composants est NaN ou infini.
• So3Error::InvalidNorm si la norme est nulle (vecteur nul).

Exemple

use embedded_so3_f32::Rotation;
// 90° autour de Z  (w = cos 45°, z = sin 45°)
let s = core::f32::consts::FRAC_1_SQRT_2;
let rot = Rotation::new(s, 0.0, 0.0, s).unwrap();

pub fn compose(&self, other: &Rotation) -> Result<Self, So3Error>

Compose deux rotations : R_new = self ∘ other.

Équivalent à self * other via l’implémentation de Mul.

Applique une re-normalisation automatique pour contenir la dérive numérique inhérente à l’arithmétique f32 sur SO(3).

Erreurs

Retourne So3Error::InvalidNorm ou So3Error::NonFiniteValue si le résultat est dégénéré (cas extrêmement rare avec des entrées valides).

pub fn rotate_vector(&self, v: [f32; 3]) -> [f32; 3]

Applique la rotation à un vecteur [x, y, z].

Utilise la formule optimisée de Rodrigues pour quaternions : v' = v + 2w·(q⃗ × v) + 2·(q⃗ × (q⃗ × v))

Cette forme évite le produit p·q·p⁻¹ naïf (28 multiplications) et ne nécessite que 15 multiplications.

pub fn inverse(&self) -> Self

Retourne la rotation inverse.

Pour un quaternion unitaire, l’inverse est le conjugué : q⁻¹ = [w, -x, -y, -z].

Aucune normalisation n’est nécessaire car le conjugué d’un quaternion unitaire est déjà unitaire.

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

Retourne les composants bruts sous la forme [w, x, y, z].

Trait Implementations

impl Clone for Rotation

fn clone(&self) -> Rotation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rotation

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

Formats the value using the given formatter.

impl Mul for &Rotation

Opérateur * par référence pour éviter la copie inutile.

type Output = Result<Rotation, So3Error>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Rotation

Opérateur * pour composer deux rotations.

Équivalent à Rotation::compose.

Exemple

use embedded_so3_f32::Rotation;
let s = core::f32::consts::FRAC_1_SQRT_2;
let r = Rotation::new(s, s, 0.0, 0.0).unwrap(); // 90° autour de X
let r180 = (r * r).unwrap();                      // 180° autour de X

type Output = Result<Rotation, So3Error>

The resulting type after applying the * operator.

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

Performs the * operation.

impl PartialEq for Rotation

fn eq(&self, other: &Rotation) -> 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 Copy for Rotation

impl StructuralPartialEq for Rotation