Trait array_math::MatrixMath

source · 
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 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_fft_cooley_tukey<Rhs, const W: usize, const H: usize, const U: usize, const V: 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 + ComplexFloat<Real: Float> + From<Complex<<Complex<T> as ComplexFloat>::Real>> + Mul<Complex<Rhs>, Output: ComplexFloat<Real: Float>>,
             Complex<Rhs>: MulAssign + ComplexFloat<Real: Float> + From<Complex<<Complex<Rhs> as ComplexFloat>::Real>>,
             <Complex<T> as Mul<Complex<Rhs>>>::Output: MulAssign + ComplexFloat<Real: Float> + From<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>;
    fn fft_2d_cooley_tukey(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + From<Complex<T::Real>>;
    fn ifft_2d_cooley_tukey(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + From<Complex<T::Real>>;
    fn mul_matrix<Rhs, const P: usize>(
        &self,
        rhs: &[[Rhs; P]; N]
    ) -> Self::Array2d<<T as Mul<Rhs>>::Output, M, P>
       where T: Mul<Rhs, Output: AddAssign + Zero> + Copy,
             Rhs: Copy;
    fn pivot_matrix(&self) -> [[T; M]; M]
       where T: Neg<Output = T> + Zero + One + PartialOrd + 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 lu_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }])
       where T: Zero + One + PartialOrd + 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 is_matrix_invertible(&self) -> bool
       where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + MulAssign + Sub<Output = T> + Div<Output = T>;
}

Required Methods§

source

fn identity_matrix() -> Self
where T: Zero + One,

source

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]
]);
source

fn convolve_2d_fft_cooley_tukey<Rhs, const W: usize, const H: usize, const U: usize, const V: 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 + ComplexFloat<Real: Float> + From<Complex<<Complex<T> as ComplexFloat>::Real>> + Mul<Complex<Rhs>, Output: ComplexFloat<Real: Float>>, Complex<Rhs>: MulAssign + ComplexFloat<Real: Float> + From<Complex<<Complex<Rhs> as ComplexFloat>::Real>>, <Complex<T> as Mul<Complex<Rhs>>>::Output: MulAssign + ComplexFloat<Real: Float> + From<Complex<<<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_fft_cooley_tukey::<_, _, _, 4, 4>(&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);
source

fn fft_2d_cooley_tukey(&mut self)
where T: ComplexFloat<Real: Float> + MulAssign + From<Complex<T::Real>>,

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

§Examples
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_cooley_tukey();
y.ifft_2d_cooley_tukey();
 
assert_eq!(x, y);
source

fn ifft_2d_cooley_tukey(&mut self)
where T: ComplexFloat<Real: Float> + MulAssign + From<Complex<T::Real>>,

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

§Examples
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_cooley_tukey();
y.ifft_2d_cooley_tukey();
 
assert_eq!(x, y);
source

fn mul_matrix<Rhs, const P: usize>( &self, rhs: &[[Rhs; P]; N] ) -> Self::Array2d<<T as Mul<Rhs>>::Output, M, P>
where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

source

fn pivot_matrix(&self) -> [[T; M]; M]
where T: Neg<Output = T> + Zero + One + PartialOrd + Copy,

source

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>,

source

fn lu_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }])
where T: Zero + One + PartialOrd + Mul<Output = T> + Sub<Output = T> + Div<Output = T> + AddAssign + Copy,

source

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>,

source

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§

source§

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

source§

fn identity_matrix() -> Self
where T: Zero + One,

source§

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,

source§

fn convolve_2d_fft_cooley_tukey<Rhs, const W: usize, const H: usize, const U: usize, const V: 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 + ComplexFloat<Real: Float> + From<Complex<<Complex<T> as ComplexFloat>::Real>> + Mul<Complex<Rhs>, Output: ComplexFloat<Real: Float>>, Complex<Rhs>: MulAssign + ComplexFloat<Real: Float> + From<Complex<<Complex<Rhs> as ComplexFloat>::Real>>, <Complex<T> as Mul<Complex<Rhs>>>::Output: MulAssign + ComplexFloat<Real: Float> + From<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>,

source§

fn fft_2d_cooley_tukey(&mut self)
where T: ComplexFloat<Real: Float> + MulAssign + From<Complex<T::Real>>,

source§

fn ifft_2d_cooley_tukey(&mut self)
where T: ComplexFloat<Real: Float> + MulAssign + From<Complex<T::Real>>,

source§

fn mul_matrix<Rhs, const P: usize>( &self, rhs: &Self::Array2d<Rhs, N, P> ) -> Self::Array2d<<T as Mul<Rhs>>::Output, M, P>
where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

source§

fn pivot_matrix(&self) -> [[T; M]; M]
where T: Neg<Output = T> + Zero + One + PartialOrd + Copy,

source§

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>,

source§

fn lu_matrix(&self) -> ([[T; { _ }]; M], [[T; N]; { _ }])
where T: Zero + One + PartialOrd + Mul<Output = T> + Sub<Output = T> + Div<Output = T> + AddAssign + Copy,

source§

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>,

source§

fn is_matrix_invertible(&self) -> bool
where T: Zero + Neg<Output = T> + One + Copy + AddAssign + PartialOrd + MulAssign + Sub<Output = T> + Div<Output = T>,

Implementors§