Struct funspace::space::space1::Space1

source · [−]

pub struct Space1<B0> {
    pub base0: B0,
}

Expand description

Create two-dimensional space

Fields

base0: B0

Implementations

source

impl<B0> Space1<B0> where
B0: Clone,

source

pub fn new(base0: &B0) -> Self

Create a new space

Trait Implementations

source

impl<A> BaseSpaceElements<1_usize> for Space1<BaseR2r<A>> where
A: FloatNum,

source

fn coords(&self) -> [Array1<Self::RealNum>; 1]

Array of coordinates

source

fn coords_axis(&self, _axis: usize) -> Array1<Self::RealNum>

Coordinates of grid points (in physical space)

Arguments

axis - usize

source

fn base_kind(&self, _axis: usize) -> BaseKind

Return base key

source

fn transform_kind(&self, _axis: usize) -> TransformKind

Return transform kind

type RealNum = A

Real valued scalar type

source

impl<A> BaseSpaceElements<1_usize> for Space1<BaseR2c<A>> where
A: FloatNum,

source

fn coords(&self) -> [Array1<Self::RealNum>; 1]

Array of coordinates

source

fn coords_axis(&self, _axis: usize) -> Array1<Self::RealNum>

Coordinates of grid points (in physical space)

Arguments

axis - usize

source

fn base_kind(&self, _axis: usize) -> BaseKind

Return base key

source

fn transform_kind(&self, _axis: usize) -> TransformKind

Return transform kind

type RealNum = A

Real valued scalar type

source

impl<A> BaseSpaceElements<1_usize> for Space1<BaseC2c<A>> where
A: FloatNum,

source

fn coords(&self) -> [Array1<Self::RealNum>; 1]

Array of coordinates

source

fn coords_axis(&self, _axis: usize) -> Array1<Self::RealNum>

Coordinates of grid points (in physical space)

Arguments

axis - usize

source

fn base_kind(&self, _axis: usize) -> BaseKind

Return base key

source

fn transform_kind(&self, _axis: usize) -> TransformKind

Return transform kind

type RealNum = A

Real valued scalar type

source

impl<A, T> BaseSpaceFromOrtho<A, T, 1_usize> for Space1<BaseR2r<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T>,

source

fn to_ortho_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn from_ortho_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn to_ortho_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn from_ortho_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

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

Transformation from composite and to orthonormal space. Read more

source

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

Transformation from orthonormal and to composite space. Read more

source

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

Transformation from composite and to orthonormal space. Read more

source

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

Transformation from orthonormal and to composite space. Read more

source

impl<A, T> BaseSpaceFromOrtho<A, T, 1_usize> for Space1<BaseR2c<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T> + Add<Complex<A>, Output = T> + Mul<Complex<A>, Output = T> + Div<Complex<A>, Output = T> + Sub<Complex<A>, Output = T>,

source

fn to_ortho_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn from_ortho_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn to_ortho_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn from_ortho_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

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

Transformation from composite and to orthonormal space. Read more

source

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

Transformation from orthonormal and to composite space. Read more

source

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

Transformation from composite and to orthonormal space. Read more

source

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

Transformation from orthonormal and to composite space. Read more

source

impl<A, T> BaseSpaceFromOrtho<A, T, 1_usize> for Space1<BaseC2c<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T> + Add<Complex<A>, Output = T> + Mul<Complex<A>, Output = T> + Div<Complex<A>, Output = T> + Sub<Complex<A>, Output = T>,

source

fn to_ortho_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn from_ortho_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn to_ortho_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

fn from_ortho_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) where
 S1: Data<Elem = T>,
 S2: Data<Elem = T> + 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

source

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

Transformation from composite and to orthonormal space. Read more

source

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

Transformation from orthonormal and to composite space. Read more

source

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

Transformation from composite and to orthonormal space. Read more

source

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

Transformation from orthonormal and to composite space. Read more

source

impl<A, T> BaseSpaceGradient<A, T, 1_usize> for Space1<BaseR2r<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T>,

source

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

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])

source

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

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])

source

impl<A, T> BaseSpaceGradient<A, T, 1_usize> for Space1<BaseR2c<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T> + Add<Complex<A>, Output = T> + Mul<Complex<A>, Output = T> + Div<Complex<A>, Output = T> + Sub<Complex<A>, Output = T>,

source

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

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])

source

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

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])

source

impl<A, T> BaseSpaceGradient<A, T, 1_usize> for Space1<BaseC2c<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T> + Add<Complex<A>, Output = T> + Mul<Complex<A>, Output = T> + Div<Complex<A>, Output = T> + Sub<Complex<A>, Output = T>,

source

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

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])

source

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

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])

source

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseR2r<A>> where
A: FloatNum,

type NumType = A

Scalar type of laplacian matrix

source

fn laplacian(&self, _axis: usize) -> Array2<A>

Laplacian L

L_pinv @ L = I_pinv

Arguments

axis - usize

source

fn laplacian_pinv(&self, _axis: usize) -> (Array2<A>, Array2<A>)

Pseudoinverse matrix L_pinv of Laplacian

Returns (L_pinv, I_pinv)

L_pinv @ L = I_pinv

Arguments

axis - usize

source

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseR2c<A>> where
A: FloatNum,

type NumType = A

Scalar type of laplacian matrix

source

fn laplacian(&self, _axis: usize) -> Array2<A>

Laplacian L

L_pinv @ L = I_pinv

Arguments

axis - usize

source

fn laplacian_pinv(&self, _axis: usize) -> (Array2<A>, Array2<A>)

Pseudoinverse matrix L_pinv of Laplacian

Returns (L_pinv, I_pinv)

L_pinv @ L = I_pinv

Arguments

axis - usize

source

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseC2c<A>> where
A: FloatNum,

type NumType = A

Scalar type of laplacian matrix

source

fn laplacian(&self, _axis: usize) -> Array2<A>

Laplacian L

L_pinv @ L = I_pinv

Arguments

axis - usize

source

fn laplacian_pinv(&self, _axis: usize) -> (Array2<A>, Array2<A>)

Pseudoinverse matrix L_pinv of Laplacian

Returns (L_pinv, I_pinv)

L_pinv @ L = I_pinv

Arguments

axis - usize

source

impl<A> BaseSpaceMatOpStencil for Space1<BaseR2r<A>> where
A: FloatNum,

type NumType = A

Scalar type of laplacian matrix

source

fn stencil(&self, _axis: usize) -> Array2<A>

Transformation stencil

Multiplication of this matrix with a coefficient vector has the same effect as BaseSpaceFromOrtho::to_ortho(), but is less efficient.

Returns identity matrix for orthogonal bases

Arguments

axis - usize

source

fn stencil_inv(&self, _axis: usize) -> Array2<A>

Inverse of transformation stencil

Multiplication of this matrix with a coefficient vector has the same effect as BaseSpaceFromOrtho::from_ortho(), but is less efficient.

Returns identity matrix for orthogonal bases

Arguments

axis - usize

source

impl<A> BaseSpaceMatOpStencil for Space1<BaseR2c<A>> where
A: FloatNum,

type NumType = A

Scalar type of laplacian matrix

source

fn stencil(&self, _axis: usize) -> Array2<A>

Transformation stencil

Multiplication of this matrix with a coefficient vector has the same effect as BaseSpaceFromOrtho::to_ortho(), but is less efficient.

Returns identity matrix for orthogonal bases

Arguments

axis - usize

source

fn stencil_inv(&self, _axis: usize) -> Array2<A>

Inverse of transformation stencil

Multiplication of this matrix with a coefficient vector has the same effect as BaseSpaceFromOrtho::from_ortho(), but is less efficient.

Returns identity matrix for orthogonal bases

Arguments

axis - usize

source

impl<A> BaseSpaceMatOpStencil for Space1<BaseC2c<A>> where
A: FloatNum,

type NumType = A

Scalar type of laplacian matrix

source

fn stencil(&self, _axis: usize) -> Array2<A>

Transformation stencil

Multiplication of this matrix with a coefficient vector has the same effect as BaseSpaceFromOrtho::to_ortho(), but is less efficient.

Returns identity matrix for orthogonal bases

Arguments

axis - usize

source

fn stencil_inv(&self, _axis: usize) -> Array2<A>

Inverse of transformation stencil

Multiplication of this matrix with a coefficient vector has the same effect as BaseSpaceFromOrtho::from_ortho(), but is less efficient.

Returns identity matrix for orthogonal bases

Arguments

axis - usize

source

impl<A> BaseSpaceSize<1_usize> for Space1<BaseR2r<A>> where
A: FloatNum,

source

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

Shape of physical space

source

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

Shape of spectral space

source

fn shape_spectral_ortho(&self) -> [usize ; 1]

Shape of spectral space (orthogonal bases)

source

fn ndarray_from_shape<T: Clone + Zero>(&self, shape: [usize ; 1]) -> Array1<T>

Return array from shape

source

impl<A> BaseSpaceSize<1_usize> for Space1<BaseR2c<A>> where
A: FloatNum,

source

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

Shape of physical space

source

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

Shape of spectral space

source

fn shape_spectral_ortho(&self) -> [usize ; 1]

Shape of spectral space (orthogonal bases)

source

fn ndarray_from_shape<T: Clone + Zero>(&self, shape: [usize ; 1]) -> Array1<T>

Return array from shape

source

impl<A> BaseSpaceSize<1_usize> for Space1<BaseC2c<A>> where
A: FloatNum,

source

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

Shape of physical space

source

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

Shape of spectral space

source

fn shape_spectral_ortho(&self) -> [usize ; 1]

Shape of spectral space (orthogonal bases)

source

fn ndarray_from_shape<T: Clone + Zero>(&self, shape: [usize ; 1]) -> Array1<T>

Return array from shape

source

impl<A> BaseSpaceTransform<A, 1_usize> for Space1<BaseR2r<A>> where
A: FloatNum + ScalarNum,
Complex<A>: ScalarNum,

source

fn forward_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn backward_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn forward_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn backward_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

type Physical = A

type Spectral = A

source

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

Return array where size and type matches physical field

source

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

Return array where size and type matches spectral field

source

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

Transform physical -> spectral space Read more

source

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

Transform spectral -> physical space Read more

source

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

Transform physical -> spectral space Read more

source

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

Transform spectral -> physical space Read more

source

impl<A> BaseSpaceTransform<A, 1_usize> for Space1<BaseR2c<A>> where
A: FloatNum + ScalarNum,
Complex<A>: ScalarNum,

source

fn forward_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn backward_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn forward_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn backward_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

type Physical = A

type Spectral = Complex<A>

source

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

Return array where size and type matches physical field

source

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

Return array where size and type matches spectral field

source

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

Transform physical -> spectral space Read more

source

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

Transform spectral -> physical space Read more

source

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

Transform physical -> spectral space Read more

source

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

Transform spectral -> physical space Read more

source

impl<A> BaseSpaceTransform<A, 1_usize> for Space1<BaseC2c<A>> where
A: FloatNum + ScalarNum,
Complex<A>: ScalarNum,

source

fn forward_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn backward_inplace<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn forward_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

source

fn backward_inplace_par<S1, S2>(
 &self,
 input: &ArrayBase<S1, Dim<[usize ; 1]>>,
 output: &mut ArrayBase<S2, Dim<[usize ; 1]>>
) 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

type Physical = Complex<A>

type Spectral = Complex<A>

source

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

Return array where size and type matches physical field

source

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

Return array where size and type matches spectral field

source

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

Transform physical -> spectral space Read more

source

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

Transform spectral -> physical space Read more

source

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

Transform physical -> spectral space Read more

source

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

Transform spectral -> physical space Read more

source

impl<B0: Clone> Clone for Space1<B0>

source

fn clone(&self) -> Space1<B0>

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

Auto Trait Implementations

impl<B0> RefUnwindSafe for Space1<B0> where
B0: RefUnwindSafe,

impl<B0> Send for Space1<B0> where
B0: Send,

impl<B0> Sync for Space1<B0> where
B0: Sync,

impl<B0> Unpin for Space1<B0> where
B0: Unpin,

impl<B0> UnwindSafe for Space1<B0> where
B0: UnwindSafe,

Blanket Implementations

source

impl<T> Any for T where
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> Pointable for T

const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more

source

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for T where
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

source

impl<A, T, const N: usize> BaseSpace<A, N> for T where
T: Clone + BaseSpaceElements<N, RealNum = A> + BaseSpaceMatOpStencil<NumType = A> + BaseSpaceMatOpLaplacian<NumType = A> + BaseSpaceFromOrtho<A, <T as BaseSpaceTransform<A, N>>::Spectral, N> + BaseSpaceGradient<A, <T as BaseSpaceTransform<A, N>>::Spectral, N> + BaseSpaceTransform<A, N>,
A: FloatNum,

Struct funspace::space::space1::Space1

Fields

Implementations

impl<B0> Space1<B0> where B0: Clone,

pub fn new(base0: &B0) -> Self

Trait Implementations

impl<A> BaseSpaceElements<1_usize> for Space1<BaseR2r<A>> where A: FloatNum,

fn coords(&self) -> [Array1<Self::RealNum>; 1]

fn coords_axis(&self, _axis: usize) -> Array1<Self::RealNum>

fn base_kind(&self, _axis: usize) -> BaseKind

fn transform_kind(&self, _axis: usize) -> TransformKind

type RealNum = A

impl<A> BaseSpaceElements<1_usize> for Space1<BaseR2c<A>> where A: FloatNum,

fn coords(&self) -> [Array1<Self::RealNum>; 1]

fn coords_axis(&self, _axis: usize) -> Array1<Self::RealNum>

fn base_kind(&self, _axis: usize) -> BaseKind

fn transform_kind(&self, _axis: usize) -> TransformKind

type RealNum = A

impl<A> BaseSpaceElements<1_usize> for Space1<BaseC2c<A>> where A: FloatNum,

fn coords(&self) -> [Array1<Self::RealNum>; 1]

fn coords_axis(&self, _axis: usize) -> Array1<Self::RealNum>

fn base_kind(&self, _axis: usize) -> BaseKind

fn transform_kind(&self, _axis: usize) -> TransformKind

type RealNum = A

impl<A, T> BaseSpaceFromOrtho<A, T, 1_usize> for Space1<BaseR2r<A>> where A: FloatNum + ScalarNum, T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<A, T> BaseSpaceGradient<A, T, 1_usize> for Space1<BaseR2r<A>> where A: FloatNum + ScalarNum, T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T>,

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

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

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

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

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

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

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseR2r<A>> where A: FloatNum,

type NumType = A

fn laplacian(&self, _axis: usize) -> Array2<A>

fn laplacian_pinv(&self, _axis: usize) -> (Array2<A>, Array2<A>)

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseR2c<A>> where A: FloatNum,

type NumType = A

fn laplacian(&self, _axis: usize) -> Array2<A>

fn laplacian_pinv(&self, _axis: usize) -> (Array2<A>, Array2<A>)

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseC2c<A>> where A: FloatNum,

type NumType = A

fn laplacian(&self, _axis: usize) -> Array2<A>

fn laplacian_pinv(&self, _axis: usize) -> (Array2<A>, Array2<A>)

impl<A> BaseSpaceMatOpStencil for Space1<BaseR2r<A>> where A: FloatNum,

type NumType = A

fn stencil(&self, _axis: usize) -> Array2<A>

fn stencil_inv(&self, _axis: usize) -> Array2<A>

impl<A> BaseSpaceMatOpStencil for Space1<BaseR2c<A>> where A: FloatNum,

type NumType = A

fn stencil(&self, _axis: usize) -> Array2<A>

fn stencil_inv(&self, _axis: usize) -> Array2<A>

impl<A> BaseSpaceMatOpStencil for Space1<BaseC2c<A>> where A: FloatNum,

type NumType = A

fn stencil(&self, _axis: usize) -> Array2<A>

fn stencil_inv(&self, _axis: usize) -> Array2<A>

impl<B0> Space1<B0> where
B0: Clone,

impl<A> BaseSpaceElements<1_usize> for Space1<BaseR2r<A>> where
A: FloatNum,

impl<A> BaseSpaceElements<1_usize> for Space1<BaseR2c<A>> where
A: FloatNum,

impl<A> BaseSpaceElements<1_usize> for Space1<BaseC2c<A>> where
A: FloatNum,

impl<A, T> BaseSpaceFromOrtho<A, T, 1_usize> for Space1<BaseR2r<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<A, T> BaseSpaceGradient<A, T, 1_usize> for Space1<BaseR2r<A>> where
A: FloatNum + ScalarNum,
T: ScalarNum + From<A> + Add<A, Output = T> + Mul<A, Output = T> + Div<A, Output = T> + Sub<A, Output = T>,

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

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

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

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

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

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

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseR2r<A>> where
A: FloatNum,

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseR2c<A>> where
A: FloatNum,

impl<A> BaseSpaceMatOpLaplacian for Space1<BaseC2c<A>> where
A: FloatNum,

impl<A> BaseSpaceMatOpStencil for Space1<BaseR2r<A>> where
A: FloatNum,

impl<A> BaseSpaceMatOpStencil for Space1<BaseR2c<A>> where
A: FloatNum,

impl<A> BaseSpaceMatOpStencil for Space1<BaseC2c<A>> where
A: FloatNum,

impl<A> BaseSpaceSize<1_usize> for Space1<BaseR2r<A>> where
A: FloatNum,

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

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

fn shape_spectral_ortho(&self) -> [usize ; 1]

fn ndarray_from_shape<T: Clone + Zero>(&self, shape: [usize ; 1]) -> Array1<T>

impl<A> BaseSpaceSize<1_usize> for Space1<BaseR2c<A>> where
A: FloatNum,

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

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

fn shape_spectral_ortho(&self) -> [usize ; 1]

fn ndarray_from_shape<T: Clone + Zero>(&self, shape: [usize ; 1]) -> Array1<T>

impl<A> BaseSpaceSize<1_usize> for Space1<BaseC2c<A>> where
A: FloatNum,

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

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

fn shape_spectral_ortho(&self) -> [usize ; 1]

fn ndarray_from_shape<T: Clone + Zero>(&self, shape: [usize ; 1]) -> Array1<T>

impl<A> BaseSpaceTransform<A, 1_usize> for Space1<BaseR2r<A>> where
A: FloatNum + ScalarNum,
Complex<A>: ScalarNum,

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

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

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

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