Struct bayes_estimate::models::InformationState

pub struct InformationState<N: SimdRealField, D: Dim> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,  {
    pub i: VectorN<N, D>,
    pub I: MatrixN<N, D>,
}

Information state.

Linear representation as a information state vector and the information (symmetric positive semi-definite) matrix. For a given KalmanState the information state I == inverse(X), i == I.x

Fields

i: VectorN<N, D>

Information state vector

I: MatrixN<N, D>

Information matrix (symmetric positive semi-definite)

Implementations

impl<N: RealField, D: Dim> InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, 

pub fn new_zero(d: D) -> InformationState<N, D>

impl<N: RealField, D: Dim> InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, 

pub fn predict_linear<QD: Dim>(
    &mut self,
    pred_inv: MatrixN<N, D>,
    noise: &CoupledNoise<N, D, QD>
) -> Result<N, &'static str> where
    DefaultAllocator: Allocator<N, QD, QD> + Allocator<N, D, QD> + Allocator<N, QD, D> + Allocator<N, QD>, 

Linear information predict.

Computation is through information state i,I only. Uses Fx.x instead of extended f(x)

The numerical solution used is particularly flexible. It takes particular care to avoid invertibility requirements for the noise and noise coupling g,Q Therefore both zero noises and zeros in the couplings can be used.

pub fn add_information(&mut self, information: &InformationState<N, D>)

pub fn observe_info<ZD: Dim>(
    &self,
    hx: &MatrixMN<N, ZD, D>,
    noise_inv: &MatrixN<N, ZD>,
    z: &VectorN<N, ZD>
) -> InformationState<N, D> where
    DefaultAllocator: Allocator<N, ZD, ZD> + Allocator<N, ZD, D> + Allocator<N, D, ZD> + Allocator<N, ZD>, 

Trait Implementations

impl<N: Clone + SimdRealField, D: Clone + Dim> Clone for InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, 

fn clone(&self) -> InformationState<N, D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N: RealField, D: Dim> Estimator<N, D> for InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, 

fn state(&self) -> Result<VectorN<N, D>, &'static str>

The estimator’s estimate of the system’s state.

impl<N: RealField, D: Dim, ZD: Dim> ExtendedLinearObserver<N, D, ZD> for InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D, ZD> + Allocator<N, ZD, D> + Allocator<N, ZD, ZD> + Allocator<N, D> + Allocator<N, ZD>, 

fn observe_innovation(
    &mut self,
    s: &VectorN<N, ZD>,
    hx: &MatrixMN<N, ZD, D>,
    noise: &CorrelatedNoise<N, ZD>
) -> Result<(), &'static str>

Uses a non-linear state observation with linear estimation model with additive noise.

impl<N: RealField, D: Dim> ExtendedLinearPredictor<N, D> for InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, 

fn predict(
    &mut self,
    x_pred: &VectorN<N, D>,
    fx: &MatrixN<N, D>,
    noise: &CorrelatedNoise<N, D>
) -> Result<(), &'static str>

Uses a non-linear state prediction with linear estimation model with additive noise.

impl<N: RealField, D: Dim> KalmanEstimator<N, D> for InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, 

fn init(&mut self, state: &KalmanState<N, D>) -> Result<(), &'static str>

Initialise the estimator with a KalmanState.

fn kalman_state(&self) -> Result<KalmanState<N, D>, &'static str>

The estimator’s estimate of the system’s KalmanState.

impl<N: PartialEq + SimdRealField, D: PartialEq + Dim> PartialEq<InformationState<N, D>> for InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>, 

fn eq(&self, other: &InformationState<N, D>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &InformationState<N, D>) -> bool

This method tests for !=.

impl<N: SimdRealField, D: Dim> StructuralPartialEq for InformationState<N, D> where
    DefaultAllocator: Allocator<N, D, D> + Allocator<N, D>,