Enum funspace::enums::BaseC2c

pub enum BaseC2c<T: FloatNum> {
    FourierC2c(FourierC2c<T>),
}

All bases who transform: complex-to-complex

Variants

FourierC2c

Fourier polynomials

Tuple Fields of FourierC2c

0: FourierC2c<T>

Trait Implementations

impl<T: FloatNum> Basics<T> for BaseC2c<T>

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

Coordinates in physical space

fn len_phys(&self) -> usize

Size in physical space

fn len_spec(&self) -> usize

Size in spectral space

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

Return mass matrix

fn get_transform_kind(&self) -> &TransformKind

Return kind of transform

impl<T: Clone + FloatNum> Clone for BaseC2c<T>

fn clone(&self) -> BaseC2c<T>

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 BaseC2c<A>

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 BaseC2c<A>

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<BaseC2c<T>> for BaseAll<T>

fn from(v: BaseC2c<T>) -> BaseAll<T>

Performs the conversion.

impl<T: FloatNum> From<FourierC2c<T>> for BaseC2c<T>

fn from(v: FourierC2c<T>) -> BaseC2c<T>

Performs the conversion.

impl<A: FloatNum> FromOrtho<Complex<A>> for BaseC2c<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 coefficents in associated composite space

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, 

See to_ortho

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 coefficents in associated composite space

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, 

See fom_ortho

impl<A: FloatNum> FromOrthoPar<Complex<A>> for BaseC2c<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, 

Parallel version of to_ortho

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, 

Parallel version of to_ortho_inplace

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, 

Parallel version of from_ortho

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, 

Parallel version of from_ortho_inplace

impl<T: FloatNum> LaplacianInverse<T> for BaseC2c<T>

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

Laplacian $ L $

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

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

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

Pseudoidentity matrix of laplacian $ L^{-1} L $

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

type Physical = Complex<A>

type Spectral = Complex<A>

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

Transform physical -> spectral space along axis

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

Transform from spectral to physical space

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

Transform spectral -> physical space along axis

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

Transform from spectral to physical space

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

type Physical = Complex<A>

Scalar type in physical space (before transform)

type Spectral = Complex<A>

Scalar type in spectral space (after transfrom)

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

Transform physical -> spectral space along axis

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

Transform from spectral to physical space

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

Transform spectral -> physical space along axis

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

Transform from spectral to physical space

impl<T: FloatNum> TryInto<BaseC2c<T>> for BaseAll<T>

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<T: FloatNum> TryInto<FourierC2c<T>> for BaseC2c<T>

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.