Struct funspace::chebyshev::CompositeChebyshev[−][src]

impl<A: FloatNum> CompositeChebyshev<A>

pub fn dirichlet(n: usize) -> Self

Return function space of chebyshev space with dirichlet boundary conditions $$ \phi_k = T_k - T_{k+2} $$

pub fn neumann(n: usize) -> Self

Return function space of chebyshev space with neumann boundary conditions $$ \phi_k = T_k - k^{2} / (k+2)^2 T_{k+2} $$

pub fn dirichlet_bc(n: usize) -> Self

Dirichlet boundary condition basis $$ \phi_0 = 0.5 T_0 - 0.5 T_1 $$ $$ \phi_1 = 0.5 T_0 + 0.5 T_1 $$

pub fn neumann_bc(n: usize) -> Self

Neumann boundary condition basis $$ \phi_0 = 0.5T_0 - 1/8T_1 $$ $$ \phi_1 = 0.5T_0 + 1/8T_1 $$

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

Return grid coordinates

Trait Implementations

impl<A: FloatNum> BaseSize for CompositeChebyshev<A>

fn len_phys(&self) -> usize

Size in physical space

fn len_spec(&self) -> usize

Size in spectral space

fn len_orth(&self) -> usize

Size of orthogonal space

impl<A: FloatNum> Basics<A> for CompositeChebyshev<A>

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

Coordinates in physical space

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

Returns transformation stencil

fn get_transform_kind(&self) -> &TransformKind

Return transform kind

impl<A: Clone + FloatNum> Clone for CompositeChebyshev<A>

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

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

impl<A: FloatNum> Differentiate<A> for CompositeChebyshev<A>

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

Differentiation in spectral space

use funspace::Differentiate;
use funspace::chebyshev::CompositeChebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = CompositeChebyshev::<f64>::dirichlet(5);
let mut input = array![1., 2., 3.];
let output = cheby.differentiate(&input, 2, 0);
approx_eq(&output, &array![-88.,  -48., -144., 0., 0. ]);

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

Differentiate on input array

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

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

Differentiation in spectral space

use funspace::Differentiate;
use funspace::chebyshev::CompositeChebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = CompositeChebyshev::<f64>::dirichlet(5);
let mut input = array![1., 2., 3.];
let output = cheby.differentiate(&input, 2, 0);
approx_eq(&output, &array![-88.,  -48., -144., 0., 0. ]);

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

Differentiate on input array

impl<A: FloatNum> DifferentiatePar<A> for CompositeChebyshev<A>

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

Differentiation in spectral space

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

Differentiate on input array

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

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

Differentiation in spectral space

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

Differentiate on input array

impl<T: FloatNum> From<CompositeChebyshev<T>> for BaseR2r<T>

fn from(v: CompositeChebyshev<T>) -> BaseR2r<T>

Performs the conversion.

impl<A: FloatNum> FromOrtho<A> for CompositeChebyshev<A>

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

Return coefficents in associated composite space

use funspace::chebyshev::CompositeChebyshev;
use ndarray::prelude::*;
use funspace::utils::approx_eq;
use funspace::FromOrtho;
let (nx, ny) = (5, 4);
let mut composite_coeff = Array2::<f64>::zeros((nx - 2, ny));
for (i, v) in composite_coeff.iter_mut().enumerate() {
    *v = i as f64;
}
let cd = CompositeChebyshev::<f64>::dirichlet(nx);

let expected = array![
    [0., 1., 2., 3.],
    [4., 5., 6., 7.],
    [8., 8., 8., 8.],
    [-4., -5., -6., -7.],
    [-8., -9., -10., -11.],
];
let parent_coeff = cd.to_ortho(&composite_coeff, 0);
approx_eq(&parent_coeff, &expected);

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

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

Return coefficents in associated composite space

use funspace::chebyshev::CompositeChebyshev;
use ndarray::prelude::*;
use funspace::utils::approx_eq;
use funspace::FromOrtho;
let (nx, ny) = (5, 4);
let mut parent_coeff = Array2::<f64>::zeros((nx, ny));
for (i, v) in parent_coeff.iter_mut().enumerate() {
    *v = i as f64;
}
let cd = CompositeChebyshev::<f64>::dirichlet(nx);

let expected = array![
    [-8., -8., -8., -8.],
    [-4., -4., -4., -4.],
    [-8., -8., -8., -8.],
];
let composite_coeff = cd.from_ortho(&parent_coeff, 0);
approx_eq(&composite_coeff, &expected);

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

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

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

Return coefficents in associated composite space

use funspace::chebyshev::CompositeChebyshev;
use ndarray::prelude::*;
use funspace::utils::approx_eq;
use funspace::FromOrtho;
let (nx, ny) = (5, 4);
let mut composite_coeff = Array2::<f64>::zeros((nx - 2, ny));
for (i, v) in composite_coeff.iter_mut().enumerate() {
    *v = i as f64;
}
let cd = CompositeChebyshev::<f64>::dirichlet(nx);

let expected = array![
    [0., 1., 2., 3.],
    [4., 5., 6., 7.],
    [8., 8., 8., 8.],
    [-4., -5., -6., -7.],
    [-8., -9., -10., -11.],
];
let parent_coeff = cd.to_ortho(&composite_coeff, 0);
approx_eq(&parent_coeff, &expected);

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

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

Return coefficents in associated composite space

use funspace::chebyshev::CompositeChebyshev;
use ndarray::prelude::*;
use funspace::utils::approx_eq;
use funspace::FromOrtho;
let (nx, ny) = (5, 4);
let mut parent_coeff = Array2::<f64>::zeros((nx, ny));
for (i, v) in parent_coeff.iter_mut().enumerate() {
    *v = i as f64;
}
let cd = CompositeChebyshev::<f64>::dirichlet(nx);

let expected = array![
    [-8., -8., -8., -8.],
    [-4., -4., -4., -4.],
    [-8., -8., -8., -8.],
];
let composite_coeff = cd.from_ortho(&parent_coeff, 0);
approx_eq(&composite_coeff, &expected);

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

impl<A: FloatNum> FromOrthoPar<A> for CompositeChebyshev<A>

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

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

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

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

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

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

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

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

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

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

Example

Forward transform along first axis

use funspace::Transform;
use funspace::chebyshev::CompositeChebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = CompositeChebyshev::dirichlet(5);
let input = array![1., 2., 3., 4., 5.];
let output = cheby.forward(&input, 0);
approx_eq(&output, &array![2., 0.70710678, 1.]);

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

See CompositeChebyshev::forward

use funspace::Transform;
use funspace::chebyshev::CompositeChebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = CompositeChebyshev::dirichlet(5);
let input = array![1., 2., 3., 4., 5.];
let mut output = Array1::<f64>::zeros(3);
cheby.forward_inplace(&input, &mut output, 0);
approx_eq(&output, &array![2., 0.70710678, 1.]);

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

Example

Backward transform along first axis

use funspace::Transform;
use funspace::chebyshev::CompositeChebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = CompositeChebyshev::dirichlet(5);
let input = array![1., 2., 3.];
let output = cheby.backward(&input, 0);
approx_eq(&output, &array![0.,1.1716, -4., 6.8284, 0. ]);

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

See CompositeChebyshev::backward

use funspace::Transform;
use funspace::chebyshev::CompositeChebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = CompositeChebyshev::dirichlet(5);
let input = array![1., 2., 3.];
let mut output = Array1::<f64>::zeros(5);
cheby.backward_inplace(&input, &mut output, 0);
approx_eq(&output, &array![0.,1.1716, -4., 6.8284, 0. ]);

type Physical = A

type Spectral = A

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

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

Parallel version. See CompositeChebyshev::forward

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

Parallel version. See CompositeChebyshev::forward_inplace

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

Parallel version. See CompositeChebyshev::backward

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

Parallel version. See CompositeChebyshev::backward_inplace

type Physical = A

Scalar type in physical space (before transform)

type Spectral = A

Scalar type in spectral space (after transfrom)

impl<T: FloatNum> TryInto<CompositeChebyshev<T>> for BaseR2r<T>

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.

Auto Trait Implementations

impl<A> !RefUnwindSafe for CompositeChebyshev<A>

impl<A> Send for CompositeChebyshev<A>

impl<A> Sync for CompositeChebyshev<A>

impl<A> Unpin for CompositeChebyshev<A>

impl<A> !UnwindSafe for CompositeChebyshev<A>

Blanket Implementations

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

pub fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

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

pub fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

pub fn from(t: T) -> T

Performs the conversion.

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

pub fn into(self) -> U

Performs the conversion.

impl<T> Pointable for T

pub const ALIGN: usize

The alignment of pointer.

type Init = T

The type for initializers.

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

Initializes a with the given initializer. Read more

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

Dereferences the given pointer. Read more

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

Mutably dereferences the given pointer. Read more

pub unsafe fn drop(ptr: usize)

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

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

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T

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

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

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

recently added

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Error = >::Error

The type returned in the event of a conversion error.