Struct Matrix 

pub struct Matrix<const ROWS: usize, const COLS: usize> { /* private fields */ }

Trait Implementations

impl<const ROWS: usize, const COLS: usize> Add for Matrix<ROWS, COLS>

type Output = Matrix<ROWS, COLS>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<ROWS, COLS>) -> Self::Output

Performs the + operation.

impl<const ROWS: usize, const COLS: usize> AddAssign for Matrix<ROWS, COLS>

fn add_assign(&mut self, rhs: Matrix<ROWS, COLS>)

Performs the += operation.

impl<const ROWS: usize, const COLS: usize> Clone for Matrix<ROWS, COLS>

fn clone(&self) -> Matrix<ROWS, COLS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const ROWS: usize, const COLS: usize> Debug for Matrix<ROWS, COLS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const ROWS: usize, const COLS: usize> Index<usize> for Matrix<ROWS, COLS>

type Output = Vec<f64, COLS>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<const ROWS: usize, const COLS: usize> IndexMut<usize> for Matrix<ROWS, COLS>

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

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

impl<const ROWS: usize, const COLS: usize> MatrixConcat<ROWS, COLS> for Matrix<ROWS, COLS>

fn x_concat<const RHS_COLS: usize, const NEW_COLS: usize>( self, rhs: Matrix<ROWS, RHS_COLS>, ) -> Result<Matrix<ROWS, NEW_COLS>, &'static str>

Example:

use heapless_matrix::{matrix_trait::{MatrixTrait, MatrixConcat}, Matrix};
let mat1: Matrix<2, 2> = Matrix::eye().unwrap();
let mat2: Matrix<2, 2> = Matrix::new().unwrap();
let mat3 = mat1.clone().x_concat::<2, 4>(mat2.clone()).unwrap();
for i in 0..2 {
    for j in 0..2 {
        assert_eq!(mat3[i][j], mat1[i][j]);
    }
    for j in 0..2 {
        assert_eq!(mat3[i][j + 2], mat2[i][j]);
    }
}

fn y_concat<const RHS_ROWS: usize, const NEW_ROWS: usize>( self, rhs: Matrix<RHS_ROWS, COLS>, ) -> Result<Matrix<NEW_ROWS, COLS>, &'static str>

Function that concatenates matrices vertically

impl<const ROWS: usize, const COLS: usize> MatrixTrait<ROWS, COLS> for Matrix<ROWS, COLS>

fn from_vector(data: [[f64; COLS]; ROWS]) -> Result<Self, &'static str>

where Self: Sized,

Function used to create a heapless matrix from a 2D array Example:

use heapless_matrix::{matrix_trait::MatrixTrait as _, Matrix};
let data = [[1., 2.],
            [3., 4.]];
let mat: Matrix<2, 2> = Matrix::from_vector(data).unwrap();

for i in 0..2 {
    for j in 0..2 {
        assert_eq!(data[i][j], mat[i][j]);
    }
}

type TransposeType = Matrix<COLS, ROWS>

fn new() -> Result<Self, &'static str>

where Self: Sized,

Function that creates an matrix where all elements are equal to zero

fn eye() -> Result<Self, &'static str>

where Self: Sized,

Function that creates an identity matrix

fn to_double(&self) -> Result<f64, &'static str>

Function that converts a 1x1 matrix into a f64

fn transpose(&self) -> Self::TransposeType

Function that transposes a matrix

fn swap_rows(&mut self, row1: usize, row2: usize) -> Result<(), &'static str>

Function that swaps two rows of a matrix

fn swap_cols(&mut self, col1: usize, col2: usize) -> Result<(), &'static str>

function that swaps two columns of a matrix

fn sub_matrix<const NEW_ROWS: usize, const NEW_COLS: usize>( &self, row_start: usize, col_start: usize, ) -> Result<Matrix<NEW_ROWS, NEW_COLS>, &'static str>

Function that returns the submatrix of a matrix

fn vector_to_row(elems: [f64; ROWS]) -> Result<Matrix<ROWS, 1>, &'static str>

Function that takes the element from the array and sort them in a matrix row of dimensions ROWS x 1

fn pinv<const DOUBLE: usize>(&self) -> Result<Matrix<COLS, ROWS>, &'static str>

Function that implements Moore-Penrose pseudoinversion

impl<const LHS_ROWS: usize, const LHS_COLS: usize, const RHS_COLS: usize> Mul<Matrix<LHS_COLS, RHS_COLS>> for Matrix<LHS_ROWS, LHS_COLS>

type Output = Matrix<LHS_ROWS, RHS_COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<LHS_COLS, RHS_COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<Matrix<ROWS, COLS>> for f64

type Output = Matrix<ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<ROWS, COLS>) -> Self::Output

Performs the * operation.

impl<const ROWS: usize, const COLS: usize> Mul<f64> for Matrix<ROWS, COLS>

type Output = Matrix<ROWS, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Performs the * operation.

impl<const N: usize> MulAssign<&Matrix<N, N>> for Matrix<N, N>

fn mul_assign(&mut self, rhs: &Matrix<N, N>)

Performs the *= operation.

impl<const ROWS: usize, const COLS: usize> MulAssign<f64> for Matrix<ROWS, COLS>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<const N: usize> MulAssign for Matrix<N, N>

fn mul_assign(&mut self, rhs: Matrix<N, N>)

Performs the *= operation.

impl<const ROWS: usize, const COLS: usize> PartialEq for Matrix<ROWS, COLS>

fn eq(&self, other: &Matrix<ROWS, COLS>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> SquareMatrix<N> for Matrix<N, N>

fn det(&self) -> f64

Function that calculates the determinant of a square matrix

fn inv<const DOUBLE_COLS: usize>(&self) -> Result<Matrix<N, N>, &'static str>

Function that calculates the inversion of a sqaure matrix if possible, othervise it returns an Err

fn pow(&self, n: usize) -> Matrix<N, N>

Function that calculates the pow of a square matrix

fn diag(elems: [f64; N]) -> Result<Matrix<N, N>, &'static str>

Function that takes the element from an array an makes a diagonal matrix using them

impl<const ROWS: usize, const COLS: usize> Sub for Matrix<ROWS, COLS>

type Output = Matrix<ROWS, COLS>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<ROWS, COLS>) -> Self::Output

Performs the - operation.

impl<const ROWS: usize, const COLS: usize> SubAssign for Matrix<ROWS, COLS>

fn sub_assign(&mut self, rhs: Matrix<ROWS, COLS>)

Performs the -= operation.

impl<const ROWS: usize> VectorCol<ROWS> for Matrix<ROWS, 1>

fn shift_data(&mut self, data: f64)

Function that inserts new data at the begginig of the matrix, and shifts other data by one to the end

impl<const N: usize> IsSquareMatrix for Matrix<N, N>

impl<const ROWS: usize> IsVectorCol for Matrix<ROWS, 1>