Struct ObservationMatrixMutBuffer 

pub struct ObservationMatrixMutBuffer<const OBSERVATIONS: usize, const STATES: usize, T, M>(/* private fields */)
where
    M: MatrixMut<OBSERVATIONS, STATES, T>;

Mutable buffer for the observation matrix (num_controls × num_states), typically denoted “H”.

Regular Kalman Filters

This matrix represents the observation model. It defines the relationship between the state and the measurements obtained from the system. The matrix ( H ) is used to map the predicted state into the measurement space, allowing the Kalman filter to compare the predicted measurements with the actual measurements for updating the state estimate.

Extended Kalman Filters

This matrix represents the observation model in the context of the Extended Kalman Filter (EKF). It defines the relationship between the state and the measurements obtained from the system. In the EKF, the matrix ( H ) is the Jacobian of the measurement function with respect to the state, evaluated at the current state estimate. This Jacobian matrix linearizes the non-linear measurement function around the current estimate, allowing the EKF to map the predicted state into the measurement space for comparison with the actual measurements during the update step.

Example

use minikalman::buffers::types::ObservationMatrixMutBuffer;
use minikalman::prelude::*;

// From owned data
let buffer = ObservationMatrixMutBuffer::new(MatrixData::new_array::<2, 2, 4, f32>([0.0; 4]));

// From a reference
let mut data = [0.0; 4];
let buffer = ObservationMatrixMutBuffer::<2, 2, f32, _>::from(data.as_mut_slice());

Implementations

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

pub const fn new(matrix: M) -> Self

pub const fn len(&self) -> usize

pub const fn is_empty(&self) -> bool

pub fn is_valid(&self) -> bool

Ensures the underlying buffer has enough space for the expected number of values.

Trait Implementations

impl<'a, const OBSERVATIONS: usize, const STATES: usize, T> From<&'a mut [T]> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, MatrixDataMut<'a, OBSERVATIONS, STATES, T>>

fn from(value: &'a mut [T]) -> Self

Converts to this type from the input type.

impl<const OBSERVATIONS: usize, const STATES: usize, const TOTAL: usize, T> From<[T; TOTAL]> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, MatrixDataArray<OBSERVATIONS, STATES, TOTAL, T>>

fn from(value: [T; TOTAL]) -> Self

Converts to this type from the input type.

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> Index<usize> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> IndexMut<usize> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> IntoInnerData for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T> + IntoInnerData,

type Target = <M as IntoInnerData>::Target

fn into_inner(self) -> Self::Target

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> Matrix<OBSERVATIONS, STATES, T> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

fn rows(&self) -> usize

Returns the number of rows of this matrix.

fn cols(&self) -> usize

Returns the number of columns of this matrix.

fn inspect<F, O>(&self, f: F) -> O

where F: FnMut(&Self) -> O,

Applies a function to this matrix.

fn get(&self, row: usize, column: usize) -> T

where T: Copy,

Gets a matrix element

fn get_column_copy(&self, column: usize, col_data: &mut [T])

where T: Copy,

Gets a copy of a matrix column

fn get_row_copy(&self, row: usize, row_data: &mut [T])

where T: Copy,

Gets a copy of a matrix row

fn copy<Target>(&self, target: &mut Target)

where Target: MatrixMut<ROWS, COLS, T>, T: Copy,

Copies the matrix from mat to target.

fn mult_buffered<const U: usize, B, C>(&self, b: &B, c: &mut C, baux: &mut [T])

where B: Matrix<COLS, U, T>, C: MatrixMut<ROWS, U, T>, T: MatrixDataType,

Performs a matrix multiplication such that C = A * B. This method uses an auxiliary buffer for keeping one row of B cached. This might improve performance on very wide matrices but is generally slower than Matrix::mult.

fn mult<const U: usize, B, C>(&self, b: &B, c: &mut C)

where B: Matrix<COLS, U, T>, C: MatrixMut<ROWS, U, T>, T: MatrixDataType,

Performs a matrix multiplication such that C = A * B.

fn mult_rowvector<X, C>(&self, x: &X, c: &mut C)

where X: Matrix<COLS, 1, T>, C: MatrixMut<ROWS, 1, T>, T: MatrixDataType,

Performs a matrix multiplication such that C = A * x.

fn multadd_rowvector<X, C>(&self, x: &X, c: &mut C)

where X: Matrix<COLS, 1, T>, C: MatrixMut<ROWS, 1, T>, T: MatrixDataType,

Performs a matrix-vector multiplication and addition such that C = C + A * x.

fn mult_transb<const U: usize, B, C>(&self, b: &B, c: &mut C)

where B: Matrix<U, COLS, T>, C: MatrixMut<ROWS, U, T>, T: MatrixDataType,

Performs a matrix multiplication with transposed B such that C = A * B'.

fn multadd_transb<const U: usize, B, C>(&self, b: &B, c: &mut C)

where B: Matrix<U, COLS, T>, C: MatrixMut<ROWS, U, T>, T: MatrixDataType,

Performs a matrix multiplication with transposed B and adds the result to C such that C = C + A * B'.

fn multscale_transb<const U: usize, B, C>(&self, b: &B, scale: T, c: &mut C)

where B: Matrix<U, COLS, T>, C: MatrixMut<ROWS, U, T>, T: MatrixDataType,

Performs a matrix multiplication with transposed B and scales the result such that C = A * B' * scale.

fn sub<B, C>(&self, b: &B, c: &mut C)

where B: Matrix<ROWS, COLS, T>, C: MatrixMut<ROWS, COLS, T>, T: MatrixDataType,

Subtracts two matrices, using C = A - B.

fn add_inplace_b<B>(&self, b: &mut B)

where B: MatrixMut<ROWS, COLS, T>, T: MatrixDataType,

Adds two matrices in place, using B = A + B

fn sub_inplace_b<B>(&self, b: &mut B)

where B: MatrixMut<ROWS, COLS, T>, T: MatrixDataType,

Subtracts two matrices in place, using B = A - B.

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> MatrixMut<OBSERVATIONS, STATES, T> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

fn apply<F, O>(&mut self, f: F) -> O

where F: FnMut(&mut Self) -> O,

Applies a function to this matrix.

fn clear(&mut self)

where T: Copy + Zero,

Sets all elements of the matrix to the zero.

fn set(&mut self, row: usize, column: usize, value: T)

Sets a matrix element

fn set_all(&mut self, value: T)

where T: Copy,

Sets all elements of the matrix to the provided value.

fn set_zero(&mut self)

where T: Copy + Zero,

Sets all elements of the matrix to the provided value.

fn set_symmetric(&mut self, row: usize, column: usize, value: T)

where T: Copy,

Sets matrix elements in a symmetric matrix

fn add_inplace_a<B>(&mut self, b: &B)

where B: Matrix<ROWS, COLS, T>, T: MatrixDataType,

Adds two matrices in place, using A = A + B

fn sub_inplace_a<B>(&mut self, b: &B)

where B: Matrix<ROWS, COLS, T>, T: MatrixDataType,

Subtracts two matrices in place, using A = A - B.

fn cholesky_decompose_lower(&mut self) -> bool

where T: MatrixDataType,

Decomposes a matrix into lower triangular form using Cholesky decomposition.

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> ObservationMatrix<OBSERVATIONS, STATES, T> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

type Target = M

fn as_matrix(&self) -> &Self::Target

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> ObservationMatrixMut<OBSERVATIONS, STATES, T> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

type TargetMut = M

fn as_matrix_mut(&mut self) -> &mut Self::TargetMut

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> RowMajorSequentialData<OBSERVATIONS, STATES, T> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

fn as_slice(&self) -> &[T]

Gets the data as a slice.

fn len(&self) -> usize

Gets the length of the data.

fn buffer_len(&self) -> usize

Gets the length of the underlying data buffer.

fn is_empty(&self) -> bool

Determines if this data is empty.

fn is_valid(&self) -> bool

Ensures the underlying buffer has enough space for the expected number of values.

fn get_at(&self, row: usize, column: usize) -> T

where T: Copy,

Gets a matrix element

impl<const OBSERVATIONS: usize, const STATES: usize, T, M> RowMajorSequentialDataMut<OBSERVATIONS, STATES, T> for ObservationMatrixMutBuffer<OBSERVATIONS, STATES, T, M>

where M: MatrixMut<OBSERVATIONS, STATES, T>,

fn as_mut_slice(&mut self) -> &mut [T]

fn set_at(&mut self, row: usize, column: usize, value: T)

Gets a matrix element