Trait array_math::MatrixMath

pub trait MatrixMath<T, const M: usize, const N: usize>: Array2dOps<T, M, N> {
    // Required methods
    fn identity_matrix() -> Self
       where T: Zero + One;
    fn eye_matrix(k: isize) -> Self
       where T: Zero + One;
    fn transpose_conj(self) -> [[T; M]; N]
       where T: ComplexFloat;
    fn solve_matrix(&self, y: &[T; M]) -> [T; N]
       where T: ComplexFloat + AddAssign + SubAssign + DivAssign + Div<T::Real, Output = T>,
             [(); { _ }]:;
    fn covariance_matrix(&self, expected: Option<&Self>) -> [[T; N]; N]
       where T: Div<Output = T> + Sub<Output = T> + AddAssign + SubAssign + One + Zero + NumCast + Copy;
    fn convolve_2d_direct<Rhs, const H: usize, const W: usize>(
        &self,
        rhs: &[[Rhs; W]; H]
    ) -> [[<T as Mul<Rhs>>::Output; { _ }]; { _ }]
       where T: Mul<Rhs, Output: AddAssign + Zero> + Copy,
             Rhs: Copy;
    fn convolve_2d_real_fft<Rhs, const W: usize, const H: usize>(
        &self,
        rhs: &[[Rhs; W]; H]
    ) -> [[<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real; { _ }]; { _ }]
       where T: Float + Copy,
             Rhs: Float + Copy,
             Complex<T>: MulAssign + AddAssign + ComplexFloat<Real = T> + Mul<Complex<Rhs>, Output: ComplexFloat<Real: Float>>,
             Complex<Rhs>: MulAssign + AddAssign + ComplexFloat<Real = Rhs>,
             <Complex<T> as Mul<Complex<Rhs>>>::Output: ComplexFloat<Real: Float> + Into<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>,
             Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>: MulAssign + AddAssign + ComplexFloat<Real = <<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>,
             [(); { _ }]:;
    fn convolve_2d_fft<Rhs, const W: usize, const H: usize>(
        &self,
        rhs: &[[Rhs; W]; H]
    ) -> [[<T as Mul<Rhs>>::Output; { _ }]; { _ }]
       where T: ComplexFloat + Mul<Rhs, Output: ComplexFloat + From<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + 'static>,
             Rhs: ComplexFloat,
             Complex<T::Real>: From<T> + AddAssign + MulAssign + Mul<Complex<Rhs::Real>, Output: ComplexFloat<Real = <<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + From<Complex<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real>> + Sum + 'static>,
             Complex<Rhs::Real>: From<Rhs> + AddAssign + MulAssign,
             [(); { _ }]:;
    fn fft_2d(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum;
    fn ifft_2d(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum;
    fn real_fft_2d_tall(&self, y: &mut [[Complex<T>; N]; { _ }])
       where T: Float,
             Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign;
    fn real_fft_2d_wide(&self, y: &mut [[Complex<T>; { _ }]; M])
       where T: Float,
             Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign;
    fn real_ifft_2d_tall(&mut self, y: &[[Complex<T>; N]; { _ }])
       where T: Float,
             Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign;
    fn real_ifft_2d_wide(&mut self, y: &[[Complex<T>; { _ }]; M])
       where T: Float,
             Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign;
    fn mul_matrix<Rhs, const P: usize>(
        &self,
        rhs: &[[Rhs; P]; N]
    ) -> [[<T as Mul<Rhs>>::Output; P]; M]
       where T: Mul<Rhs, Output: AddAssign + Zero> + Copy,
             Rhs: Copy;
    fn mul_matrix_assign<Rhs>(&mut self, rhs: &[[Rhs; N]; N])
       where T: Mul<Rhs> + Copy + AddAssign<<T as Mul<Rhs>>::Output> + Zero,
             Rhs: Copy;
    fn rmul_matrix_assign<Rhs>(&mut self, rhs: &[[Rhs; M]; M])
       where T: Copy + AddAssign<<Rhs as Mul<T>>::Output> + Zero,
             Rhs: Copy + Mul<T>;
    fn add_matrix<Rhs>(
        self,
        rhs: [[Rhs; N]; M]
    ) -> [[<T as Add<Rhs>>::Output; N]; M]
       where T: Add<Rhs>;
    fn add_matrix_assign<Rhs>(&mut self, rhs: [[Rhs; N]; M])
       where T: AddAssign<Rhs>;
    fn sub_matrix<Rhs>(
        self,
        rhs: [[Rhs; N]; M]
    ) -> [[<T as Sub<Rhs>>::Output; N]; M]
       where T: Sub<Rhs>;
    fn sub_matrix_assign<Rhs>(&mut self, rhs: [[Rhs; N]; M])
       where T: SubAssign<Rhs>;
    fn mul_matrix_all<Rhs>(self, rhs: Rhs) -> [[<T as Mul<Rhs>>::Output; N]; M]
       where T: Mul<Rhs>,
             Rhs: Copy;
    fn mul_matrix_assign_all<Rhs>(&mut self, rhs: Rhs)
       where T: MulAssign<Rhs>,
             Rhs: Copy;
    fn div_matrix_all<Rhs>(self, rhs: Rhs) -> [[<T as Div<Rhs>>::Output; N]; M]
       where T: Div<Rhs>,
             Rhs: Copy;
    fn div_matrix_assign_all<Rhs>(&mut self, rhs: Rhs)
       where T: DivAssign<Rhs>,
             Rhs: Copy;
    fn rpivot_matrix(&self) -> [[T; M]; M]
       where T: Neg<Output = T> + Zero + One + PartialOrd + Copy;
    fn cpivot_matrix(&self) -> [[T; N]; N]
       where T: Neg<Output = T> + Zero + One + PartialOrd + Copy;
    fn rpivot_matrix_complex(&self) -> [[T; M]; M]
       where T: ComplexFloat + Copy;
    fn cpivot_matrix_complex(&self) -> [[T; N]; N]
       where T: ComplexFloat + Copy;
    fn lup_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M])
       where T: Neg<Output = T> + Zero + One + PartialOrd + Mul<Output = T> + AddAssign + Copy + Sub<Output = T> + Div<Output = T>;
    fn lup_matrix_complex(
        &self
    ) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M])
       where T: ComplexFloat + AddAssign + Copy;
    fn lupq_matrix(
        &self
    ) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M], [[T; N]; N])
       where T: Neg<Output = T> + Zero + One + PartialOrd + Mul<Output = T> + AddAssign + Copy + Sub<Output = T> + Div<Output = T>;
    fn lupq_matrix_complex(
        &self
    ) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M], [[T; N]; N])
       where T: ComplexFloat + AddAssign + Copy;
    fn lu_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }])
       where T: Zero + One + Mul<Output = T> + Sub<Output = T> + Div<Output = T> + AddAssign + Copy;
    fn det_matrix(&self) -> T
       where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + Mul<Output = T> + MulAssign + Sub<Output = T> + Div<Output = T>,
             [(); { _ }]:;
    fn det_matrix_complex(&self) -> T
       where T: ComplexFloat + AddAssign + MulAssign + Copy,
             [(); { _ }]:;
    fn qrp_matrix(&self) -> ([[T; M]; M], [[T; N]; M], [[T; N]; N])
       where T: ComplexFloat + SubAssign + AddAssign + Copy + DivAssign<T::Real>;
    fn qr_matrix(&self) -> ([[T; M]; M], [[T; N]; M])
       where T: ComplexFloat + SubAssign + AddAssign + Copy + DivAssign<T::Real>;
    fn is_matrix_invertible(&self) -> bool
       where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + MulAssign + Sub<Output = T> + Div<Output = T>,
             [(); { _ }]:;
}

Required Methods

fn identity_matrix() -> Self

where T: Zero + One,

fn eye_matrix(k: isize) -> Self

where T: Zero + One,

fn transpose_conj(self) -> [[T; M]; N]

where T: ComplexFloat,

fn solve_matrix(&self, y: &[T; M]) -> [T; N]

where T: ComplexFloat + AddAssign + SubAssign + DivAssign + Div<T::Real, Output = T>, [(); { _ }]:,

fn covariance_matrix(&self, expected: Option<&Self>) -> [[T; N]; N]

where T: Div<Output = T> + Sub<Output = T> + AddAssign + SubAssign + One + Zero + NumCast + Copy,

fn convolve_2d_direct<Rhs, const H: usize, const W: usize>( &self, rhs: &[[Rhs; W]; H] ) -> [[<T as Mul<Rhs>>::Output; { _ }]; { _ }]

where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

Performs two-dimensional direct convolution on two matrices.

Example

#![feature(generic_const_exprs)]
 
use array_math::*;
 
let x = [
    [1, 0, 0],
    [0, 0, 0],
    [0, 0, 2]
];
let h = [
    [1, 1],
    [1, 1]
];
 
let y = x.convolve_2d_direct(&h);
 
assert_eq!(y, [
    [1, 1, 0, 0],
    [1, 1, 0, 0],
    [0, 0, 2, 2],
    [0, 0, 2, 2]
]);

fn convolve_2d_real_fft<Rhs, const W: usize, const H: usize>( &self, rhs: &[[Rhs; W]; H] ) -> [[<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real; { _ }]; { _ }]

where T: Float + Copy, Rhs: Float + Copy, Complex<T>: MulAssign + AddAssign + ComplexFloat<Real = T> + Mul<Complex<Rhs>, Output: ComplexFloat<Real: Float>>, Complex<Rhs>: MulAssign + AddAssign + ComplexFloat<Real = Rhs>, <Complex<T> as Mul<Complex<Rhs>>>::Output: ComplexFloat<Real: Float> + Into<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>, Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>: MulAssign + AddAssign + ComplexFloat<Real = <<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>, [(); { _ }]:,

Performs two-dimensional convolution using FFT on two matrices.

Example

#![feature(generic_arg_infer)]
#![feature(generic_const_exprs)]
 
use array_math::*;
 
let x = [
    [1.0, 0.0, 0.0],
    [0.0, 0.0, 0.0],
    [0.0, 0.0, 2.0]
];
let h = [
    [1.0, 1.0],
    [1.0, 1.0]
];
 
let y_fft = x.convolve_2d_real_fft(&h);
let y_direct = x.convolve_2d_direct(&h);
 
let avg_error = y_fft.comap(y_direct, |y_fft, y_direct| y_fft.comap(y_direct, |y_fft: f64, y_direct: f64| (y_fft - y_direct).abs()).avg()).avg();
assert!(avg_error < 1.0e-16);

fn convolve_2d_fft<Rhs, const W: usize, const H: usize>( &self, rhs: &[[Rhs; W]; H] ) -> [[<T as Mul<Rhs>>::Output; { _ }]; { _ }]

where T: ComplexFloat + Mul<Rhs, Output: ComplexFloat + From<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + 'static>, Rhs: ComplexFloat, Complex<T::Real>: From<T> + AddAssign + MulAssign + Mul<Complex<Rhs::Real>, Output: ComplexFloat<Real = <<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + From<Complex<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<Rhs::Real>: From<Rhs> + AddAssign + MulAssign, [(); { _ }]:,

fn fft_2d(&mut self)

where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum,

Performs the 2D Cooley-Tukey FFT on a given matrix

Examples

#![feature(generic_const_exprs)]
 
use num::Complex;
use array_math::*;
 
let x = [
    [1.0, 0.0],
    [0.0, 1.0]
].map(|r| r.map(|x| Complex::from(x)));
let mut y = x;
 
y.fft_2d();
y.ifft_2d();
 
assert_eq!(x, y);

fn ifft_2d(&mut self)

where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum,

Performs the 2D Cooley-Tukey IFFT on a given matrix

Examples

#![feature(generic_const_exprs)]
 
use num::Complex;
use array_math::*;
 
let x = [
    [1.0, 0.0],
    [0.0, 1.0]
].map(|r| r.map(|x| Complex::from(x)));
let mut y = x;
 
y.fft_2d();
y.ifft_2d();
 
assert_eq!(x, y);

fn real_fft_2d_tall(&self, y: &mut [[Complex<T>; N]; { _ }])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn real_fft_2d_wide(&self, y: &mut [[Complex<T>; { _ }]; M])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn real_ifft_2d_tall(&mut self, y: &[[Complex<T>; N]; { _ }])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn real_ifft_2d_wide(&mut self, y: &[[Complex<T>; { _ }]; M])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn mul_matrix<Rhs, const P: usize>( &self, rhs: &[[Rhs; P]; N] ) -> [[<T as Mul<Rhs>>::Output; P]; M]

where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

fn mul_matrix_assign<Rhs>(&mut self, rhs: &[[Rhs; N]; N])

where T: Mul<Rhs> + Copy + AddAssign<<T as Mul<Rhs>>::Output> + Zero, Rhs: Copy,

fn rmul_matrix_assign<Rhs>(&mut self, rhs: &[[Rhs; M]; M])

where T: Copy + AddAssign<<Rhs as Mul<T>>::Output> + Zero, Rhs: Copy + Mul<T>,

fn add_matrix<Rhs>( self, rhs: [[Rhs; N]; M] ) -> [[<T as Add<Rhs>>::Output; N]; M]

where T: Add<Rhs>,

fn add_matrix_assign<Rhs>(&mut self, rhs: [[Rhs; N]; M])

where T: AddAssign<Rhs>,

fn sub_matrix<Rhs>( self, rhs: [[Rhs; N]; M] ) -> [[<T as Sub<Rhs>>::Output; N]; M]

where T: Sub<Rhs>,

fn sub_matrix_assign<Rhs>(&mut self, rhs: [[Rhs; N]; M])

where T: SubAssign<Rhs>,

fn mul_matrix_all<Rhs>(self, rhs: Rhs) -> [[<T as Mul<Rhs>>::Output; N]; M]

where T: Mul<Rhs>, Rhs: Copy,

fn mul_matrix_assign_all<Rhs>(&mut self, rhs: Rhs)

where T: MulAssign<Rhs>, Rhs: Copy,

fn div_matrix_all<Rhs>(self, rhs: Rhs) -> [[<T as Div<Rhs>>::Output; N]; M]

where T: Div<Rhs>, Rhs: Copy,

fn div_matrix_assign_all<Rhs>(&mut self, rhs: Rhs)

where T: DivAssign<Rhs>, Rhs: Copy,

fn rpivot_matrix(&self) -> [[T; M]; M]

where T: Neg<Output = T> + Zero + One + PartialOrd + Copy,

fn cpivot_matrix(&self) -> [[T; N]; N]

where T: Neg<Output = T> + Zero + One + PartialOrd + Copy,

fn rpivot_matrix_complex(&self) -> [[T; M]; M]

where T: ComplexFloat + Copy,

fn cpivot_matrix_complex(&self) -> [[T; N]; N]

where T: ComplexFloat + Copy,

fn lup_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M])

where T: Neg<Output = T> + Zero + One + PartialOrd + Mul<Output = T> + AddAssign + Copy + Sub<Output = T> + Div<Output = T>,

fn lup_matrix_complex(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M])

where T: ComplexFloat + AddAssign + Copy,

fn lupq_matrix( &self ) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M], [[T; N]; N])

where T: Neg<Output = T> + Zero + One + PartialOrd + Mul<Output = T> + AddAssign + Copy + Sub<Output = T> + Div<Output = T>,

fn lupq_matrix_complex( &self ) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M], [[T; N]; N])

where T: ComplexFloat + AddAssign + Copy,

fn lu_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }])

where T: Zero + One + Mul<Output = T> + Sub<Output = T> + Div<Output = T> + AddAssign + Copy,

fn det_matrix(&self) -> T

where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + Mul<Output = T> + MulAssign + Sub<Output = T> + Div<Output = T>, [(); { _ }]:,

fn det_matrix_complex(&self) -> T

where T: ComplexFloat + AddAssign + MulAssign + Copy, [(); { _ }]:,

fn qrp_matrix(&self) -> ([[T; M]; M], [[T; N]; M], [[T; N]; N])

where T: ComplexFloat + SubAssign + AddAssign + Copy + DivAssign<T::Real>,

fn qr_matrix(&self) -> ([[T; M]; M], [[T; N]; M])

where T: ComplexFloat + SubAssign + AddAssign + Copy + DivAssign<T::Real>,

fn is_matrix_invertible(&self) -> bool

where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + MulAssign + Sub<Output = T> + Div<Output = T>, [(); { _ }]:,

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<T, const M: usize, const N: usize> MatrixMath<T, M, N> for [[T; N]; M]

fn identity_matrix() -> Self

where T: Zero + One,

fn eye_matrix(k: isize) -> Self

where T: Zero + One,

fn transpose_conj(self) -> [[T; M]; N]

where T: ComplexFloat,

fn solve_matrix(&self, y: &[T; M]) -> [T; N]

where T: ComplexFloat + AddAssign + SubAssign + DivAssign + Div<T::Real, Output = T>, [(); { _ }]:,

fn covariance_matrix(&self, expected: Option<&Self>) -> [[T; N]; N]

where T: Div<Output = T> + Sub<Output = T> + AddAssign + SubAssign + One + Zero + NumCast + Copy,

fn convolve_2d_direct<Rhs, const H: usize, const W: usize>( &self, rhs: &[[Rhs; W]; H] ) -> [[<T as Mul<Rhs>>::Output; { _ }]; { _ }]

where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

fn convolve_2d_real_fft<Rhs, const W: usize, const H: usize>( &self, rhs: &[[Rhs; W]; H] ) -> [[<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real; { _ }]; { _ }]

where T: Float + Copy, Rhs: Float + Copy, Complex<T>: MulAssign + AddAssign + ComplexFloat<Real = T> + Mul<Complex<Rhs>, Output: ComplexFloat<Real: Float>>, Complex<Rhs>: MulAssign + AddAssign + ComplexFloat<Real = Rhs>, <Complex<T> as Mul<Complex<Rhs>>>::Output: ComplexFloat<Real: Float> + Into<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>, Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>: MulAssign + AddAssign + ComplexFloat<Real = <<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>, [(); { _ }]:,

fn convolve_2d_fft<Rhs, const W: usize, const H: usize>( &self, rhs: &[[Rhs; W]; H] ) -> [[<T as Mul<Rhs>>::Output; { _ }]; { _ }]

where T: ComplexFloat + Mul<Rhs, Output: ComplexFloat + From<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + 'static>, Rhs: ComplexFloat, Complex<T::Real>: From<T> + AddAssign + MulAssign + Mul<Complex<Rhs::Real>, Output: ComplexFloat<Real = <<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + From<Complex<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real>> + Sum + 'static>, Complex<Rhs::Real>: From<Rhs> + AddAssign + MulAssign, [(); { _ }]:,

fn fft_2d(&mut self)

where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum,

fn ifft_2d(&mut self)

where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum,

fn real_fft_2d_tall(&self, y: &mut [[Complex<T>; N]; { _ }])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn real_fft_2d_wide(&self, y: &mut [[Complex<T>; { _ }]; M])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn real_ifft_2d_tall(&mut self, y: &[[Complex<T>; N]; { _ }])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn real_ifft_2d_wide(&mut self, y: &[[Complex<T>; { _ }]; M])

where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

fn mul_matrix<Rhs, const P: usize>( &self, rhs: &[[Rhs; P]; N] ) -> [[<T as Mul<Rhs>>::Output; P]; M]

where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

fn mul_matrix_assign<Rhs>(&mut self, rhs: &[[Rhs; N]; N])

where T: Mul<Rhs> + Copy + AddAssign<<T as Mul<Rhs>>::Output> + Zero, Rhs: Copy,

fn rmul_matrix_assign<Rhs>(&mut self, rhs: &[[Rhs; M]; M])

where T: Copy + AddAssign<<Rhs as Mul<T>>::Output> + Zero, Rhs: Copy + Mul<T>,

fn add_matrix<Rhs>( self, rhs: [[Rhs; N]; M] ) -> [[<T as Add<Rhs>>::Output; N]; M]

where T: Add<Rhs>,

fn add_matrix_assign<Rhs>(&mut self, rhs: [[Rhs; N]; M])

where T: AddAssign<Rhs>,

fn sub_matrix<Rhs>( self, rhs: [[Rhs; N]; M] ) -> [[<T as Sub<Rhs>>::Output; N]; M]

where T: Sub<Rhs>,

fn sub_matrix_assign<Rhs>(&mut self, rhs: [[Rhs; N]; M])

where T: SubAssign<Rhs>,

fn mul_matrix_all<Rhs>(self, rhs: Rhs) -> [[<T as Mul<Rhs>>::Output; N]; M]

where T: Mul<Rhs>, Rhs: Copy,

fn mul_matrix_assign_all<Rhs>(&mut self, rhs: Rhs)

where T: MulAssign<Rhs>, Rhs: Copy,

fn div_matrix_all<Rhs>(self, rhs: Rhs) -> [[<T as Div<Rhs>>::Output; N]; M]

where T: Div<Rhs>, Rhs: Copy,

fn div_matrix_assign_all<Rhs>(&mut self, rhs: Rhs)

where T: DivAssign<Rhs>, Rhs: Copy,

fn rpivot_matrix(&self) -> [[T; M]; M]

where T: Neg<Output = T> + Zero + One + PartialOrd + Copy,

fn cpivot_matrix(&self) -> [[T; N]; N]

where T: Neg<Output = T> + Zero + One + PartialOrd + Copy,

fn rpivot_matrix_complex(&self) -> [[T; M]; M]

where T: ComplexFloat + Copy,

fn cpivot_matrix_complex(&self) -> [[T; N]; N]

where T: ComplexFloat + Copy,

fn lup_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M])

where T: Neg<Output = T> + Zero + One + PartialOrd + Mul<Output = T> + AddAssign + Copy + Sub<Output = T> + Div<Output = T>,

fn lup_matrix_complex(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M])

where T: ComplexFloat + AddAssign + Copy,

fn lupq_matrix( &self ) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M], [[T; N]; N])

where T: Neg<Output = T> + Zero + One + PartialOrd + Mul<Output = T> + AddAssign + Copy + Sub<Output = T> + Div<Output = T>,

fn lupq_matrix_complex( &self ) -> ([[T; { _ }]; M], [[T; N]; { _ }], [[T; M]; M], [[T; N]; N])

where T: ComplexFloat + AddAssign + Copy,

fn lu_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }])

where T: Zero + One + Mul<Output = T> + Sub<Output = T> + Div<Output = T> + AddAssign + Copy,

fn det_matrix(&self) -> T

where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + Mul<Output = T> + MulAssign + Sub<Output = T> + Div<Output = T>, [(); { _ }]:,

fn det_matrix_complex(&self) -> T

where T: ComplexFloat + AddAssign + MulAssign + Copy, [(); { _ }]:,

fn qrp_matrix(&self) -> ([[T; M]; M], [[T; N]; M], [[T; N]; N])

where T: ComplexFloat + SubAssign + AddAssign + Copy + DivAssign<T::Real>,

fn qr_matrix(&self) -> ([[T; M]; M], [[T; N]; M])

where T: ComplexFloat + SubAssign + AddAssign + Copy + DivAssign<T::Real>,

fn is_matrix_invertible(&self) -> bool

where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + MulAssign + Sub<Output = T> + Div<Output = T>, [(); { _ }]:,

Implementors