Struct funspace::fourier::FourierR2c

pub struct FourierR2c<A> {
    pub n: usize,
    pub m: usize,
    pub x: Array1<A>,
    pub k: Array1<Complex<A>>,
    pub fft_handler: R2cFftHandler<A>,
    // some fields omitted
}

Container for fourier space (Real-to-complex)

Fields

n: usize

Number of coefficients in physical space

m: usize

Number of coefficients in spectral space

x: Array1<A>

Grid coordinates of fourier nodes

k: Array1<Complex<A>>

Complex wavenumber vector

fft_handler: R2cFftHandler<A>

Handles discrete cosine transform

Implementations

impl<A: FloatNum> FourierR2c<A>

pub fn new(n: usize) -> Self

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

pub fn differentiate_lane<S, T2>(
    &self,
    data: &mut ArrayBase<S, Ix1>,
    n_times: usize
) where
    S: Data<Elem = T2> + DataMut,
    T2: Scalar + From<Complex<A>>, 

Differentiate 1d Array n_times

Example

Differentiate along lane

use funspace::fourier::FourierR2c;
use funspace::utils::approx_eq_complex;
use ndarray::prelude::*;
let fo = FourierR2c::<f64>::new(5);
let mut k = fo.k.clone();
let expected = k.mapv(|x| x.powf(2.));
fo.differentiate_lane(&mut k, 1);
approx_eq_complex(&k, &expected);

Panics

When type conversion fails ( safe )

Trait Implementations

impl<A: FloatNum> BaseSize for FourierR2c<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> Basics<A> for FourierR2c<A>

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

Coordinates in physical space

fn mass(&self) -> Array2<A>

Return mass matrix (= eye)

fn get_transform_kind(&self) -> &TransformKind

Return transform kind

impl<A: Clone> Clone for FourierR2c<A>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: FloatNum> Differentiate<Complex<A>> for FourierR2c<A>

Perform differentiation in spectral space

fn differentiate<S, D>(
    &self,
    data: &ArrayBase<S, D>,
    n_times: usize,
    axis: usize
) -> Array<Complex<A>, D> where
    S: Data<Elem = Complex<A>>,
    D: Dimension, 

Return differentiated array

fn differentiate_inplace<S, D>(
    &self,
    data: &mut ArrayBase<S, D>,
    n_times: usize,
    axis: usize
) where
    S: Data<Elem = Complex<A>> + DataMut,
    D: Dimension, 

Differentiate on input array

impl<A: FloatNum> DifferentiatePar<Complex<A>> for FourierR2c<A>

Perform differentiation in spectral space

fn differentiate_par<S, D>(
    &self,
    data: &ArrayBase<S, D>,
    n_times: usize,
    axis: usize
) -> Array<Complex<A>, D> where
    S: Data<Elem = Complex<A>>,
    D: Dimension, 

Return differentiated array

fn differentiate_inplace_par<S, D>(
    &self,
    data: &mut ArrayBase<S, D>,
    n_times: usize,
    axis: usize
) where
    S: Data<Elem = Complex<A>> + DataMut,
    D: Dimension, 

Differentiate on input array

impl<T: FloatNum> From<FourierR2c<T>> for BaseR2c<T>

fn from(v: FourierR2c<T>) -> BaseR2c<T>

Performs the conversion.

impl<A: FloatNum> FromOrtho<Complex<A>> for FourierR2c<A>

fn to_ortho<S, D>(
    &self,
    input: &ArrayBase<S, D>,
    _axis: usize
) -> Array<Complex<A>, D> where
    S: Data<Elem = Complex<A>>,
    D: Dimension, 

Return itself

fn to_ortho_inplace<S1, S2, D>(
    &self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    _axis: usize
) where
    S1: Data<Elem = Complex<A>>,
    S2: Data<Elem = Complex<A>> + DataMut,
    D: Dimension, 

Return itself

fn from_ortho<S, D>(
    &self,
    input: &ArrayBase<S, D>,
    _axis: usize
) -> Array<Complex<A>, D> where
    S: Data<Elem = Complex<A>>,
    D: Dimension, 

Return itself

fn from_ortho_inplace<S1, S2, D>(
    &self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    _axis: usize
) where
    S1: Data<Elem = Complex<A>>,
    S2: Data<Elem = Complex<A>> + DataMut,
    D: Dimension, 

Return itself

impl<A: FloatNum> FromOrthoPar<Complex<A>> for FourierR2c<A>

fn to_ortho_par<S, D>(
    &self,
    input: &ArrayBase<S, D>,
    _axis: usize
) -> Array<Complex<A>, D> where
    S: Data<Elem = Complex<A>>,
    D: Dimension, 

Return itself

fn to_ortho_inplace_par<S1, S2, D>(
    &self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    _axis: usize
) where
    S1: Data<Elem = Complex<A>>,
    S2: Data<Elem = Complex<A>> + DataMut,
    D: Dimension, 

Return itself

fn from_ortho_par<S, D>(
    &self,
    input: &ArrayBase<S, D>,
    _axis: usize
) -> Array<Complex<A>, D> where
    S: Data<Elem = Complex<A>>,
    D: Dimension, 

Return itself

fn from_ortho_inplace_par<S1, S2, D>(
    &self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    _axis: usize
) where
    S1: Data<Elem = Complex<A>>,
    S2: Data<Elem = Complex<A>> + DataMut,
    D: Dimension, 

Return itself

impl<A: FloatNum> LaplacianInverse<A> for FourierR2c<A>

fn laplace(&self) -> Array2<A>

Laplacian ( = |k^2| ) diagonal matrix

fn laplace_inv(&self) -> Array2<A>

Pseudoinverse Laplacian for FourierR2c basis

fn laplace_inv_eye(&self) -> Array2<A>

Pseudoidentity matrix (= eye matrix with removed first row for FourierR2c)

impl<A: FloatNum> Transform for FourierR2c<A>

Copied from c2c

fn forward<S, D>(
    &mut self,
    input: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Spectral, D> where
    S: Data<Elem = Self::Physical>,
    D: Dimension, 

Example

Forward transform along first axis

use funspace::fourier::FourierR2c;
use funspace::Transform;
use funspace::utils::approx_eq_complex;
use num_complex::Complex;
use ndarray::prelude::*;
let mut fo = FourierR2c::new(4);
let input = array![1., 2., 3., 4.];
let expected = array![
    Complex::new(10., 0.),
    Complex::new(-2., 2.),
    Complex::new(-2., 0.)
];
let output = fo.forward(&input, 0);
approx_eq_complex(&output, &expected);

fn forward_inplace<S1, S2, D>(
    &mut self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Physical>,
    S2: Data<Elem = Self::Spectral> + DataMut,
    D: Dimension, 

See FourierR2c::forward

fn backward<S, D>(
    &mut self,
    input: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Physical, D> where
    S: Data<Elem = Self::Spectral>,
    D: Dimension, 

Example

Backward transform along first axis

use funspace::fourier::FourierR2c;
use funspace::Transform;
use funspace::utils::approx_eq;
use num_complex::Complex;
use ndarray::prelude::*;
let mut fo = FourierR2c::new(4);
let input = array![
    Complex::new(10., 0.),
    Complex::new(-2., 2.),
    Complex::new(-2., 0.)
];
let expected = array![1., 2., 3., 4.];
let output = fo.backward(&input, 0);
approx_eq(&output, &expected);

fn backward_inplace<S1, S2, D>(
    &mut self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Physical> + DataMut,
    D: Dimension, 

See FourierR2c::backward

Panics

Panics when input type cannot be cast from f64.

type Physical = A

type Spectral = Complex<A>

impl<A: FloatNum> TransformPar for FourierR2c<A>

fn forward_par<S, D>(
    &mut self,
    input: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Spectral, D> where
    S: Data<Elem = Self::Physical>,
    D: Dimension, 

Parallel version. See FourierR2c::forward

fn forward_inplace_par<S1, S2, D>(
    &mut self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Physical>,
    S2: Data<Elem = Self::Spectral> + DataMut,
    D: Dimension, 

Parallel version. See FourierR2c::forward_inplace

fn backward_par<S, D>(
    &mut self,
    input: &ArrayBase<S, D>,
    axis: usize
) -> Array<Self::Physical, D> where
    S: Data<Elem = Self::Spectral>,
    D: Dimension, 

Parallel version. See FourierR2c::backward

fn backward_inplace_par<S1, S2, D>(
    &mut self,
    input: &ArrayBase<S1, D>,
    output: &mut ArrayBase<S2, D>,
    axis: usize
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Physical> + DataMut,
    D: Dimension, 

Parallel version. See FourierR2c::backward_inplace

Panics

Panics when input type cannot be cast from f64.

type Physical = A

Scalar type in physical space (before transform)

type Spectral = Complex<A>

Scalar type in spectral space (after transfrom)

impl<T: FloatNum> TryInto<FourierR2c<T>> for BaseR2c<T>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(
    self
) -> Result<FourierR2c<T>, <Self as TryInto<FourierR2c<T>>>::Error>

Performs the conversion.