Struct funspace::spaces::space1::Space1

source · [−]

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

Expand description

Create one-dimensional space

Fields

base0: B

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> BaseSpace<A, 1_usize> for Space1<BaseR2r<A>> where
A: FloatNum + ScalarNum,
Complex<A>: ScalarNum,

type Physical = A

Number type in physical space (float or complex)

type Spectral = A

Number type in spectral space (float or complex)

source

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

Shape of physical space

source

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

Shape of spectral space

source

fn ndarray_physical(&self) -> Array1<Self::Physical>

Return array where size and type matches physical field

source

fn ndarray_spectral(&self) -> Array1<Self::Spectral>

Return array where size and type matches spectral field

source

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

Laplacian Read more

source

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

Pseudoinverse matrix of Laplacian Read more

source

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

Pseudoidentity matrix of laplacian Read more

source

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

Mass matrix Read more

source

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

Array of coordinates

source

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

Coordinates of grid points (in physical space) Read more

source

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

Return base key

source

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

Transformation from composite and to orthonormal space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from composite and to orthonormal space (inplace). Read more

source

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

Transformation from orthonormal and to composite space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from orthonormal and to composite space (inplace). Read more

source

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

Transformation from composite and to orthonormal space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from composite and to orthonormal space (inplace). Read more

source

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

Transformation from orthonormal and to composite space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from orthonormal and to composite space (inplace). Read more

source

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

Take gradient. Optional: Rescale result by a constant. Read more

source

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

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

source

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

Transform physical -> spectral space Read more

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) Read more

source

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

Transform spectral -> physical space Read more

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) Read more

source

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

Transform physical -> spectral space Read more

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) Read more

source

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

Transform spectral -> physical space Read more

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) Read more

source

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

type Physical = A

Number type in physical space (float or complex)

type Spectral = Complex<A>

Number type in spectral space (float or complex)

source

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

Shape of physical space

source

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

Shape of spectral space

source

fn ndarray_physical(&self) -> Array1<Self::Physical>

Return array where size and type matches physical field

source

fn ndarray_spectral(&self) -> Array1<Self::Spectral>

Return array where size and type matches spectral field

source

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

Laplacian Read more

source

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

Pseudoinverse matrix of Laplacian Read more

source

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

Pseudoidentity matrix of laplacian Read more

source

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

Mass matrix Read more

source

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

Array of coordinates

source

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

Coordinates of grid points (in physical space) Read more

source

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

Return base key

source

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

Transformation from composite and to orthonormal space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from composite and to orthonormal space (inplace). Read more

source

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

Transformation from orthonormal and to composite space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from orthonormal and to composite space (inplace). Read more

source

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

Transformation from composite and to orthonormal space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from composite and to orthonormal space (inplace). Read more

source

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

Transformation from orthonormal and to composite space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from orthonormal and to composite space (inplace). Read more

source

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

Take gradient. Optional: Rescale result by a constant. Read more

source

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

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

source

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

Transform physical -> spectral space Read more

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) Read more

source

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

Transform spectral -> physical space Read more

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) Read more

source

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

Transform physical -> spectral space Read more

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) Read more

source

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

Transform spectral -> physical space Read more

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) Read more

source

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

type Physical = Complex<A>

Number type in physical space (float or complex)

type Spectral = Complex<A>

Number type in spectral space (float or complex)

source

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

Shape of physical space

source

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

Shape of spectral space

source

fn ndarray_physical(&self) -> Array1<Self::Physical>

Return array where size and type matches physical field

source

fn ndarray_spectral(&self) -> Array1<Self::Spectral>

Return array where size and type matches spectral field

source

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

Laplacian Read more

source

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

Pseudoinverse matrix of Laplacian Read more

source

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

Pseudoidentity matrix of laplacian Read more

source

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

Mass matrix Read more

source

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

Array of coordinates

source

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

Coordinates of grid points (in physical space) Read more

source

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

Return base key

source

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

Transformation from composite and to orthonormal space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from composite and to orthonormal space (inplace). Read more

source

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

Transformation from orthonormal and to composite space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from orthonormal and to composite space (inplace). Read more

source

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

Transformation from composite and to orthonormal space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from composite and to orthonormal space (inplace). Read more

source

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

Transformation from orthonormal and to composite space. Read more

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 = Self::Spectral>,
 S2: Data<Elem = Self::Spectral> + DataMut,

Transformation from orthonormal and to composite space (inplace). Read more

source

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

Take gradient. Optional: Rescale result by a constant. Read more

source

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

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

source

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

Transform physical -> spectral space Read more

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) Read more

source

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

Transform spectral -> physical space Read more

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) Read more

source

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

Transform physical -> spectral space Read more

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) Read more

source

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

Transform spectral -> physical space Read more

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) Read more

source

impl<B: Clone> Clone for Space1

source

fn clone(&self) -> Space1

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 RefUnwindSafe for Space1 where
B: RefUnwindSafe,

impl Send for Space1 where
B: Send,

impl Sync for Space1 where
B: Sync,

impl Unpin for Space1 where
B: Unpin,

impl UnwindSafe for Space1 where
B: 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.

Struct funspace::spaces::space1::Space1

Fields

Implementations

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

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

Trait Implementations

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

type Physical = A

type Spectral = A

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

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

fn ndarray_physical(&self) -> Array1<Self::Physical>

fn ndarray_spectral(&self) -> Array1<Self::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(&self) -> [Array1<A>; 1]

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

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

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

fn to_ortho_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::Spectral> + DataMut,

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

fn from_ortho_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::Spectral> + DataMut,

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

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 = Self::Spectral>, S2: Data<Elem = Self::Spectral> + DataMut,

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

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 = Self::Spectral>, S2: Data<Elem = Self::Spectral> + DataMut,

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

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

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

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<S>( &self, input: &ArrayBase<S, Dim<[usize; 1]>>) -> Array<Self::Physical, Dim<[usize; 1]>> where S: Data<Elem = Self::Spectral>,

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_par<S>( &self, input: &ArrayBase<S, Dim<[usize; 1]>>) -> Array<Self::Spectral, Dim<[usize; 1]>> where S: Data<Elem = Self::Physical>,

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_par<S>( &self, input: &ArrayBase<S, Dim<[usize; 1]>>) -> Array<Self::Physical, Dim<[usize; 1]>> where S: Data<Elem = Self::Spectral>,

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,

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

type Physical = A

type Spectral = Complex<A>

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

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

fn ndarray_physical(&self) -> Array1<Self::Physical>

fn ndarray_spectral(&self) -> Array1<Self::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(&self) -> [Array1<A>; 1]

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

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

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

fn to_ortho_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::Spectral> + DataMut,

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

fn from_ortho_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::Spectral> + DataMut,

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

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 = Self::Spectral>, S2: Data<Elem = Self::Spectral> + DataMut,

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

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 = Self::Spectral>, S2: Data<Elem = Self::Spectral> + DataMut,

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

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

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

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<S>( &self, input: &ArrayBase<S, Dim<[usize; 1]>>) -> Array<Self::Physical, Dim<[usize; 1]>> where S: Data<Elem = Self::Spectral>,

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_par<S>( &self, input: &ArrayBase<S, Dim<[usize; 1]>>) -> Array<Self::Spectral, Dim<[usize; 1]>> where S: Data<Elem = Self::Physical>,

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_par<S>( &self, input: &ArrayBase<S, Dim<[usize; 1]>>) -> Array<Self::Physical, Dim<[usize; 1]>> where S: Data<Elem = Self::Spectral>,

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,

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

type Physical = Complex<A>

type Spectral = Complex<A>

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

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

fn ndarray_physical(&self) -> Array1<Self::Physical>

fn ndarray_spectral(&self) -> Array1<Self::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>

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

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

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

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

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

fn to_ortho_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::Spectral> + DataMut,

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

fn from_ortho_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::Spectral> + DataMut,

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

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 = Self::Spectral>,
S2: Data<Elem = Self::Spectral> + DataMut,

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

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 = Self::Spectral>,
S2: Data<Elem = Self::Spectral> + DataMut,

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

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

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

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<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Physical, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Spectral>,

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_par<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Spectral, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Physical>,

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_par<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Physical, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Spectral>,

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,

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

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

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

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

fn to_ortho_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::Spectral> + DataMut,

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

fn from_ortho_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::Spectral> + DataMut,

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

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 = Self::Spectral>,
S2: Data<Elem = Self::Spectral> + DataMut,

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

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 = Self::Spectral>,
S2: Data<Elem = Self::Spectral> + DataMut,

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

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

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

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<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Physical, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Spectral>,

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_par<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Spectral, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Physical>,

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_par<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Physical, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Spectral>,

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,

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

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

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

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

fn to_ortho_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::Spectral> + DataMut,

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

fn from_ortho_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::Spectral> + DataMut,

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

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 = Self::Spectral>,
S2: Data<Elem = Self::Spectral> + DataMut,

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

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 = Self::Spectral>,
S2: Data<Elem = Self::Spectral> + DataMut,

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

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

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

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<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Physical, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Spectral>,

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_par<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Spectral, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Physical>,

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_par<S>(
&self,
input: &ArrayBase<S, Dim<[usize ; 1]>>
) -> Array<Self::Physical, Dim<[usize ; 1]>> where
S: Data<Elem = Self::Spectral>,

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,

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

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

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

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

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

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

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

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

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

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

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

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