1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
// Copyright (C) 2026 Jorge Andre Castro
//
// Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier
// selon les termes de la Licence Publique Générale GNU telle que publiée par la
// Free Software Foundation, soit la version 2 de la licence, soit (à votre convention)
// n'importe quelle version ultérieure.
//! # embedded-matrix
//!
//! Matrices 2×2 et 3×3 en `f32` pour systèmes embarqués `no_std`.
//!
//! Sans dépendance, sans `unsafe`, sans allocation.
//!
//! ```rust
//! use embedded_matrix::{Matrix2x2, Matrix3x3, MatrixError};
//!
//! // Produit matriciel avec l'opérateur *
//! let a = Matrix3x3::new([
//! [1.0, 2.0, 3.0],
//! [4.0, 5.0, 6.0],
//! [7.0, 8.0, 9.0],
//! ]);
//! let b = Matrix3x3::identity();
//! assert_eq!(a * b, a);
//!
//! // Addition, soustraction, scalaire
//! assert_eq!((a + b) - b, a);
//! let _double = a * 2.0;
//!
//! // Matrice × vecteur
//! let v = Matrix2x2::identity() * [1.0, 2.0];
//! assert_eq!(v, [1.0, 2.0]);
//!
//! // Inversion (Err si singulière ou non finie)
//! match Matrix2x2::new([[2.0, 0.0], [0.0, 4.0]]).inv() {
//! Ok(inv) => assert_eq!(inv, Matrix2x2::new([[0.5, 0.0], [0.0, 0.25]])),
//! Err(MatrixError::SingularMatrix) => { /* gérer */ }
//! Err(e) => panic!("{e}"),
//! }
//! ```
//!
//! ## Résolution de systèmes
//!
//! `solve(b)` résout `A·x = b` et renvoie directement `x` :
//!
//! ```rust
//! use embedded_matrix::Matrix2x2;
//!
//! let a = Matrix2x2::new([[2.0, 1.0], [1.0, 3.0]]);
//! let x = a.solve([3.0, 5.0]).unwrap(); // x = [0.8, 1.4]
//! assert!((x[0] - 0.8).abs() < 1e-6);
//! ```
//!
//! ## Feature optionnelle : `trig`
//!
//! ```toml
//! embedded-matrix = { version = "0.3", features = ["trig"] }
//! ```
//!
//! Active la dépendance à `embedded-trig-f32` et ajoute les constructeurs de
//! rotation : `Matrix2x2::rotation(angle)`, `Matrix3x3::rotation_x / _y / _z(angle)`
//! (angles en radians, règle de la main droite). Sans la feature, la crate
//! n'a **aucune dépendance**.
//!
//! ## Pistes futures (non implémentées)
//!
//! Ces idées ne font pas partie de l'API actuelle ; elles sont notées ici
//! pour la suite :
//!
//! - **Taille quelconque** : `Matrix<const R: usize, const C: usize>` sur la
//! pile (alias `Matrix2x2 = Matrix<2, 2>`), produit de matrices non carrées.
//! - **Décomposition LU** avec pivot partiel pour `det`, `inv` et `solve`
//! en taille n.
//! - **Cholesky** pour les matrices symétriques définies positives
//! (matrices de covariance).
//! - **Type `Vector<N>`** : produit scalaire, produit vectoriel 3D, norme.
//! - **`#[must_use]`** sur les opérations arithmétiques.
//! - **Benchmarks en cycles** (compteur DWT) et CI de compilation embarquée.
//!
//! ## Détection des matrices singulières
//!
//! `inv` compare `|det|` à une borne **relative** à la taille des termes du
//! déterminant (et non à une constante absolue) : une matrice `1e-4 · I`
//! reste inversible, alors qu'une matrice de grands coefficients dont le
//! déterminant n'est que du bruit d'arrondi est correctement rejetée.
pub use MatrixError;
pub use Matrix2x2;
pub use Matrix3x3;
/// Seuil relatif : `|det| <= SINGULAR_REL * borne` ⇒ matrice singulière.
/// `borne` est la somme des valeurs absolues des termes du déterminant.
const SINGULAR_REL: f32 = 8.0 * f32EPSILON;
/// Valide un déterminant avant inversion.
///
/// `bound` : somme des valeurs absolues des termes qui composent `det`
/// (échelle de l'erreur d'arrondi attendue sur `det`).
pub