flight_solver/lib.rs
1//! Real-time solvers for flight controllers.
2//!
3//! `flight-solver` provides `no_std`, fully stack-allocated solvers designed
4//! for real-time system identification and control allocation on embedded
5//! targets. All dimensions are const-generic for
6//! zero-overhead monomorphization.
7//!
8//! # Solvers
9//!
10//! | Module | Algorithm | Use case |
11//! |--------|-----------|----------|
12//! | [`rls`] | Recursive Least Squares | Online parameter estimation |
13//! | [`cls`] | Constrained Least Squares | Box-constrained allocation |
14//!
15//! # Example: RLS online parameter estimation
16//!
17//! ```no_run
18//! use flight_solver::rls::{RlsParallel, CovarianceGuards};
19//!
20//! let mut rls = RlsParallel::<4, 3>::new(1e2, 0.995, CovarianceGuards::default());
21//!
22//! let a = nalgebra::SVector::<f32, 4>::new(0.1, -0.2, 0.3, 0.05);
23//! let y = nalgebra::SVector::<f32, 3>::new(0.5, -0.3, 0.1);
24//! rls.update(&a, &y);
25//!
26//! let estimate = rls.params(); // 4×3 parameter matrix
27//! ```
28//!
29//! # Example: WLS constrained allocation
30//!
31//! ```no_run
32//! use flight_solver::cls::{solve, ExitCode, Mat, VecN};
33//! use flight_solver::cls::setup::wls::{setup_a, setup_b};
34//!
35//! let g: Mat<6, 4> = Mat::zeros(); // effectiveness matrix
36//! let wv = VecN::<6>::from_column_slice(&[10.0, 10.0, 10.0, 1.0, 0.5, 0.5]);
37//! let mut wu = VecN::<4>::from_column_slice(&[1.0; 4]);
38//!
39//! let (a, gamma) = setup_a::<4, 6, 10>(&g, &wv, &mut wu, 2e-9, 4e5);
40//! let v = VecN::<6>::zeros();
41//! let ud = VecN::<4>::from_column_slice(&[0.5; 4]);
42//! let b = setup_b::<4, 6, 10>(&v, &ud, &wv, &wu, gamma);
43//!
44//! let umin = VecN::<4>::from_column_slice(&[0.0; 4]);
45//! let umax = VecN::<4>::from_column_slice(&[1.0; 4]);
46//! let mut us = VecN::<4>::from_column_slice(&[0.5; 4]);
47//! let mut ws = [0i8; 4];
48//! let stats = solve::<4, 6, 10>(&a, &b, &umin, &umax, &mut us, &mut ws, 100);
49//! assert_eq!(stats.exit_code, ExitCode::Success);
50//! ```
51//!
52//! # Example: Unregularised LS allocation
53//!
54//! ```no_run
55//! use flight_solver::cls::{solve_cls, ExitCode, Mat, VecN};
56//! use flight_solver::cls::setup::ls;
57//!
58//! let g: Mat<4, 4> = Mat::zeros(); // square system
59//! let wv = VecN::<4>::from_column_slice(&[1.0; 4]);
60//!
61//! let a = ls::setup_a::<4, 4>(&g, &wv);
62//! let v = VecN::<4>::zeros();
63//! let b = ls::setup_b(&v, &wv);
64//!
65//! let umin = VecN::<4>::from_column_slice(&[0.0; 4]);
66//! let umax = VecN::<4>::from_column_slice(&[1.0; 4]);
67//! let mut us = VecN::<4>::from_column_slice(&[0.5; 4]);
68//! let mut ws = [0i8; 4];
69//! let stats = solve_cls::<4, 4>(&a, &b, &umin, &umax, &mut us, &mut ws, 100);
70//! assert_eq!(stats.exit_code, ExitCode::Success);
71//! ```
72
73#![no_std]
74#![warn(missing_docs)]
75
76pub mod cls;
77pub mod givens;
78pub mod rls;