Trait array_math::SliceMath

source · 
pub trait SliceMath<T>: SliceOps<T> {

Show 38 methods    // Required methods
    fn recip_assign_all(&mut self)
       where T: Inv<Output = T>;
    fn conj_assign_all(&mut self)
       where T: ComplexFloat;
    fn convolve_direct<Rhs, C>(&self, rhs: &[Rhs]) -> C
       where T: Mul<Rhs> + Copy,
             <T as Mul<Rhs>>::Output: AddAssign + Zero,
             Rhs: Copy,
             C: FromIterator<<T as Mul<Rhs>>::Output>;
    fn convolve_real_fft<Rhs, C>(&self, rhs: &[Rhs]) -> C
       where T: Float + Copy,
             Rhs: Float + Copy,
             Complex<T>: MulAssign + AddAssign + ComplexFloat<Real = T> + Mul<Complex<Rhs>>,
             <Complex<T> as Mul<Complex<Rhs>>>::Output: ComplexFloat + Into<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>,
             <<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real: Float,
             Complex<Rhs>: MulAssign + AddAssign + ComplexFloat<Real = Rhs>,
             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>,
             C: FromIterator<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>;
    fn convolve_fft<Rhs, C>(&self, rhs: &[Rhs]) -> C
       where T: ComplexFloat + Mul<Rhs>,
             <T as Mul<Rhs>>::Output: ComplexFloat + From<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + 'static,
             Rhs: ComplexFloat,
             Complex<<T as ComplexFloat>::Real>: From<T> + AddAssign + MulAssign + Mul<Complex<<Rhs as ComplexFloat>::Real>>,
             <Complex<<T as ComplexFloat>::Real> as Mul<Complex<<Rhs as ComplexFloat>::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 as ComplexFloat>::Real>: From<Rhs> + AddAssign + MulAssign,
             C: FromIterator<<T as Mul<Rhs>>::Output>;
    fn dtft(
        &self,
        omega: <T as ComplexFloat>::Real
    ) -> Complex<<T as ComplexFloat>::Real>
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>>,
             Complex<<T as ComplexFloat>::Real>: ComplexFloat<Real = <T as ComplexFloat>::Real> + MulAssign + AddAssign;
    fn fft_unscaled<const I: bool>(&mut self)
       where T: ComplexFloat + MulAssign + AddAssign + From<Complex<<T as ComplexFloat>::Real>> + Sum,
             <T as ComplexFloat>::Real: Float;
    fn fft(&mut self)
       where T: ComplexFloat + MulAssign + AddAssign + From<Complex<<T as ComplexFloat>::Real>> + Sum,
             <T as ComplexFloat>::Real: Float;
    fn ifft(&mut self)
       where T: ComplexFloat + MulAssign + AddAssign + From<Complex<<T as ComplexFloat>::Real>> + Sum,
             <T as ComplexFloat>::Real: Float;
    fn fwht_unscaled(&mut self)
       where T: Add<Output = T> + Sub<Output = T> + Copy;
    fn fwht(&mut self)
       where T: ComplexFloat + MulAssign<<T as ComplexFloat>::Real>;
    fn ifwht(&mut self)
       where T: ComplexFloat + MulAssign<<T as ComplexFloat>::Real>;
    fn fht(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign;
    fn ifht(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign;
    fn dst_i(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + DivAssign<<T as ComplexFloat>::Real>;
    fn dst_ii(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign;
    fn dst_iii(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>>;
    fn dst_iv(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>>;
    fn dct_i(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + DivAssign<<T as ComplexFloat>::Real> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + DivAssign<<T as ComplexFloat>::Real>;
    fn dct_ii(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign;
    fn dct_iii(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>> + DivAssign<<T as ComplexFloat>::Real>;
    fn dct_iv(&mut self)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T>,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>>;
    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;
    fn polynomial<Rhs>(&self, rhs: Rhs) -> T
       where T: AddAssign + MulAssign<Rhs> + Zero + Copy,
             Rhs: Copy;
    fn rpolynomial<Rhs>(&self, rhs: Rhs) -> T
       where T: AddAssign + MulAssign<Rhs> + Zero + Copy,
             Rhs: Copy;
    fn derivate_polynomial<S>(&self) -> S
       where T: NumCast + Zero + Mul + Copy,
             S: FromIterator<<T as Mul>::Output>;
    fn derivate_rpolynomial<S>(&self) -> S
       where T: NumCast + Zero + Mul + Copy,
             S: FromIterator<<T as Mul>::Output>;
    fn integrate_polynomial<S>(&self, c: <T as Div>::Output) -> S
       where T: NumCast + Zero + Div + Copy,
             S: FromIterator<<T as Div>::Output>;
    fn integrate_rpolynomial<S>(&self, c: <T as Div>::Output) -> S
       where T: NumCast + Zero + Div + Copy,
             S: FromIterator<<T as Div>::Output>;
    fn trim_zeros(&self) -> &[T]
       where T: Zero;
    fn trim_zeros_front(&self) -> &[T]
       where T: Zero;
    fn trim_zeros_back(&self) -> &[T]
       where T: Zero;
    fn trim_zeros_mut(&mut self) -> &mut [T]
       where T: Zero;
    fn trim_zeros_front_mut(&mut self) -> &mut [T]
       where T: Zero;
    fn trim_zeros_back_mut(&mut self) -> &mut [T]
       where T: Zero;
    fn frac_rotate_right(&mut self, shift: <T as ComplexFloat>::Real)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T> + SubAssign,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign;
    fn frac_rotate_left(&mut self, shift: <T as ComplexFloat>::Real)
       where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static,
             <T as ComplexFloat>::Real: Into<T> + SubAssign,
             Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign;

}

Required Methods§

source

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

source

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

source

fn convolve_direct<Rhs, C>(&self, rhs: &[Rhs]) -> C
where T: Mul<Rhs> + Copy, <T as Mul<Rhs>>::Output: AddAssign + Zero, Rhs: Copy, C: FromIterator<<T as Mul<Rhs>>::Output>,

source

fn convolve_real_fft<Rhs, C>(&self, rhs: &[Rhs]) -> C
where T: Float + Copy, Rhs: Float + Copy, Complex<T>: MulAssign + AddAssign + ComplexFloat<Real = T> + Mul<Complex<Rhs>>, <Complex<T> as Mul<Complex<Rhs>>>::Output: ComplexFloat + Into<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>, <<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real: Float, Complex<Rhs>: MulAssign + AddAssign + ComplexFloat<Real = Rhs>, 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>, C: FromIterator<<<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_const_exprs)]
 
use slice_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: Vec<f64> = x.convolve_real_fft(&h);
let y_direct: Vec<f64> = x.convolve_direct(&h);
 
let avg_error = y_fft.into_iter()
    .zip(y_direct.into_iter())
    .map(|(y_fft, y_direct)| (y_fft - y_direct).abs())
    .sum::<f64>()/x.len() as f64;
assert!(avg_error < 1.0e-15);
source

fn convolve_fft<Rhs, C>(&self, rhs: &[Rhs]) -> C
where T: ComplexFloat + Mul<Rhs>, <T as Mul<Rhs>>::Output: ComplexFloat + From<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + 'static, Rhs: ComplexFloat, Complex<<T as ComplexFloat>::Real>: From<T> + AddAssign + MulAssign + Mul<Complex<<Rhs as ComplexFloat>::Real>>, <Complex<<T as ComplexFloat>::Real> as Mul<Complex<<Rhs as ComplexFloat>::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 as ComplexFloat>::Real>: From<Rhs> + AddAssign + MulAssign, C: FromIterator<<T as Mul<Rhs>>::Output>,

source

fn dtft( &self, omega: <T as ComplexFloat>::Real ) -> Complex<<T as ComplexFloat>::Real>
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>>, Complex<<T as ComplexFloat>::Real>: ComplexFloat<Real = <T as ComplexFloat>::Real> + MulAssign + AddAssign,

source

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

source

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

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 length is not a power of two, it uses the DFT, which is a lot slower.

§Examples
#![feature(generic_const_exprs)]
 
use num::Complex;
use slice_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.as_mut_slice().fft();
y.as_mut_slice().ifft();
 
let avg_error = x.into_iter()
    .zip(y.into_iter())
    .map(|(x, y)| (x - y).norm())
    .sum::<f64>()/x.len() as f64;
assert!(avg_error < 1.0e-16);
source

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

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 length is not a power of two, it uses the IDFT, which is a lot slower.

§Examples
#![feature(generic_const_exprs)]
 
use num::Complex;
use slice_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.as_mut_slice().fft();
y.as_mut_slice().ifft();
 
let avg_error = x.into_iter()
    .zip(y.into_iter())
    .map(|(x, y)| (x - y).norm())
    .sum::<f64>()/x.len() as f64;
assert!(avg_error < 1.0e-16);
source

fn fwht_unscaled(&mut self)
where T: Add<Output = T> + Sub<Output = T> + Copy,

Walsh-Hadamard transform

source

fn fwht(&mut self)
where T: ComplexFloat + MulAssign<<T as ComplexFloat>::Real>,

Normalized Walsh-Hadamard transform

source

fn ifwht(&mut self)
where T: ComplexFloat + MulAssign<<T as ComplexFloat>::Real>,

Normalized inverse Walsh-Hadamard transform

source

fn fht(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source

fn ifht(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source

fn dst_i(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + DivAssign<<T as ComplexFloat>::Real>,

source

fn dst_ii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source

fn dst_iii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>>,

source

fn dst_iv(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>>,

source

fn dct_i(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + DivAssign<<T as ComplexFloat>::Real> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + DivAssign<<T as ComplexFloat>::Real>,

source

fn dct_ii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source

fn dct_iii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>> + DivAssign<<T as ComplexFloat>::Real>,

source

fn dct_iv(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>>,

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,

source

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

source

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

source

fn derivate_polynomial<S>(&self) -> S
where T: NumCast + Zero + Mul + Copy, S: FromIterator<<T as Mul>::Output>,

source

fn derivate_rpolynomial<S>(&self) -> S
where T: NumCast + Zero + Mul + Copy, S: FromIterator<<T as Mul>::Output>,

source

fn integrate_polynomial<S>(&self, c: <T as Div>::Output) -> S
where T: NumCast + Zero + Div + Copy, S: FromIterator<<T as Div>::Output>,

source

fn integrate_rpolynomial<S>(&self, c: <T as Div>::Output) -> S
where T: NumCast + Zero + Div + Copy, S: FromIterator<<T as Div>::Output>,

source

fn trim_zeros(&self) -> &[T]
where T: Zero,

source

fn trim_zeros_front(&self) -> &[T]
where T: Zero,

source

fn trim_zeros_back(&self) -> &[T]
where T: Zero,

source

fn trim_zeros_mut(&mut self) -> &mut [T]
where T: Zero,

source

fn trim_zeros_front_mut(&mut self) -> &mut [T]
where T: Zero,

source

fn trim_zeros_back_mut(&mut self) -> &mut [T]
where T: Zero,

source

fn frac_rotate_right(&mut self, shift: <T as ComplexFloat>::Real)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T> + SubAssign, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source

fn frac_rotate_left(&mut self, shift: <T as ComplexFloat>::Real)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T> + SubAssign, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl<T> SliceMath<T> for [T]

source§

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

source§

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

source§

fn convolve_direct<Rhs, C>(&self, rhs: &[Rhs]) -> C
where T: Mul<Rhs> + Copy, <T as Mul<Rhs>>::Output: AddAssign + Zero, Rhs: Copy, C: FromIterator<<T as Mul<Rhs>>::Output>,

source§

fn convolve_real_fft<Rhs, C>(&self, rhs: &[Rhs]) -> C
where T: Float + Copy, Rhs: Float + Copy, Complex<T>: MulAssign + AddAssign + ComplexFloat<Real = T> + Mul<Complex<Rhs>>, <Complex<T> as Mul<Complex<Rhs>>>::Output: ComplexFloat + Into<Complex<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>>, <<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real: Float, Complex<Rhs>: MulAssign + AddAssign + ComplexFloat<Real = Rhs>, 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>, C: FromIterator<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real>,

source§

fn convolve_fft<Rhs, C>(&self, rhs: &[Rhs]) -> C
where T: ComplexFloat + Mul<Rhs>, <T as Mul<Rhs>>::Output: ComplexFloat + From<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + 'static, Rhs: ComplexFloat, Complex<<T as ComplexFloat>::Real>: From<T> + AddAssign + MulAssign + Mul<Complex<<Rhs as ComplexFloat>::Real>>, <Complex<<T as ComplexFloat>::Real> as Mul<Complex<<Rhs as ComplexFloat>::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 as ComplexFloat>::Real>: From<Rhs> + AddAssign + MulAssign, C: FromIterator<<T as Mul<Rhs>>::Output>,

source§

fn dtft( &self, omega: <T as ComplexFloat>::Real ) -> Complex<<T as ComplexFloat>::Real>
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>>, Complex<<T as ComplexFloat>::Real>: ComplexFloat<Real = <T as ComplexFloat>::Real> + MulAssign + AddAssign,

source§

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

source§

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

source§

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

source§

fn fwht_unscaled(&mut self)
where T: Add<Output = T> + Sub<Output = T> + Copy,

source§

fn fwht(&mut self)
where T: ComplexFloat + MulAssign<<T as ComplexFloat>::Real>,

source§

fn ifwht(&mut self)
where T: ComplexFloat + MulAssign<<T as ComplexFloat>::Real>,

source§

fn fht(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T> + Into<Complex<<T as ComplexFloat>::Real>>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source§

fn ifht(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T> + Into<Complex<<T as ComplexFloat>::Real>>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source§

fn dst_i(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + DivAssign<<T as ComplexFloat>::Real>,

source§

fn dst_ii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source§

fn dst_iii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<<T as ComplexFloat>::Real, Output = Complex<<T as ComplexFloat>::Real>, Output = Complex<<T as ComplexFloat>::Real>> + Mul<T>,

source§

fn dst_iv(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<<T as ComplexFloat>::Real, Output = Complex<<T as ComplexFloat>::Real>, Output = Complex<<T as ComplexFloat>::Real>> + Mul<T>,

source§

fn dct_i(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + DivAssign<<T as ComplexFloat>::Real> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + DivAssign<<T as ComplexFloat>::Real>,

source§

fn dct_ii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source§

fn dct_iii(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>, Output = Complex<<T as ComplexFloat>::Real>> + Mul<<T as ComplexFloat>::Real> + DivAssign<<T as ComplexFloat>::Real>,

source§

fn dct_iv(&mut self)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T>, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<<T as ComplexFloat>::Real>, Output = Complex<<T as ComplexFloat>::Real>> + Mul<<T as ComplexFloat>::Real>,

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,

source§

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

source§

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

source§

fn derivate_polynomial<S>(&self) -> S
where T: NumCast + Zero + Mul + Copy, S: FromIterator<<T as Mul>::Output>,

source§

fn derivate_rpolynomial<S>(&self) -> S
where T: NumCast + Zero + Mul + Copy, S: FromIterator<<T as Mul>::Output>,

source§

fn integrate_polynomial<S>(&self, c: <T as Div>::Output) -> S
where T: NumCast + Zero + Div + Copy, S: FromIterator<<T as Div>::Output>,

source§

fn integrate_rpolynomial<S>(&self, c: <T as Div>::Output) -> S
where T: NumCast + Zero + Div + Copy, S: FromIterator<<T as Div>::Output>,

source§

fn trim_zeros(&self) -> &[T]
where T: Zero,

source§

fn trim_zeros_front(&self) -> &[T]
where T: Zero,

source§

fn trim_zeros_back(&self) -> &[T]
where T: Zero,

source§

fn trim_zeros_mut(&mut self) -> &mut [T]
where T: Zero,

source§

fn trim_zeros_front_mut(&mut self) -> &mut [T]
where T: Zero,

source§

fn trim_zeros_back_mut(&mut self) -> &mut [T]
where T: Zero,

source§

fn frac_rotate_right(&mut self, shift: <T as ComplexFloat>::Real)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T> + SubAssign, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

source§

fn frac_rotate_left(&mut self, shift: <T as ComplexFloat>::Real)
where T: ComplexFloat + Into<Complex<<T as ComplexFloat>::Real>> + 'static, <T as ComplexFloat>::Real: Into<T> + SubAssign, Complex<<T as ComplexFloat>::Real>: AddAssign + MulAssign,

Implementors§