Struct funspace::fourier::FourierC2c

pub struct FourierC2c<A> { /* private fields */ }

Container for fourier space (Complex-to-complex)

Implementations

impl<A: FloatNum> FourierC2c<A>

pub fn new(n: usize) -> Self

Returns a new Fourier Basis for complex-to-complex transforms

pub fn nodes(n: usize) -> Vec<A>

Equispaced points on intervall [0, 2pi[

Panics

Float conversion fails

pub fn wavenumber(n: usize) -> Vec<Complex<A>>

Return complex wavenumber vector(0, 1, 2, -3, -2, -1)

Panics

Float conversion fails

Trait Implementations

impl<A: FloatNum> BaseElements for FourierC2c<A>

type RealNum = A

Real valued scalar type

fn base_kind(&self) -> BaseKind

Return kind of base

fn transform_kind(&self) -> TransformKind

Return kind of transform

fn coords(&self) -> Vec<A>

Coordinates in physical space

impl<A, T> BaseFromOrtho<T> for FourierC2c<A> where
    A: FloatNum,
    T: ScalarNum, 

fn to_ortho_slice(&self, indata: &[T], outdata: &mut [T])

Composite space coefficients -> Orthogonal space coefficients

fn from_ortho_slice(&self, indata: &[T], outdata: &mut [T])

Orthogonal space coefficients -> Composite space coefficients

fn to_ortho<S, D>(&self, indata: &ArrayBase<S, D>, axis: usize) -> Array<T, D> where
    S: Data<Elem = T>,
    D: Dimension, 

Composite coefficients -> Orthogonal coefficients

fn to_ortho_inplace<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = T>,
    S2: Data<Elem = T> + DataMut,
    D: Dimension,
    T: Clone,
    T: Clone + Zero + Copy, 

Composite coefficients -> Orthogonal coefficients

fn from_ortho<S, D>(&self, indata: &ArrayBase<S, D>, axis: usize) -> Array<T, D> where
    S: Data<Elem = T>,
    D: Dimension, 

Composite coefficients -> Orthogonal coefficients

fn from_ortho_inplace<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = T>,
    S2: Data<Elem = T> + DataMut,
    D: Dimension,
    T: Clone,
    T: Clone + Zero + Copy, 

Composite coefficients -> Orthogonal coefficients

fn to_ortho_par<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    axis: usize
) -> Array<T, D> where
    S: Data<Elem = T>,
    D: Dimension,
    Self: Sync,
    T: Send + Sync, 

Composite coefficients -> Orthogonal coefficients (Parallel)

fn to_ortho_inplace_par<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = T>,
    S2: Data<Elem = T> + DataMut,
    D: Dimension,
    T: Clone + Send + Sync,
    T: Clone + Zero + Copy + Send + Sync,
    Self: Sync, 

Composite coefficients -> Orthogonal coefficients (Parallel)

fn from_ortho_par<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    axis: usize
) -> Array<T, D> where
    S: Data<Elem = T>,
    D: Dimension,
    Self: Sync,
    T: Send + Sync, 

Composite coefficients -> Orthogonal coefficients (Parallel)

fn from_ortho_inplace_par<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = T>,
    S2: Data<Elem = T> + DataMut,
    D: Dimension,
    T: Clone + Send + Sync,
    T: Clone + Zero + Copy + Send + Sync,
    Self: Sync, 

Composite coefficients -> Orthogonal coefficients (Parallel)

impl<A, T> BaseGradient<T> for FourierC2c<A> where
    A: FloatNum,
    T: ScalarNum + Add<Complex<A>, Output = T> + Mul<Complex<A>, Output = T> + Div<Complex<A>, Output = T> + Sub<Complex<A>, Output = T>, 

fn gradient_slice(&self, indata: &[T], outdata: &mut [T], n_times: usize)

Differentiate along slice

use funspace::traits::BaseGradient;
use funspace::fourier::FourierC2c;
use funspace::utils::approx_eq_complex;
use num_complex::Complex;
use num_traits::Zero;
let fo = FourierC2c::<f64>::new(5);
let mut k = FourierC2c::<f64>::wavenumber(5);
let expected: Vec<Complex<f64>> = k.iter().map(|x| x.powi(2)).collect();
let mut outdata = vec![Complex::<f64>::zero(); 5];
fo.gradient_slice(&k, &mut outdata, 1);
approx_eq_complex(&outdata, &expected);

Panics

When type conversion fails ( safe )

fn gradient<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    n_times: usize,
    axis: usize
) -> Array<T, D> where
    S: Data<Elem = T>,
    D: Dimension, 

Differentiate in spectral space

fn gradient_inplace<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    n_times: usize,
    axis: usize
) where
    S1: Data<Elem = T>,
    S2: Data<Elem = T> + DataMut,
    D: Dimension, 

Differentiate in spectral space

fn gradient_par<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    n_times: usize,
    axis: usize
) -> Array<T, D> where
    S: Data<Elem = T>,
    D: Dimension,
    T: Send + Sync,
    Self: Sync, 

Differentiate in spectral space

fn gradient_inplace_par<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    n_times: usize,
    axis: usize
) where
    S1: Data<Elem = T>,
    S2: Data<Elem = T> + DataMut,
    D: Dimension,
    T: Send + Sync,
    Self: Sync, 

Differentiate in spectral space

impl<A: FloatNum> BaseMatOpDiffmat for FourierC2c<A>

type NumType = Complex<A>

Scalar type of matrix

fn diffmat(&self, deriv: usize) -> Array2<Self::NumType>

Explicit differential operator $ D $

Matrix-based version of BaseGradient::gradient()

Panics

Type conversion fails

fn diffmat_pinv(
    &self,
    deriv: usize
) -> (Array2<Self::NumType>, Array2<Self::NumType>)

Explicit inverse of differential operator $ D^* $

Returns (D_pinv, I_pinv), where D_pinv is the pseudoinverse and I_pinv the corresponding pseudoidentity matrix, such that

D_pinv @ D = I_pinv

Can be used as a preconditioner.

impl<A: FloatNum> BaseMatOpLaplacian for FourierC2c<A>

type NumType = A

Scalar type of laplacian matrix

fn laplacian(&self) -> Array2<Self::NumType>

Laplacian $ L $

fn laplacian_pinv(&self) -> (Array2<Self::NumType>, Array2<Self::NumType>)

Pseudoinverse matrix of Laplacian $ L^{-1} $

Returns pseudoinverse and pseudoidentity,i.e (D_pinv, I_pinv)

D_pinv @ D = I_pinv
``

impl<A: FloatNum> BaseMatOpStencil for FourierC2c<A>

type NumType = A

Scalar type of matrix

fn stencil(&self) -> Array2<Self::NumType>

Transformation stencil composite -> orthogonal space

fn stencil_inv(&self) -> Array2<Self::NumType>

Inverse of transformation stencil

impl<A: FloatNum> BaseSize for FourierC2c<A>

fn len_phys(&self) -> usize

Size in physical space

fn len_spec(&self) -> usize

Size in spectral space

fn len_orth(&self) -> usize

Size of orthogonal space

impl<A: FloatNum> BaseTransform for FourierC2c<A>

fn forward_slice(
    &self,
    indata: &[Self::Physical],
    outdata: &mut [Self::Spectral]
)

Example

Forward transform

use funspace::traits::BaseTransform;
use funspace::fourier::FourierC2c;
use funspace::utils::approx_eq_complex;
use num_complex::Complex;
use num_traits::Zero;
let mut fo = FourierC2c::<f64>::new(4);
let indata = vec![
    Complex::new(1., 1.),
    Complex::new(2., 2.),
    Complex::new(3., 3.),
    Complex::new(4., 4.)
];
let expected = vec![
    Complex::new(10., 10.),
    Complex::new(-4., 0.),
    Complex::new(-2., -2.),
    Complex::new(0., -4.)
];
let mut outdata = vec![Complex::<f64>::zero(); 4];
fo.forward_slice(&indata, &mut outdata);
approx_eq_complex(&outdata, &expected);

fn backward_slice(
    &self,
    indata: &[Self::Spectral],
    outdata: &mut [Self::Physical]
)

Example

Backward transform

use funspace::traits::BaseTransform;
use funspace::fourier::FourierC2c;
use funspace::utils::approx_eq_complex;
use num_complex::Complex;
use num_traits::Zero;
let mut fo = FourierC2c::<f64>::new(4);
let indata = vec![
    Complex::new(10., 10.),
    Complex::new(-4., 0.),
    Complex::new(-2., -2.),
    Complex::new(0., -4.)
];
let expected = vec![
    Complex::new(1., 1.),
    Complex::new(2., 2.),
    Complex::new(3., 3.),
    Complex::new(4., 4.)
];
let mut outdata = vec![Complex::<f64>::zero(); 4];
fo.backward_slice(&indata, &mut outdata);
approx_eq_complex(&outdata, &expected);

type Physical = Complex<A>

Scalar type in physical space

type Spectral = Complex<A>

Scalar type in spectral space

fn forward<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Spectral, D> where
    S: Data<Elem = Self::Physical>,
    D: Dimension,
    Self::Physical: Clone,
    Self::Spectral: Zero + Clone + Copy, 

Physical values -> Spectral coefficients

fn forward_inplace<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Physical>,
    S2: Data<Elem = Self::Spectral> + DataMut,
    D: Dimension,
    Self::Physical: Clone,
    Self::Spectral: Clone + Zero + Copy, 

Physical values -> Spectral coefficients

fn backward<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Physical, D> where
    S: Data<Elem = Self::Spectral>,
    D: Dimension,
    Self::Spectral: Clone,
    Self::Physical: Zero + Clone + Copy, 

Spectral coefficients -> Physical values

fn backward_inplace<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Physical> + DataMut,
    D: Dimension,
    Self::Spectral: Clone,
    Self::Physical: Clone + Zero + Copy, 

Spectral coefficients -> Physical values

fn forward_par<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Spectral, D> where
    S: Data<Elem = Self::Physical>,
    D: Dimension,
    Self::Physical: Clone + Send + Sync,
    Self::Spectral: Zero + Clone + Copy + Send + Sync,
    Self: Sync, 

Physical values -> Spectral coefficients (Parallel)

fn forward_inplace_par<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Physical>,
    S2: Data<Elem = Self::Spectral> + DataMut,
    D: Dimension,
    Self::Physical: Clone + Send + Sync,
    Self::Spectral: Clone + Zero + Copy + Send + Sync,
    Self: Sync, 

Physical values -> Spectral coefficients (Parallel)

fn backward_par<S, D>(
    &self,
    indata: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Physical, D> where
    S: Data<Elem = Self::Spectral>,
    D: Dimension,
    Self::Spectral: Clone + Send + Sync,
    Self::Physical: Zero + Clone + Copy + Send + Sync,
    Self: Sync, 

Spectral coefficients -> Physical values (Parallel)

fn backward_inplace_par<S1, S2, D>(
    &self,
    indata: &ArrayBase<S1, D>,
    outdata: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Physical> + DataMut,
    D: Dimension,
    Self::Spectral: Clone + Send + Sync,
    Self::Physical: Clone + Zero + Copy + Send + Sync,
    Self: Sync, 

Spectral coefficients -> Physical values (Parallel)

impl<A: Clone> Clone for FourierC2c<A>

fn clone(&self) -> FourierC2c<A>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.