Struct Matrix 

pub struct Matrix<const M: usize, const N: usize> { /* private fields */ }

Implementations

impl<const M: usize, const N: usize> Matrix<M, N>

pub const ZEROS: Self

pub const fn new(data: [[Complex64; N]; M]) -> Self

pub fn from_column_vectors(columns: [Vector<M>; N]) -> Self

pub fn to_column_vectors(self) -> [Vector<M>; N]

pub fn iter(&self) -> impl Iterator<Item = &Complex64>

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Complex64>

pub fn epsilon(&self) -> f64

pub fn swap_row(&mut self, i: usize, j: usize)

pub fn multiply_row_by_scalar(&mut self, i: usize, scalar: Complex64)

pub fn add_row_with_scalar(&mut self, i: usize, j: usize, scalar: Complex64)

pub fn transpose(&self) -> Matrix<N, M>

pub fn gaussian_elimination(self) -> (Matrix<M, N>, Matrix<M, M>, usize)

pub fn rank(&self) -> usize

impl<const M: usize> Matrix<M, M>

pub fn diagonal(data: [Complex64; M]) -> Self

pub fn identity() -> Self

pub fn determinant(&self) -> Complex64

pub fn gauss_jordan_elimination(self) -> (Matrix<M, M>, Matrix<M, M>)

pub fn inverse(self) -> Option<Matrix<M, M>>

pub fn qr_decomposition(self) -> (Matrix<M, M>, Matrix<M, M>)

pub fn schur_form(self, iterations: usize) -> Matrix<M, M>

pub fn eigenvalues(&self, iterations: usize) -> [Complex64; M]

pub fn eigenvectors(&self, iterations: usize) -> [Vector<M>; M]

impl<const N: usize> Matrix<N, 1>

pub fn dot(&self, rhs: &Vector<N>) -> Complex64

pub fn norm(&self, p: u32) -> f64

pub fn normalize(self) -> Self

pub fn project(self, rhs: Self) -> Self

pub fn gram_schimidt_process<const M: usize>( vectors: [Vector<N>; M], ) -> [Vector<N>; M]

Trait Implementations

impl<const M: usize, const N: usize> Add for Matrix<M, N>

type Output = Matrix<M, N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<const M: usize, const N: usize> AddAssign for Matrix<M, N>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const M: usize, const N: usize> Clone for Matrix<M, N>

fn clone(&self) -> Matrix<M, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const M: usize, const N: usize> Debug for Matrix<M, N>

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

Formats the value using the given formatter.

impl<const M: usize, const N: usize> Display for Matrix<M, N>

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

Formats the value using the given formatter.

impl<const M: usize, const N: usize> Index<[usize; 2]> for Matrix<M, N>

type Output = Complex<f64>

The returned type after indexing.

fn index(&self, [i, j]: [usize; 2]) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const M: usize, const N: usize> IndexMut<[usize; 2]> for Matrix<M, N>

fn index_mut(&mut self, index: [usize; 2]) -> &mut Self::Output

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

impl<const M: usize, const N: usize> Mul<Complex<f64>> for Matrix<M, N>

type Output = Matrix<M, N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const M: usize, const N: usize> Mul<Matrix<M, N>> for Complex64

type Output = Matrix<M, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<M, N>) -> Self::Output

Performs the * operation.

impl<const M: usize, const N: usize, const P: usize> Mul<Matrix<N, P>> for Matrix<M, N>

type Output = Matrix<M, P>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<N, P>) -> Self::Output

Performs the * operation.

impl<const M: usize, const N: usize> MulAssign<Complex<f64>> for Matrix<M, N>

fn mul_assign(&mut self, rhs: Complex64)

Performs the *= operation.

impl<const M: usize, const N: usize> PartialEq for Matrix<M, N>

fn eq(&self, other: &Self) -> 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 M: usize, const N: usize> Sub for Matrix<M, N>

type Output = Matrix<M, N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<const M: usize, const N: usize> SubAssign for Matrix<M, N>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const M: usize, const N: usize> Sum for Matrix<M, N>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.