Struct funspace::chebyshev::Chebyshev

pub struct Chebyshev<A> {
    pub n: usize,
    pub m: usize,
    pub x: Array1<A>,
    // some fields omitted
}

Container for chebyshev space

Fields

n: usize

Number of coefficients in physical space

m: usize

Number of coefficients in spectral space ( equal to n in this case )

x: Array1<A>

Grid coordinates of chebyshev nodes (2nd kind).

Implementations

impl<A: FloatNum> Chebyshev<A>

pub fn new(n: usize) -> Self

Creates a new Basis.

Arguments

• n - Length of array’s dimension which shall live in chebyshev space.

Panics

Panics when input type cannot be cast from f64.

Examples

use funspace::chebyshev::Chebyshev;
let cheby = Chebyshev::<f64>::new(10);

pub fn differentiate_lane<T, S>(
    &self,
    data: &mut ArrayBase<S, Ix1>,
    n_times: usize
) where
    T: Scalar + From<A>,
    S: Data<Elem = T> + DataMut, 

Differentiat 1d Array n_times using the recurrence relation of chebyshev polynomials.

Differentiation is performed on input array directly.

Panics

Panics when input type cannot be cast from f64.

Example

Differentiate along lane

use funspace::chebyshev::Chebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = Chebyshev::<f64>::new(4);
// Differentiate twice
let mut input = array![1., 2., 3., 4.];
cheby.differentiate_lane(&mut input, 2);
approx_eq(&input, &array![12., 96.,  0.,  0.]);
// Differentiate zero times, return itself
let mut input = array![1., 2., 3., 4.];
cheby.differentiate_lane(&mut input, 0);
approx_eq(&input, &array![1., 2., 3., 4.]);

Trait Implementations

impl<A: FloatNum> BaseSize for Chebyshev<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 Chebyshev<A>

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

Coordinates in physical space

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

Return mass matrix (= eye)

fn get_transform_kind(&self) -> &TransformKind

Return transform kind

impl<A: Clone> Clone for Chebyshev<A>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: FloatNum> Differentiate<A> for Chebyshev<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, 

Return differentiated array

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

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

Return differentiated array

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

Differentiate on input array

impl<A: FloatNum> DifferentiatePar<A> for Chebyshev<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, 

Return differentiated array

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

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

Return differentiated array

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

Differentiate on input array

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

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

Performs the conversion.

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

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

Return itself

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, 

Return itself

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

Return itself

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, 

Return itself

impl<A: FloatNum> FromOrtho<Complex<A>> for Chebyshev<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 itself

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, 

Return itself

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 itself

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, 

Return itself

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

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

Return itself

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, 

Return itself

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

Return itself

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, 

Return itself

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

Return itself

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, 

Return itself

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, 

Return itself

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, 

Return itself

impl<A: FloatNum> LaplacianInverse<A> for Chebyshev<A>

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

Laplacian

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

Pseudoinverse Laplacian of chebyshev spectral differentiation matrices

Second order equations become banded when preconditioned with this matrix

Example

use funspace::chebyshev::Chebyshev;
use funspace::LaplacianInverse;
use funspace::utils::approx_eq;
use ndarray::s;
let ch = Chebyshev::<f64>::new(5);
let lap = ch.laplace();
let pinv = ch.laplace_inv();
let peye = pinv.dot(&lap);
approx_eq(&peye.slice(s![2..,..]).to_owned(), &ch.laplace_inv_eye());

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

Pseudoidentity matrix of laplacian

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

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::Chebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = Chebyshev::new(4);
let input = array![1., 2., 3., 4.];
let output = cheby.forward(&input, 0);
approx_eq(&output, &array![2.5, 1.33333333, 0. , 0.16666667]);

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 Chebyshev::forward

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::Chebyshev;
use funspace::utils::approx_eq;
use ndarray::prelude::*;
let mut cheby = Chebyshev::new(4);
let input = array![1., 2., 3., 4.];
let output = cheby.backward(&input, 0);
approx_eq(&output, &array![-2. ,  2.5, -3.5, 10.]);

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 Chebyshev::backward

Panics

Panics when input type cannot be cast from f64.

type Physical = A

type Spectral = A

impl<A: FloatNum> TransformPar for Chebyshev<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, 

Forward transform along first axis. See Chebyshev::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, 

See Chebyshev::forward_par

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, 

See Chebyshev::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, 

See Chebyshev::backward_par

Panics

Panics when input type cannot be cast from f64.

type Physical = A

Scalar type in physical space (before transform)

type Spectral = A

Scalar type in spectral space (after transfrom)

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

type Error = &'static str

The type returned in the event of a conversion error.

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

Performs the conversion.