Trait funspace::space_traits::BaseSpace

pub trait BaseSpace<A, const N: usize>: Clone where
    A: FloatNum, {
    type Physical;
    type Spectral;
    fn laplace(&self, axis: usize) -> Array2<A>;
    fn laplace_inv(&self, axis: usize) -> Array2<A>;
    fn laplace_inv_eye(&self, axis: usize) -> Array2<A>;
    fn mass(&self, axis: usize) -> Array2<A>;
    fn coords_axis(&self, axis: usize) -> Array1<A>;
    fn coords(&self) -> [Array1<A>; N];
    fn shape_physical(&self) -> [usize; N];
    fn shape_spectral(&self) -> [usize; N];
    fn ndarray_physical(&self) -> Array<Self::Physical, Dim<[usize; N]>>;
    fn ndarray_spectral(&self) -> Array<Self::Spectral, Dim<[usize; N]>>;
    fn to_ortho<S>(
        &self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn to_ortho_inplace<S1, S2>(
        &self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Spectral>,
        S2: Data<Elem = Self::Spectral> + DataMut;
    fn from_ortho<S>(
        &self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn from_ortho_inplace<S1, S2>(
        &self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Spectral>,
        S2: Data<Elem = Self::Spectral> + DataMut;
    fn to_ortho_par<S>(
        &self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn to_ortho_inplace_par<S1, S2>(
        &self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Spectral>,
        S2: Data<Elem = Self::Spectral> + DataMut;
    fn from_ortho_par<S>(
        &self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn from_ortho_inplace_par<S1, S2>(
        &self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Spectral>,
        S2: Data<Elem = Self::Spectral> + DataMut;
    fn gradient<S>(
        &self, 
        input: &ArrayBase<S, Dim<[usize; N]>>, 
        deriv: [usize; N], 
        scale: Option<[A; N]>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn gradient_par<S>(
        &self, 
        input: &ArrayBase<S, Dim<[usize; N]>>, 
        deriv: [usize; N], 
        scale: Option<[A; N]>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn base_all(&self) -> [BaseAll<A>; N];
    fn forward<S>(
        &mut self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Physical>;
    fn forward_inplace<S1, S2>(
        &mut self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Physical>,
        S2: Data<Elem = Self::Spectral> + DataMut;
    fn backward<S>(
        &mut self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Physical, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn backward_inplace<S1, S2>(
        &mut self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Spectral>,
        S2: Data<Elem = Self::Physical> + DataMut;
    fn forward_par<S>(
        &mut self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Spectral, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Physical>;
    fn forward_inplace_par<S1, S2>(
        &mut self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Physical>,
        S2: Data<Elem = Self::Spectral> + DataMut;
    fn backward_par<S>(
        &mut self, 
        input: &ArrayBase<S, Dim<[usize; N]>>
    ) -> Array<Self::Physical, Dim<[usize; N]>>
    where
        S: Data<Elem = Self::Spectral>;
    fn backward_inplace_par<S1, S2>(
        &mut self, 
        input: &ArrayBase<S1, Dim<[usize; N]>>, 
        output: &mut ArrayBase<S2, Dim<[usize; N]>>
    )
    where
        S1: Data<Elem = Self::Spectral>,
        S2: Data<Elem = Self::Physical> + DataMut;
}

Associated Types

type Physical

Number type in physical space (float or complex)

type Spectral

Number type in spectral space (float or complex)

Required methods

fn laplace(&self, axis: usize) -> Array2<A>

Laplacian

Arguments

• axis - usize

fn laplace_inv(&self, axis: usize) -> Array2<A>

Pseudoinverse matrix of Laplacian

Arguments

• axis - usize

fn laplace_inv_eye(&self, axis: usize) -> Array2<A>

Pseudoidentity matrix of laplacian

Arguments

• axis - usize

fn mass(&self, axis: usize) -> Array2<A>

Mass matrix

Arguments

• axis - usize

fn coords_axis(&self, axis: usize) -> Array1<A>

Coordinates of grid points (in physical space)

Arguments

• axis - usize

fn coords(&self) -> [Array1<A>; N]

Array of coordinates

fn shape_physical(&self) -> [usize; N]

Shape of physical space

fn shape_spectral(&self) -> [usize; N]

Shape of spectral space

fn ndarray_physical(&self) -> Array<Self::Physical, Dim<[usize; N]>>

Return array where size and type matches physical field

fn ndarray_spectral(&self) -> Array<Self::Spectral, Dim<[usize; N]>>

Return array where size and type matches spectral field

fn to_ortho<S>(
    &self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Transformation from composite and to orthonormal space.

Arguments

• input - ndarray with num type of spectral space

fn to_ortho_inplace<S1, S2>(
    &self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Spectral> + DataMut, 

Transformation from composite and to orthonormal space (inplace).

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of spectral space

fn from_ortho<S>(
    &self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Transformation from orthonormal and to composite space.

Arguments

• input - ndarray with num type of spectral space

fn from_ortho_inplace<S1, S2>(
    &self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Spectral> + DataMut, 

Transformation from orthonormal and to composite space (inplace).

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of spectral space

fn to_ortho_par<S>(
    &self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Transformation from composite and to orthonormal space.

Arguments

• input - ndarray with num type of spectral space

fn to_ortho_inplace_par<S1, S2>(
    &self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Spectral> + DataMut, 

Transformation from composite and to orthonormal space (inplace).

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of spectral space

fn from_ortho_par<S>(
    &self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Transformation from orthonormal and to composite space.

Arguments

• input - ndarray with num type of spectral space

fn from_ortho_inplace_par<S1, S2>(
    &self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Spectral> + DataMut, 

Transformation from orthonormal and to composite space (inplace).

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of spectral space

fn gradient<S>(
    &self,
    input: &ArrayBase<S, Dim<[usize; N]>>,
    deriv: [usize; N],
    scale: Option<[A; N]>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Take gradient. Optional: Rescale result by a constant.

Arguments

• input - ndarray with num type of spectral space
• deriv - [usize; N], derivative along each axis
• scale - [float; N], scaling factor along each axis (default [1.;n])

fn gradient_par<S>(
    &self,
    input: &ArrayBase<S, Dim<[usize; N]>>,
    deriv: [usize; N],
    scale: Option<[A; N]>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Take gradient. Optional: Rescale result by a constant. (Parallel)

Arguments

• input - ndarray with num type of spectral space
• deriv - [usize; N], derivative along each axis
• scale - [float; N], scaling factor along each axis (default [1.;n])

fn base_all(&self) -> [BaseAll<A>; N]

Return bases as array of enums

fn forward<S>(
    &mut self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Physical>, 

Transform physical -> spectral space

Arguments

• input - ndarray with num type of physical space
• output - ndarray with num type of spectral space

fn forward_inplace<S1, S2>(
    &mut self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Physical>,
    S2: Data<Elem = Self::Spectral> + DataMut, 

Transform physical -> spectral space (inplace)

Arguments

• input - ndarray with num type of physical space
• output - ndarray with num type of spectral space

fn backward<S>(
    &mut self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Physical, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Transform spectral -> physical space

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of physical space

fn backward_inplace<S1, S2>(
    &mut self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Physical> + DataMut, 

Transform spectral -> physical space (inplace)

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of physical space

fn forward_par<S>(
    &mut self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Spectral, Dim<[usize; N]>> where
    S: Data<Elem = Self::Physical>, 

Transform physical -> spectral space

Arguments

• input - ndarray with num type of physical space
• output - ndarray with num type of spectral space

fn forward_inplace_par<S1, S2>(
    &mut self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Physical>,
    S2: Data<Elem = Self::Spectral> + DataMut, 

Transform physical -> spectral space (inplace)

Arguments

• input - ndarray with num type of physical space
• output - ndarray with num type of spectral space

fn backward_par<S>(
    &mut self,
    input: &ArrayBase<S, Dim<[usize; N]>>
) -> Array<Self::Physical, Dim<[usize; N]>> where
    S: Data<Elem = Self::Spectral>, 

Transform spectral -> physical space

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of physical space

fn backward_inplace_par<S1, S2>(
    &mut self,
    input: &ArrayBase<S1, Dim<[usize; N]>>,
    output: &mut ArrayBase<S2, Dim<[usize; N]>>
) where
    S1: Data<Elem = Self::Spectral>,
    S2: Data<Elem = Self::Physical> + DataMut, 

Transform spectral -> physical space (inplace)

Arguments

• input - ndarray with num type of spectral space
• output - ndarray with num type of physical space

Implementors

impl<A> BaseSpace<A, 1_usize> for Space1<BaseC2c<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = Complex<A>

type Spectral = Complex<A>

impl<A> BaseSpace<A, 1_usize> for Space1<BaseR2c<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = Complex<A>

impl<A> BaseSpace<A, 1_usize> for Space1<BaseR2r<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = A

impl<A> BaseSpace<A, 2_usize> for Space2<BaseC2c<A>, BaseC2c<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = Complex<A>

type Spectral = Complex<A>

impl<A> BaseSpace<A, 2_usize> for Space2<BaseC2c<A>, BaseR2c<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = Complex<A>

impl<A> BaseSpace<A, 2_usize> for Space2<BaseR2c<A>, BaseR2r<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = Complex<A>

impl<A> BaseSpace<A, 2_usize> for Space2<BaseR2r<A>, BaseR2r<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = A

impl<A> BaseSpace<A, 3_usize> for Space3<BaseC2c<A>, BaseC2c<A>, BaseC2c<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = Complex<A>

type Spectral = Complex<A>

impl<A> BaseSpace<A, 3_usize> for Space3<BaseC2c<A>, BaseC2c<A>, BaseR2c<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = Complex<A>

impl<A> BaseSpace<A, 3_usize> for Space3<BaseC2c<A>, BaseR2c<A>, BaseR2r<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = Complex<A>

impl<A> BaseSpace<A, 3_usize> for Space3<BaseR2c<A>, BaseR2r<A>, BaseR2r<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = Complex<A>

impl<A> BaseSpace<A, 3_usize> for Space3<BaseR2r<A>, BaseR2r<A>, BaseR2r<A>> where
    A: FloatNum,
    Complex<A>: ScalarOperand, 

type Physical = A

type Spectral = A