Trait array_math::ArrayMath

source · 
pub trait ArrayMath<T, const N: usize>: ArrayOps<T, N> {

Show 30 methods    // Required methods
    fn sum(self) -> T
       where T: AddAssign + Zero;
    fn product(self) -> T
       where T: MulAssign + One;
    fn variance(self) -> <T as Mul>::Output
       where Self: ArrayOps<T, N> + Copy,
             u8: Into<T>,
             T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero;
    fn variance16(self) -> <T as Mul>::Output
       where Self: ArrayOps<T, N> + Copy,
             u16: Into<T>,
             T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero;
    fn variance32(self) -> <T as Mul>::Output
       where Self: ArrayOps<T, N> + Copy,
             u32: Into<T>,
             T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero;
    fn variance64(self) -> <T as Mul>::Output
       where Self: ArrayOps<T, N> + Copy,
             u64: Into<T>,
             T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero;
    fn avg(self) -> <T as Div>::Output
       where u8: Into<T>,
             T: Div + AddAssign + Zero;
    fn avg16(self) -> <T as Div>::Output
       where u16: Into<T>,
             T: Div + AddAssign + Zero;
    fn avg32(self) -> <T as Div>::Output
       where u32: Into<T>,
             T: Div + AddAssign + Zero;
    fn avg64(self) -> <T as Div>::Output
       where u64: Into<T>,
             T: Div + AddAssign + Zero;
    fn mul_dot<Rhs>(self, rhs: [Rhs; N]) -> <T as Mul<Rhs>>::Output
       where T: Mul<Rhs, Output: AddAssign + Zero>;
    fn magnitude_squared(self) -> <T as Mul<T>>::Output
       where T: Mul<T, Output: AddAssign + Zero> + Copy;
    fn magnitude(self) -> <T as Mul<T>>::Output
       where T: Mul<T, Output: AddAssign + Zero + Float> + Copy;
    fn magnitude_inv(self) -> <T as Mul<T>>::Output
       where T: Mul<T, Output: AddAssign + Zero + Float> + Copy;
    fn normalize(self) -> [<T as Mul<<T as Mul<T>>::Output>>::Output; N]
       where T: Mul<T, Output: AddAssign + Zero + Float + Copy> + Mul<<T as Mul<T>>::Output> + Copy;
    fn normalize_to<Rhs>(
        self,
        magnitude: Rhs
    ) -> [<T as Mul<<<T as Mul<T>>::Output as Mul<Rhs>>::Output>>::Output; N]
       where T: Mul<T, Output: AddAssign + Zero + Float + Mul<Rhs, Output: Copy>> + Mul<<<T as Mul<T>>::Output as Mul<Rhs>>::Output> + Copy;
    fn normalize_assign(&mut self)
       where T: Mul<T, Output: AddAssign + Zero + Float + Copy> + MulAssign<<T as Mul<T>>::Output> + Copy;
    fn normalize_assign_to<Rhs>(&mut self, magnitude: Rhs)
       where T: Mul<T, Output: AddAssign + Zero + Float + Mul<Rhs, Output: Copy>> + MulAssign<<<T as Mul<T>>::Output as Mul<Rhs>>::Output> + Copy;
    fn polynomial<Rhs>(self, rhs: Rhs) -> T
       where T: AddAssign + MulAssign<Rhs> + Zero,
             Rhs: Copy;
    fn convolve_direct<Rhs, const M: usize>(
        &self,
        rhs: &[Rhs; M]
    ) -> [<T as Mul<Rhs>>::Output; { _ }]
       where T: Mul<Rhs, Output: AddAssign + Zero> + Copy,
             Rhs: Copy;
    fn convolve_fft<Rhs, const M: usize>(
        &self,
        rhs: &[Rhs; M]
    ) -> [<<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 recip_all(self) -> [<T as Inv>::Output; N]
       where T: Inv;
    fn recip_assign_all(&mut self)
       where T: Inv<Output = T>;
    fn conj_all(self) -> Self
       where T: ComplexFloat;
    fn conj_assign_all(&mut self)
       where T: ComplexFloat;
    fn fft_unscaled<const I: bool>(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum;
    fn fft(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum;
    fn ifft(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum;
    fn real_fft(&self, y: &mut [Complex<T>; { _ }])
       where T: Float,
             Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign;
    fn real_ifft(&mut self, x: &[Complex<T>; { _ }])
       where T: Float,
             Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign;

}

Required Methods§

source

fn sum(self) -> T
where T: AddAssign + Zero,

source

fn product(self) -> T
where T: MulAssign + One,

source

fn variance(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u8: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source

fn variance16(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u16: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source

fn variance32(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u32: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source

fn variance64(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u64: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source

fn avg(self) -> <T as Div>::Output
where u8: Into<T>, T: Div + AddAssign + Zero,

source

fn avg16(self) -> <T as Div>::Output
where u16: Into<T>, T: Div + AddAssign + Zero,

source

fn avg32(self) -> <T as Div>::Output
where u32: Into<T>, T: Div + AddAssign + Zero,

source

fn avg64(self) -> <T as Div>::Output
where u64: Into<T>, T: Div + AddAssign + Zero,

source

fn mul_dot<Rhs>(self, rhs: [Rhs; N]) -> <T as Mul<Rhs>>::Output
where T: Mul<Rhs, Output: AddAssign + Zero>,

source

fn magnitude_squared(self) -> <T as Mul<T>>::Output
where T: Mul<T, Output: AddAssign + Zero> + Copy,

source

fn magnitude(self) -> <T as Mul<T>>::Output
where T: Mul<T, Output: AddAssign + Zero + Float> + Copy,

source

fn magnitude_inv(self) -> <T as Mul<T>>::Output
where T: Mul<T, Output: AddAssign + Zero + Float> + Copy,

source

fn normalize(self) -> [<T as Mul<<T as Mul<T>>::Output>>::Output; N]
where T: Mul<T, Output: AddAssign + Zero + Float + Copy> + Mul<<T as Mul<T>>::Output> + Copy,

source

fn normalize_to<Rhs>( self, magnitude: Rhs ) -> [<T as Mul<<<T as Mul<T>>::Output as Mul<Rhs>>::Output>>::Output; N]
where T: Mul<T, Output: AddAssign + Zero + Float + Mul<Rhs, Output: Copy>> + Mul<<<T as Mul<T>>::Output as Mul<Rhs>>::Output> + Copy,

source

fn normalize_assign(&mut self)
where T: Mul<T, Output: AddAssign + Zero + Float + Copy> + MulAssign<<T as Mul<T>>::Output> + Copy,

source

fn normalize_assign_to<Rhs>(&mut self, magnitude: Rhs)
where T: Mul<T, Output: AddAssign + Zero + Float + Mul<Rhs, Output: Copy>> + MulAssign<<<T as Mul<T>>::Output as Mul<Rhs>>::Output> + Copy,

source

fn polynomial<Rhs>(self, rhs: Rhs) -> T
where T: AddAssign + MulAssign<Rhs> + Zero, Rhs: Copy,

source

fn convolve_direct<Rhs, const M: usize>( &self, rhs: &[Rhs; M] ) -> [<T as Mul<Rhs>>::Output; { _ }]
where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

Performs direct convolution. This is equivalent to a polynomial multiplication.

§Examples

Convolving a unit impulse yields the impulse response.

#![feature(generic_const_exprs)]
 
use array_math::*;
 
let x = [1.0];
let h = [1.0, 0.6, 0.3];
 
let y = x.convolve_direct(&h);
 
assert_eq!(y, h);

Convolution can be done directly O(n^2) or using FFT O(nlog(n)).

#![feature(generic_arg_infer)]
#![feature(generic_const_exprs)]
 
use array_math::*;
 
let x = [1.0, 0.0, 1.5, 0.0, 0.0, -1.0];
let h = [1.0, 0.6, 0.3];
 
let y_fft = x.convolve_fft(&h);
let y_direct = x.convolve_direct(&h);
 
let avg_error = y_fft.comap(y_direct, |y_fft: f64, y_direct: f64| (y_fft - y_direct).abs()).avg();
assert!(avg_error < 1.0e-15);
source

fn convolve_fft<Rhs, const M: usize>( &self, rhs: &[Rhs; M] ) -> [<<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 convolution using FFT.

§Examples

Convolution can be done directly O(n^2) or using FFT O(nlog(n)).

#![feature(generic_arg_infer)]
#![feature(generic_const_exprs)]
 
use array_math::*;
 
let x = [1.0, 0.0, 1.5, 0.0, 0.0, -1.0];
let h = [1.0, 0.6, 0.3];
 
let y_fft = x.convolve_fft(&h);
let y_direct = x.convolve_direct(&h);
 
let avg_error = y_fft.comap(y_direct, |y_fft: f64, y_direct: f64| (y_fft - y_direct).abs()).avg();
assert!(avg_error < 1.0e-15);
source

fn recip_all(self) -> [<T as Inv>::Output; N]
where T: Inv,

source

fn recip_assign_all(&mut self)
where T: Inv<Output = T>,

source

fn conj_all(self) -> Self
where T: ComplexFloat,

source

fn conj_assign_all(&mut self)
where T: ComplexFloat,

source

fn fft_unscaled<const I: bool>(&mut self)
where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum,

source

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

Performs an iterative, in-place radix-2 FFT algorithm as described in https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm#Data_reordering,_bit_reversal,_and_in-place_algorithms. If N is not a power of two, it uses the DFT, which is a lot slower.

§Examples
#![feature(generic_const_exprs)]
 
use num::Complex;
use array_math::*;
 
let x = [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
    .map(|x| <Complex<_> as From<_>>::from(x));
 
let mut y = x;
 
y.fft();
y.ifft();
 
let avg_error = x.comap(y, |x, y| (x - y).norm()).avg();
assert!(avg_error < 1.0e-16);
source

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

Performs an iterative, in-place radix-2 IFFT algorithm as described in https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm#Data_reordering,_bit_reversal,_and_in-place_algorithms. If N is not a power of two, it uses the IDFT, which is a lot slower.

§Examples
#![feature(generic_const_exprs)]
 
use num::Complex;
use array_math::*;
 
let x = [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
    .map(|x| <Complex<_> as From<_>>::from(x));
 
let mut y = x;
 
y.fft();
y.ifft();
 
let avg_error = x.comap(y, |x, y| (x - y).norm()).avg();
assert!(avg_error < 1.0e-16);
source

fn real_fft(&self, y: &mut [Complex<T>; { _ }])
where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

Performs the FFT on an array of real floating-point numbers of length N. The result is an array of complex numbers of length N/2 + 1. This is truncated because the last half of the values are redundant, since they are a conjugate mirror-image of the first half. if N is not a power of two, the naive DFT is used instead, which is a lot slower.

§Examples
#![feature(generic_arg_infer)]
#![feature(generic_const_exprs)]
 
use num::{Complex, Zero};
use array_math::*;
 
let x = [1.0, 1.0, 0.0, 0.0];
 
let mut z = [Complex::zero(); _];
x.real_fft(&mut z);
 
let mut y = [0.0; _];
y.real_ifft(&z);
 
assert_eq!(x, y);
source

fn real_ifft(&mut self, x: &[Complex<T>; { _ }])
where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

Performs the IFFT on a truncated array of complex floating-point numbers of length N/2 + 1. The result is an array of real numbers of length N. if N is not a power of two, the naive IDFT is used instead, which is a lot slower.

§Examples
#![feature(generic_arg_infer)]
#![feature(generic_const_exprs)]
 
use num::{Complex, Zero};
use array_math::*;
 
let x = [1.0, 1.0, 0.0, 0.0];
 
let mut z = [Complex::zero(); _];
x.real_fft(&mut z);
 
let mut y = [0.0; _];
y.real_ifft(&z);
 
assert_eq!(x, y);

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

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

source§

fn sum(self) -> T
where T: AddAssign + Zero,

source§

fn product(self) -> T
where T: MulAssign + One,

source§

fn variance(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u8: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source§

fn variance16(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u16: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source§

fn variance32(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u32: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source§

fn variance64(self) -> <T as Mul>::Output
where Self: ArrayOps<T, N> + Copy, u64: Into<T>, T: Div<Output: Mul<Output: Neg<Output = <T as Mul>::Output>> + Copy> + Mul<Output: AddAssign> + AddAssign + Zero,

source§

fn avg(self) -> <T as Div>::Output
where u8: Into<T>, T: Div + AddAssign + Zero,

source§

fn avg16(self) -> <T as Div>::Output
where u16: Into<T>, T: Div + AddAssign + Zero,

source§

fn avg32(self) -> <T as Div>::Output
where u32: Into<T>, T: Div + AddAssign + Zero,

source§

fn avg64(self) -> <T as Div>::Output
where u64: Into<T>, T: Div + AddAssign + Zero,

source§

fn mul_dot<Rhs>(self, rhs: [Rhs; N]) -> <T as Mul<Rhs>>::Output
where T: Mul<Rhs, Output: AddAssign + Zero>,

source§

fn magnitude_squared(self) -> <T as Mul<T>>::Output
where T: Mul<T, Output: AddAssign + Zero> + Copy,

source§

fn magnitude(self) -> <T as Mul<T>>::Output
where T: Mul<T, Output: AddAssign + Zero + Float> + Copy,

source§

fn magnitude_inv(self) -> <T as Mul<T>>::Output
where T: Mul<T, Output: AddAssign + Zero + Float> + Copy,

source§

fn normalize(self) -> [<T as Mul<<T as Mul<T>>::Output>>::Output; N]
where T: Mul<T, Output: AddAssign + Zero + Float + Copy> + Mul<<T as Mul<T>>::Output> + Copy,

source§

fn normalize_to<Rhs>( self, magnitude: Rhs ) -> [<T as Mul<<<T as Mul<T>>::Output as Mul<Rhs>>::Output>>::Output; N]
where T: Mul<T, Output: AddAssign + Zero + Float + Mul<Rhs, Output: Copy>> + Mul<<<T as Mul<T>>::Output as Mul<Rhs>>::Output> + Copy,

source§

fn normalize_assign(&mut self)
where T: Mul<T, Output: AddAssign + Zero + Float + Copy> + MulAssign<<T as Mul<T>>::Output> + Copy,

source§

fn normalize_assign_to<Rhs>(&mut self, magnitude: Rhs)
where T: Mul<T, Output: AddAssign + Zero + Float + Mul<Rhs, Output: Copy>> + MulAssign<<<T as Mul<T>>::Output as Mul<Rhs>>::Output> + Copy,

source§

fn polynomial<Rhs>(self, rhs: Rhs) -> T
where T: AddAssign + MulAssign<Rhs> + Zero, Rhs: Copy,

source§

fn convolve_direct<Rhs, const M: usize>( &self, rhs: &[Rhs; M] ) -> [<T as Mul<Rhs>>::Output; { _ }]
where T: Mul<Rhs, Output: AddAssign + Zero> + Copy, Rhs: Copy,

source§

fn convolve_fft<Rhs, const M: usize>( &self, rhs: &[Rhs; M] ) -> [<<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>,

source§

fn recip_all(self) -> [<T as Inv>::Output; N]
where T: Inv,

source§

fn recip_assign_all(&mut self)
where T: Inv<Output = T>,

source§

fn conj_all(self) -> Self
where T: ComplexFloat,

source§

fn conj_assign_all(&mut self)
where T: ComplexFloat,

source§

fn fft_unscaled<const I: bool>(&mut self)
where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + From<Complex<T::Real>> + Sum,

source§

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

source§

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

source§

fn real_fft(&self, y: &mut [Complex<T>; { _ }])
where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

source§

fn real_ifft(&mut self, x: &[Complex<T>; { _ }])
where T: Float, Complex<T>: ComplexFloat<Real = T> + MulAssign + AddAssign,

Implementors§