Trait slice_math::SliceMath

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

Show 41 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, Output: AddAssign + Zero> + Copy,
             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>, 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 + MulAssign<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real> + 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, Output: ComplexFloat<Real: Into<<T as Mul<Rhs>>::Output>> + 'static> + Into<Complex<T::Real>>,
             Rhs: ComplexFloat + Into<Complex<Rhs::Real>>,
             Complex<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real>: Into<<Complex<T::Real> as Mul<Complex<Rhs::Real>>>::Output>,
             Complex<T::Real>: AddAssign + MulAssign + Mul<Complex<Rhs::Real>, Output: ComplexFloat<Real = <<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + Sum + 'static>,
             Complex<Rhs::Real>: AddAssign + MulAssign,
             C: FromIterator<<T as Mul<Rhs>>::Output>;
    fn cconvolve_direct<Rhs, C>(&self, rhs: &[Rhs]) -> C
       where T: Mul<Rhs, Output: AddAssign + Zero> + Copy,
             Rhs: Copy,
             C: FromIterator<<T as Mul<Rhs>>::Output>;
    fn cconvolve_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>, 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 + MulAssign<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real> + 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 cconvolve_fft<Rhs, C>(&self, rhs: &[Rhs]) -> C
       where T: ComplexFloat + Mul<Rhs, Output: ComplexFloat<Real: Into<<T as Mul<Rhs>>::Output>> + 'static> + Into<Complex<T::Real>>,
             Rhs: ComplexFloat + Into<Complex<Rhs::Real>>,
             Complex<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real>: Into<<Complex<T::Real> as Mul<Complex<Rhs::Real>>>::Output>,
             Complex<T::Real>: AddAssign + MulAssign + Mul<Complex<Rhs::Real>, Output: ComplexFloat<Real = <<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + Sum + 'static>,
             Complex<Rhs::Real>: AddAssign + MulAssign,
             C: FromIterator<<T as Mul<Rhs>>::Output>;
    fn dtft(&self, omega: T::Real) -> Complex<T::Real>
       where T: ComplexFloat + Into<Complex<T::Real>>,
             Complex<T::Real>: ComplexFloat<Real = T::Real> + MulAssign + AddAssign;
    fn fft_unscaled<const I: bool>(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + Sum,
             Complex<T::Real>: Into<T>;
    fn fft(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + Sum,
             Complex<T::Real>: Into<T>;
    fn ifft(&mut self)
       where T: ComplexFloat<Real: Float> + MulAssign + AddAssign + MulAssign<T::Real> + Sum,
             Complex<T::Real>: Into<T>;
    fn fwht_unscaled(&mut self)
       where T: Add<Output = T> + Sub<Output = T> + Copy;
    fn fwht(&mut self)
       where T: ComplexFloat + MulAssign<T::Real>;
    fn ifwht(&mut self)
       where T: ComplexFloat + MulAssign<T::Real>;
    fn fht(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign;
    fn ifht(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>;
    fn dst_i(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + DivAssign<T::Real>;
    fn dst_ii(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign;
    fn dst_iii(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real> + Mul<T, Output = Complex<T::Real>>;
    fn dst_iv(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<T::Real>>;
    fn dct_i(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + DivAssign<T::Real> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + DivAssign<T::Real>;
    fn dct_ii(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign;
    fn dct_iii(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<T::Real>> + DivAssign<T::Real>;
    fn dct_iv(&mut self)
       where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<T::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 + MulAssign<T>;
    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::Real)
       where T: ComplexFloat<Real: Into<T> + SubAssign> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>;
    fn frac_rotate_left(&mut self, shift: T::Real)
       where T: ComplexFloat<Real: Into<T> + SubAssign> + Into<Complex<T::Real>> + 'static,
             Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>;

}

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, Output: AddAssign + Zero> + Copy, 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>, 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 + MulAssign<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real> + 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, Output: ComplexFloat<Real: Into<<T as Mul<Rhs>>::Output>> + 'static> + Into<Complex<T::Real>>, Rhs: ComplexFloat + Into<Complex<Rhs::Real>>, Complex<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real>: Into<<Complex<T::Real> as Mul<Complex<Rhs::Real>>>::Output>, Complex<T::Real>: AddAssign + MulAssign + Mul<Complex<Rhs::Real>, Output: ComplexFloat<Real = <<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + Sum + 'static>, Complex<Rhs::Real>: AddAssign + MulAssign, C: FromIterator<<T as Mul<Rhs>>::Output>,

source

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

source

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

source

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

source

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

source

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

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<Real: Float> + MulAssign + AddAssign + MulAssign<T::Real> + Sum, Complex<T::Real>: Into<T>,

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

Normalized Walsh-Hadamard transform

source

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

Normalized inverse Walsh-Hadamard transform

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

fn dct_iv(&mut self)
where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<T::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 + MulAssign<T>,

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::Real)
where T: ComplexFloat<Real: Into<T> + SubAssign> + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>,

source

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

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, Output: AddAssign + Zero> + Copy, 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>, 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 + MulAssign<<<Complex<T> as Mul<Complex<Rhs>>>::Output as ComplexFloat>::Real> + 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, Output: ComplexFloat<Real: Into<<T as Mul<Rhs>>::Output>> + 'static> + Into<Complex<T::Real>>, Rhs: ComplexFloat + Into<Complex<Rhs::Real>>, Complex<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real>: Into<<Complex<T::Real> as Mul<Complex<Rhs::Real>>>::Output>, Complex<T::Real>: AddAssign + MulAssign + Mul<Complex<Rhs::Real>, Output: ComplexFloat<Real = <<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + MulAssign + AddAssign + MulAssign<<<T as Mul<Rhs>>::Output as ComplexFloat>::Real> + Sum + 'static>, Complex<Rhs::Real>: AddAssign + MulAssign, C: FromIterator<<T as Mul<Rhs>>::Output>,

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

fn dct_iv(&mut self)
where T: ComplexFloat<Real: Into<T>> + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + Mul<T, Output = Complex<T::Real>> + Mul<T::Real, Output = Complex<T::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 + MulAssign<T>,

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::Real)
where T: ComplexFloat<Real: Into<T> + SubAssign> + Into<Complex<T::Real>> + 'static, Complex<T::Real>: AddAssign + MulAssign + MulAssign<T::Real>,

source§

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

Implementors§