Struct RlsParallel 

pub struct RlsParallel<const N: usize, const P: usize> { /* private fields */ }

Parallel multi-output RLS with shared covariance.

Runs P independent scalar-output RLS instances that share the same regressor vector a ∈ ℝⁿ and covariance matrix P ∈ ℝⁿˣⁿ. Since each observation is scalar, the denominator λ + a P aᵀ is a scalar—no Cholesky decomposition required.

Model

yᵀ = a X    where  yᵀ ∈ ℝᵖ,  X ∈ ℝⁿˣᵖ,  a ∈ ℝⁿ

Each column xⱼ of X is an independent parameter vector. All P outputs share the covariance update but have independent parameter updates weighted by their individual prediction errors.

Type parameters

• N — number of parameters per output (regressor dimension)
• P — number of parallel outputs

Example

use flight_solver::rls::{RlsParallel, CovarianceGuards};

// 4 parameters, 3 parallel outputs (e.g. G1 learning for roll/pitch/yaw)
let mut rls = RlsParallel::<4, 3>::new(1e2, 0.995, CovarianceGuards::default());

let a = nalgebra::SVector::<f32, 4>::new(0.1, -0.2, 0.3, 0.05);
let y = nalgebra::SVector::<f32, 3>::new(0.5, -0.3, 0.1);

let stats = rls.update(&a, &y);

Implementations

impl<const N: usize, const P: usize> RlsParallel<N, P>

where Const<N>: DimName, Const<P>: DimName,

pub fn new(gamma: f32, lambda: f32, guards: CovarianceGuards) -> Self

Create a new parallel RLS with initial covariance P = γ I.

Arguments

• gamma — initial covariance diagonal
• lambda — forgetting factor in (0, 1]
• guards — numerical guard configuration

pub fn from_time_constant( gamma: f32, ts: f32, t_char: f32, guards: CovarianceGuards, ) -> Self

Create from a time-constant–based forgetting factor, matching indiflight’s rlsParallelInit.

λ = (1 − ln 2)^(Ts / Tchar)

At time Tchar, the weight of the oldest sample has decayed to 50%.

Arguments

• gamma — initial covariance diagonal
• ts — sampling period in seconds (e.g. 1.0 / 8000.0)
• t_char — characteristic forgetting time in seconds
• guards — numerical guard configuration

pub fn update( &mut self, a: &OVector<f32, Const<N>>, y: &OVector<f32, Const<P>>, ) -> UpdateStats

Process one observation and update parameter estimates.

Arguments

• a — shared regressor vector a ∈ ℝⁿ
• y — observation vector y ∈ ℝᵖ (one scalar per output)

Algorithm

1. Covariance explosion check
2. Compute P aᵀ and scalar a P aᵀ
3. Gain vector: k = P aᵀ / (λ + a P aᵀ)
4. Per-diagonal order decrement limiting
5. Covariance update: P ← (KAPmult · P − k (P aᵀ)ᵀ) / λ
6. Parameter update: X ← X + k eᵀ

pub fn params(&self) -> &OMatrix<f32, Const<N>, Const<P>>

Current parameter matrix X ∈ ℝⁿˣᵖ.

pub fn params_mut(&mut self) -> &mut OMatrix<f32, Const<N>, Const<P>>

Mutable access to the parameter matrix.

pub fn covariance(&self) -> &OMatrix<f32, Const<N>, Const<N>>

Current shared covariance matrix P ∈ ℝⁿˣⁿ.

pub fn lambda(&self) -> f32

Forgetting factor λ.

pub fn set_lambda(&mut self, lambda: f32)

Set the forgetting factor λ ∈ (0, 1].

pub fn samples(&self) -> u32

Number of samples processed so far.

Trait Implementations

impl<const N: usize, const P: usize> Clone for RlsParallel<N, P>

fn clone(&self) -> RlsParallel<N, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.