sis.hpp File Reference
Include dependency graph for sis.hpp:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| class | sis::LinopMat< T > |
| This class represents a block matrix operator. It is a matrix of operators. More... | |
| class | sis::BcMat< T > |
| BcMat will hold general Boundary conditions as LinopMats at evealuation points, as given by operator L and evaluation points, eval. More... | |
| class | sis::MatGen< T > |
| This class sets up integration Matrices. This class must be intiated by the highest order of based on which integration matrices will be made. More... | |
| class | sis::SingularValueDecomposition< T > |
| This class computes various SingularValues of a differential block matrix operator using using it's adjoint. Class has various utilities, like computing the adjoint, adjoint boundary conditions, and also computing singular values of the frequency response operator. More... | |
| class | sis::Discretize< T > |
| Given a linear block matrix operator and appropriate boundary conditions, this class will produce an Eigen matrix representing the discretized version. The implementation will naturally involve column pivoting, and the pivot matrix is also stored. More... | |
| class | sis::Chebfun< T > |
| This is a chebfun analogue. Chebfun will represent both values in physical space or an array of Chebyshev-coefficients. Values can be in either space for calculations. To convert between physical values or Chebyshev coefficients, one can call Chebfun.c2p() and Chebfun.p2c(). More... | |
| class | sis::Chebfun< std::complex< T > > |
| Chebfun overload to complex type. More... | |
| class | sis::ChebfunMat< T > |
| This class holds a matrix of Chebfuns. More... | |
| class | sis::ChebfunMat< std::complex< T > > |
| ChebfunMat overloaded to complex type. More... | |
| class | sis::Linop< T > |
| Linop This class creates a Linear operator to solve TPBVPs. More... | |
| class | sis::Linop< std::complex< T > > |
| Overloads the Linop class to complex type. More... | |
| class | sis::EigenSorter< T > |
| This class stores functions and values needed to sort Eigenvalues. More... | |
| class | sis::GeneralizedEigenSolver< T > |
| This class will solve the generalized eigenvalue problem for two linear operators. One of them can be singular. More... | |
| class | sis::GeneralizedEigenSolver< std::complex< T > > |
| class | sis::EigenSolver< T > |
| This class computes the eigenvalues and eigenvectors (functions) of a Linear operator Linop. See documentation of Eigen on how to access eigenvalues and eigen vectors. More... | |
| class | sis::EigenSolver< std::complex< T > > |
| This class computes the eigenvalues and eigenvectors (functions) of a Linear operator Linop, overloaded to a complex Linop. More... | |
| class | sis::MatGen< T > |
| This class sets up integration Matrices. This class must be intiated by the highest order of based on which integration matrices will be made. More... | |
| class | sis::MatGen< std::complex< T > > |
| This class sets up integration Matrices. This class must be intiated by the highest order of based on which integration matrices will be made. More... | |
| class | sis::LinopMat< T > |
| This class represents a block matrix operator. It is a matrix of operators. More... | |
| class | sis::LinopMat< std::complex< T > > |
| This class represents a block matrix operator. It is a matrix of operators. More... | |
| class | sis::BcMat< T > |
| BcMat will hold general Boundary conditions as LinopMats at evealuation points, as given by operator L and evaluation points, eval. More... | |
| class | sis::BcMat< std::complex< T > > |
| class | sis::nChoosek< T > |
| Class to compute binomial coefficients \( \binom{n}{k} \) returns a double output. More... | |
| class | sis::nChoosek< std::complex< T > > |
| Class to compute binomial coefficients \( \binom{n}{k} \), returns complex<double> output. More... | |
| class | sis::SingularValueDecomposition< T > |
| This class computes various SingularValues of a differential block matrix operator using using it's adjoint. Class has various utilities, like computing the adjoint, adjoint boundary conditions, and also computing singular values of the frequency response operator. More... | |
| class | sis::Discretize< T > |
| Given a linear block matrix operator and appropriate boundary conditions, this class will produce an Eigen matrix representing the discretized version. The implementation will naturally involve column pivoting, and the pivot matrix is also stored. More... | |
| class | sis::Discretize< std::complex< T > > |
| Given a linear block matrix operator and appropriate boundary conditions, this class will produce an Eigen matrix representing the discretized version. The implementation will naturally involve column pivoting, and the pivot matrix is also stored. More... | |
| class | sis::SingularValueDecomposition< std::complex< T > > |
| This class computes various SingularValues of a differential block matrix operator using using it's adjoint. Class has various utilities, like computing the adjoint, adjoint boundary conditions, and also computing singular values of the frequency response operator. More... | |
Namespaces | |
| std | |
| sis | |
Macros | |
| #define | lapack_complex_double std::complex<double> |
| #define | lapack_complex_float std::complex<float> |
| #define | PI 3.141592653589793 |
| #define | SIS_SINGULAR 1 |
| #define | SIS_SVD 0 |
| #define | SIS_SVD_LEFT 1 |
| #define | SIS_SVD_RIGHT 2 |
| #define | SIS_PHYS_SPACE 1 |
| #define | SIS_CHEB_SPACE 0 |
| #define | SIS_TYPE double |
Functions | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::dou2com (const std::valarray< T > &a, const std::valarray< T > &b) |
| Use this to make a complex valarray out of two real valarrays. More... | |
| template<class T > | |
| valarray< T > | std::real (const valarray< complex< T > > &in) |
| real part of a complex valarray More... | |
| template<class T > | |
| valarray< T > | std::imag (const valarray< complex< T > > &in) |
| imaginary part of a complex valarray More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator* (std::complex< T > left, std::valarray< T > right) |
| Multiplying a complex number with a real valarray. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator* (const std::valarray< T > &left, const std::complex< T > &right) |
| Multiplying a real valarray with a complex number. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator+ (std::complex< T > left, std::valarray< T > right) |
| Adding a complex number to a real valarray. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator+ (const std::valarray< T > &left, std::complex< T > right) |
| Multiplying a real valarray with a complex number. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator- (std::complex< T > left, std::valarray< T > right) |
| Subtracting a real valarray from a complex number. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator- (const std::valarray< T > &left, const std::complex< T > &right) |
| Subtracting a complex number from a real valarray. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator* (T left, std::valarray< std::complex< T > > right) |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator* (const std::valarray< std::complex< T > > &left, const T &right) |
| Multiplying a real number with a complex valarray. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator+ (T left, std::valarray< std::complex< T > > right) |
| Adding a complex valarray to a real number. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator+ (const std::valarray< std::complex< T > > &left, const T &right) |
| Adding a real number with a complex valarray. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator- (T left, std::valarray< std::complex< T > > right) |
| Subtracting a real number from a complex valarray. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator- (const std::valarray< std::complex< T > > &left, const T &right) |
| Subtracting a complex valarray from a real number. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator* (const std::valarray< std::complex< T > > &left, const std::valarray< T > &right) |
| Multiplying a complex valarray to a real valarray: More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | std::operator* (const std::valarray< T > &left, const std::valarray< std::complex< T > > &right) |
| Multiplying a real valarray to a complex valarray: More... | |
| string | std::int2str (int i) |
| template<class T > | |
| valarray< complex< T > > | std::pow (valarray< complex< T > > base, T power) |
| std::valarray< std::complex< SIS_TYPE > > | sis::half_shift (N+1) |
| std::valarray< std::complex< SIS_TYPE > > | sis::rev_half_shift (N+1) |
| std::valarray< std::complex< SIS_TYPE > > | sis::yc (N+1) |
| std::valarray< SIS_TYPE > | sis::y (N+1) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::fft (std::valarray< T > in1) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::fft (std::slice_array< T > in1) |
| template<class T > | |
| std::valarray< T > | sis::ifft_cs (std::valarray< std::complex< T > > in) |
| template<class T > | |
| std::valarray< T > | sis::ifft_cs (std::slice_array< std::complex< T > > in) |
| template<class T > | |
| std::valarray< T > | sis::dct (const std::valarray< T > &x) |
| template<class T > | |
| std::valarray< T > | sis::dct (const std::slice_array< T > &x) |
| template<class T > | |
| std::valarray< T > | sis::idct (const std::valarray< T > &u) |
| template<class T > | |
| std::valarray< T > | sis::idct (const std::slice_array< T > &u) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::dct (const std::valarray< std::complex< T > > &in) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::dct (const std::slice_array< std::complex< T > > &in) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::idct (const std::valarray< std::complex< T > > &in) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::idct (const std::slice_array< std::complex< T > > &in) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::fft2 (std::valarray< T > in1, int Nx, int Nz) |
| fft2 for a 2D matrix stored in the row-major format, Nx and Nz denote dimensions in x and z. The return value is of size Nx * Nz / 2 of complex type, which implicitly assumes conjugate symmetry and also that the values at the Nyquist frequency are zero. More... | |
| template<class T > | |
| std::valarray< T > | sis::ifft2_cs (std::valarray< std::complex< T > > in1, int Nx, int Nz) |
| ifft2 for a 2D matrix stored in the row-major format, Nx and Nz denote dimensions in x and z. The input is of size (Nx x Nz / 2) of type complex double, which implicitly assumes conjugate symmetry and also that the values at the Nyquist frequency are zero. The return value is of size Nx * Nz of double type. More... | |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::fft2 (std::slice_array< T > in1, int Nx, int Nz) |
| template<class T > | |
| std::valarray< T > | sis::ifft2_cs (std::slice_array< std::complex< T > > in, int Nx, int Nz) |
| template<class T > | |
| std::valarray< std::complex< T > > | sis::dealias_prod_2D (std::valarray< std::complex< T > > a, std::valarray< std::complex< T > > b, int Nx, int Nz) |
| dealias_prod_2D for a 2D matrix stored in the row-major format, Nx and Nz denote dimensions in x and z. Input valarrays of size (Nx x Nz / 2) of type complex double, which implicitly assumes conjugate symmetry and also that the values at the Nyquist frequency are zero. The return value again complex double returning the dealiased convolution according to 3/2 rule. For example: pad zeros: Example: For an 8 x 8 matrix : More... | |
| template<class T > | |
| std::complex< T > | sis::size (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &in) |
| This function is useful to see size of Eigen matrices. Returns a complex number, where the real part indicates the number of rows and imaginary part the number of columns. More... | |
| template<class T > | |
| std::complex< T > | sis::size (const Eigen::Matrix< std::complex< T >, Eigen::Dynamic, Eigen::Dynamic > &in) |
| template<class T > | |
| void | sis::disp (std::valarray< T > in) |
| Prints a valarray to terminal. More... | |
| template<class T > | |
| void | sis::setChebPts (std::valarray< T > &in) |
| This function sets points to evaluate a function so that a DCT will give represent the same function in a Chebyshev basis. More... | |
| template<class T > | |
| void | sis::setChebPts (std::valarray< std::complex< T > > &in) |
| This function sets points to evaluate a function so that a DCT will give represent the same function in a Chebyshev basis, overloaded to complex type. More... | |
| template<class T > | |
| void | sis::setChebPts (Eigen::Array< T, Eigen::Dynamic, 1 > &in) |
| This function sets points to evaluate a function so that a DCT will give represent the same function in a Chebyshev basis, overloaded to Eigen array class. More... | |
| template<class T > | |
| void | sis::setChebPts (Eigen::Array< std::complex< T >, Eigen::Dynamic, 1 > &in) |
| This function sets points to evaluate a function so that a DCT will give represent the same function in a Chebyshev basis, overloaded to complex Eigen array class. More... | |
| void | sis::sis_setup () |
| template<class T > | |
| Eigen::Matrix< T, Eigen::Dynamic, 1 > | sis::diff (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &u) |
| Chebyshev differentiation operator for a vector of Chebyshev coefficients. More... | |
| template<class T > | |
| std::valarray< T > | sis::diff (const std::valarray< T > &u) |
| Chebyshev differentiation operator for a vector of Chebyshev coefficients. More... | |
| template<class T > | |
| Eigen::Matrix< T, Eigen::Dynamic, 1 > | sis::integ (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &u) |
| Chebyshev integration operator for a vector of Chebyshev coefficients. More... | |
| template<class T > | |
| std::valarray< T > | sis::integ (const std::valarray< T > &u) |
| Chebyshev integration operator for a vector of Chebyshev coefficients. More... | |
| template<class T > | |
| Eigen::Array< T, Eigen::Dynamic, 1 > | sis::integ (const Eigen::Array< T, Eigen::Dynamic, 1 > &u) |
| template<class T > | |
| Eigen::Array< std::complex< T >, Eigen::Dynamic, 1 > | sis::dou2com (const Eigen::Array< T, Eigen::Dynamic, 1 > &a, const Eigen::Array< T, Eigen::Dynamic, 1 > &b) |
| Use this to make a complex array out of two Eigen real valarrays. More... | |
| template<class T > | |
| Chebfun< T > | sis::conj (Chebfun< T > in) |
| Complex conjugate of a Chebfun. More... | |
| template<class T > | |
| Chebfun< std::complex< T > > | sis::conj (Chebfun< std::complex< T > > in) |
| Complex conjugate of a Chebfun. More... | |
| template<class T > | |
| Chebfun< T > | sis::diff (Chebfun< T > in, int n) |
| Chebyshev differentiation operator, to differentiate n times. More... | |
| template<class T > | |
| std::ostream & | sis::operator<< (std::ostream &stream, Chebfun< T > a) |
| This function overloads the cout<< operator to display the chebfun. More... | |
| template<class T > | |
| sis::ChebfunMat< T > | sis::conj (sis::ChebfunMat< T > in) |
| Complex Conjugate of a ChebfunMat. Not the conjugate transpose. See cTranspose() in ChebfunMat for complex conjugate transpose. More... | |
| template<class T > | |
| ChebfunMat< T > | sis::diff (ChebfunMat< T > in, int n) |
| Chebyshev differentiation operator, for a ChebfunMat, differeniates every Chebfun in the ChebfunMat n times. More... | |
| template<class T > | |
| Linop< T > | sis::diff (Linop< T > in, int n) |
| Differentiation operator for Linop, to differentiate n times. More... | |
| template<class T > | |
| Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > | sis::feval2D (std::valarray< ChebfunMat< T > > Amat, int r, int c, T a) |
| template<class T > | |
| Eigen::Matrix< std::complex< T >, Eigen::Dynamic, Eigen::Dynamic > | sis::feval2D (std::valarray< ChebfunMat< std::complex< T > > > Amat, int r, int c, T a) |
| void | sis::vtkExportCartesian2D3C (const std::string &flnm, const std::valarray< double > &y, const std::valarray< double > &z, const std::valarray< double > &u, const std::valarray< double > &v, const std::valarray< double > &w, const std::valarray< double > &p) |
| Exports all data of 2D3C to a file. There are two dimensions, the wall-normal and the spanwise, while there are three components, u, v, w, and also pressure. vtk file can be directly exported into paraview, or into Python using meshio Supply filename without .vtk extension, that will be automatically added. More... | |
| void | sis::vtkExportCartesian3D (const std::string &flnm, const std::valarray< double > &x, const std::valarray< double > &y, const std::valarray< double > &z, const std::valarray< double > &u, const std::valarray< double > &v, const std::valarray< double > &w, const std::valarray< double > &p) |
| Exports all data of 3D velocity to a file. VTK file can be directly exported into paraview, or into Python using meshio. Supply filename without .vtk extension, that will be automatically added. More... | |
| void | sis::vtkExportCartesianStress3D (const std::string &flnm, const std::valarray< double > &x, const std::valarray< double > &y, const std::valarray< double > &z, const std::valarray< double > &t11, const std::valarray< double > &t12, const std::valarray< double > &t13, const std::valarray< double > &t22, const std::valarray< double > &t23, const std::valarray< double > &t33) |
| Exports stress data to a file. VTK file can be directly exported into paraview, or into Python using meshio. Supply filename without .vtk extension, that will be automatically added. More... | |
| template<class T > | |
| Linop< T > | sis::conj (Linop< T > in) |
| template<class T > | |
| ChebfunMat< T > | sis::operator+ (ChebfunMat< T > a, ChebfunMat< T > b) |
| Defining addition of ChebfunMats. More... | |
| template<class T > | |
| std::vector< ChebfunMat< T > > | sis::operator+ (std::vector< sis::ChebfunMat< T > > a, std::vector< sis::ChebfunMat< T > > b) |
| Defining addition of vector of ChebfunMats. Used for eigenvectors, Singular values, adjoints etc. More... | |
| template<class T > | |
| std::ostream & | sis::operator<< (std::ostream &stream, std::valarray< T > a) |
| This function overloads std::cout<< to valarrays. More... | |
| template<class T > | |
| std::ostream & | sis::operator<< (std::ostream &stream, std::vector< T > a) |
| template<class T > | |
| Linop< T > | sis::operator- (const Linop< T > &in) |
| template<class T > | |
| Chebfun< T > | sis::operator- (const Chebfun< T > &in) |
| template<class T > | |
| Linop< T > | sis::operator+ (Linop< T > l_, Linop< T > r_) |
| template<class T > | |
| Linop< std::complex< T > > | sis::dou2com (Linop< T > real, Linop< T > imag) |
| Converts real and imaginary parts of a Linop to a complex Linop. More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< std::complex< T > > l_, Linop< T > r_) |
| Addition of two Linops, complex with real: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< T > l_, Linop< std::complex< T > > r_) |
| Addition of two Linops, real with complex: More... | |
| template<class T > | |
| Linop< T > | sis::operator+ (Linop< T > l_, Chebfun< T > r_) |
| Addition of Linop to Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< std::complex< T > > l_, Chebfun< std::complex< T > > r_) |
| Addition of two Linop with Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< T > l_, Chebfun< std::complex< T > > r_) |
| Addition of two Linop with Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< std::complex< T > > l_, Chebfun< T > r_) |
| Addition of Linop with Chebfun: More... | |
| template<class T > | |
| Linop< T > | sis::operator+ (Chebfun< T > l_, Linop< T > r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Chebfun< std::complex< T > > l_, Linop< std::complex< T > > r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Chebfun< T > l_, Linop< std::complex< T > > r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Chebfun< std::complex< T > > l_, Linop< T > r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< T > | sis::operator+ (Linop< T > l_, std::valarray< T > r_) |
| Addition of Linop to Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< std::complex< T > > l_, std::valarray< std::complex< T > > r_) |
| Addition of two Linop with Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< T > l_, std::valarray< std::complex< T > > r_) |
| Addition of two Linop with Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (Linop< std::complex< T > > l_, std::valarray< T > r_) |
| Addition of Linop with Chebfun: More... | |
| template<class T > | |
| Linop< T > | sis::operator+ (std::valarray< T > l_, const Linop< T > &r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (const std::valarray< std::complex< T > > &l_, const Linop< std::complex< T > > &r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (std::valarray< T > l_, Linop< std::complex< T > > r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (std::valarray< std::complex< T > > l_, Linop< T > r_) |
| Addition of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< T > | sis::operator- (Linop< T > l_, Linop< T > r_) |
| Subtraction for two Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Linop< std::complex< T > > l_, Linop< T > r_) |
| Subtraction of two Linops, complex with real: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Linop< T > l_, Linop< std::complex< T > > r_) |
| Subtraction of two Linops, real with complex: More... | |
| template<class T > | |
| Linop< T > | sis::operator- (Linop< T > l_, Chebfun< T > r_) |
| Subtraction of Linop to Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Linop< std::complex< T > > l_, Chebfun< std::complex< T > > r_) |
| Subtraction of two Linop with Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Linop< T > l_, Chebfun< std::complex< T > > r_) |
| Subtraction of two Linop with Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Linop< std::complex< T > > l_, Chebfun< T > r_) |
| Subtraction of Linop with Chebfun: More... | |
| template<class T > | |
| Linop< T > | sis::operator- (Chebfun< T > l_, Linop< T > r_) |
| Subtraction of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Chebfun< std::complex< T > > l_, Linop< std::complex< T > > r_) |
| Subtraction of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Chebfun< T > l_, Linop< std::complex< T > > r_) |
| Subtraction of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Chebfun< std::complex< T > > l_, Linop< T > r_) |
| Subtraction of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< T > | sis::operator- (Linop< T > l_, std::valarray< T > r_) |
| Subtraction of Linop to Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Linop< T > l_, std::valarray< std::complex< T > > r_) |
| Subtraction of two Linop with Chebfun: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (Linop< std::complex< T > > l_, std::valarray< T > r_) |
| Subtraction of Linop with Chebfun: More... | |
| template<class T > | |
| Linop< T > | sis::operator- (const std::valarray< T > &l_, const Linop< T > &r_) |
| Subtraction of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (std::valarray< T > l_, Linop< std::complex< T > > r_) |
| Subtraction of Chebfun to Linop: More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (std::valarray< std::complex< T > > l_, Linop< T > r_) |
| Subtraction of Chebfun to Linop: More... | |
| template<class T > | |
| Eigen::Array< T, Eigen::Dynamic, 1 > | sis::operator* (std::valarray< T > left, const Eigen::Array< T, Eigen::Dynamic, 1 > &right) |
| template<class T > | |
| Linop< T > | sis::operator* (std::valarray< T > left, Linop< T > right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator* (std::valarray< std::complex< T > > left, Linop< T > right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator* (std::valarray< T > left, Linop< std::complex< T > > right) |
| template<class T > | |
| Linop< T > | sis::operator* (Chebfun< T > left, Linop< T > right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator* (Chebfun< std::complex< T > > left, Linop< T > right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator* (Chebfun< T > left, Linop< std::complex< T > > right) |
| template<class T > | |
| Linop< T > | sis::operator* (T left, Linop< T > right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator* (std::complex< T > left, Linop< T > right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator* (T left, Linop< std::complex< T > > right) |
| template<class T > | |
| Linop< T > | sis::operator+ (const Linop< T > &left, T right) |
| Adding scalar to Linop. More... | |
| template<class T > | |
| Linop< T > | sis::operator+ (T left, const Linop< T > &right) |
| Adding Linop to scalar. More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (const Linop< std::complex< T > > &left, T right) |
| Adding scalar to Linop complex. More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (std::complex< T > left, const Linop< T > &right) |
| Adding Linop to scalar. More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (const Linop< T > &left, std::complex< T > right) |
| Adding scalar to Linop complex. More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator+ (T left, const Linop< std::complex< T > > &right) |
| Adding Linop to scalar. More... | |
| template<class T > | |
| Linop< T > | sis::operator- (const Linop< T > &left, T right) |
| Subracting scalar from Linop. More... | |
| template<class T > | |
| Linop< T > | sis::operator- (T left, const Linop< T > &right) |
| Adding Linop to scalar. More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (T left, const Linop< std::complex< T > > &right) |
| Adding Linop to scallar. More... | |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (std::complex< T > left, const Linop< T > &right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (const Linop< std::complex< T > > &left, T right) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator- (const Linop< T > &left, std::complex< T > right) |
| template<class T > | |
| Chebfun< T > | sis::operator* (T a, Chebfun< T > b) |
| Multiplying Chebfun to a constant: More... | |
| template<class T > | |
| Chebfun< T > | sis::operator* (Chebfun< T > b, T a) |
| Multiplying Chebfun to a constant: More... | |
| template<class T > | |
| Chebfun< std::complex< T > > | sis::operator* (Chebfun< std::complex< T > > b, T a) |
| Multiplying Chebfun to a constant: More... | |
| template<class T > | |
| Chebfun< std::complex< T > > | sis::operator* (T a, Chebfun< std::complex< T > > b) |
| Multiplying Chebfun to a constant: More... | |
| template<class T > | |
| ChebfunMat< T > | sis::operator* (T a, ChebfunMat< T > in) |
| Multiplying ChebfunMat to a constant, all Chebfuns in the ChebfunMat is multiplied by the constant. More... | |
| template<class T > | |
| ChebfunMat< std::complex< T > > | sis::operator* (T a, ChebfunMat< std::complex< T > > in) |
| Multiplying ChebfunMat to a constant, all Chebfuns in the ChebfunMat is multiplied by the constant. More... | |
| template<class T > | |
| ChebfunMat< std::complex< T > > | sis::operator* (std::complex< T > a, ChebfunMat< T > in) |
| Multiplying ChebfunMat to a constant, all Chebfuns in the ChebfunMat is multiplied by the constant. More... | |
| template<class T > | |
| std::valarray< ChebfunMat< T > > | sis::operator* (T a, std::valarray< ChebfunMat< T > > in) |
| Multiplying a vector of ChebfunMats to a constant, all Chebfuns in all ChebfunMats are multiplied by the constant. More... | |
| template<class T > | |
| std::valarray< ChebfunMat< std::complex< T > > > | sis::operator* (std::complex< T > a, std::valarray< ChebfunMat< T > > in) |
| Multiplying a vector of ChebfunMats to a constant, all Chebfuns in all ChebfunMats are multiplied by the constant. More... | |
| template<class T > | |
| std::valarray< ChebfunMat< T > > | sis::operator* (T a, std::valarray< ChebfunMat< std::complex< T > > > in) |
| Multiplying a vector of ChebfunMats to a constant, all Chebfuns in all ChebfunMats are multiplied by the constant. More... | |
| template<class T > | |
| Chebfun< T > | sis::operator* (Chebfun< T > a, Chebfun< T > b) |
| Multiplying two Chebfuns. If in same space, returns in same space, else defauts to SIS_PHYS_SPACE. More... | |
| template<class T > | |
| Chebfun< std::complex< T > > | sis::operator* (Chebfun< T > a, Chebfun< std::complex< T > > b) |
| template<class T > | |
| Chebfun< std::complex< T > > | sis::operator* (Chebfun< std::complex< T > > b, Chebfun< T > a) |
| template<class T > | |
| Linop< std::complex< T > > | sis::operator* (Linop< std::complex< T > > L1, Linop< T > L2) |
| template<class T > | |
| Linop< T > | sis::operator* (Linop< T > L1, Linop< std::complex< T > > L2) |
| template<class T > | |
| Chebfun< T > | sis::operator+ (Chebfun< T > a, Chebfun< T > b) |
| Addition for two chebfuns. If both functions are not in same space, then default evaluation will be in physical space. More... | |
| template<class T > | |
| Chebfun< std::complex< T > > | sis::operator+ (Chebfun< T > a, Chebfun< std::complex< T > > b) |
| template<class T > | |
| Chebfun< std::complex< T > > | sis::operator+ (Chebfun< std::complex< T > > a, Chebfun< T > b) |
| template<class T > | |
| Linop< T > | sis::pow (Linop< T > in, int a) |
| template<class T > | |
| LinopMat< T > | sis::operator+ (LinopMat< T > left, LinopMat< T > right) |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator+ (LinopMat< std::complex< T > > left, LinopMat< T > right) |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator+ (LinopMat< T > left, LinopMat< std::complex< T > > right) |
| template<class T > | |
| LinopMat< T > | sis::operator* (T a, LinopMat< T > right) |
| Multiplies all linops with the constant. More... | |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator* (T a, LinopMat< std::complex< T > > right) |
| Multiplies all linops with the constant. More... | |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator* (std::complex< T > a, LinopMat< T > right) |
| Multiplies all linops with the constant. More... | |
| template<class T > | |
| LinopMat< T > | sis::operator* (LinopMat< T > left, LinopMat< T > right) |
| Multiplication of LinopMats. More... | |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator* (LinopMat< std::complex< T > > left, LinopMat< T > right) |
| Multiplication of LinopMats. More... | |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator* (LinopMat< T > left, LinopMat< std::complex< T > > right) |
| Multiplication of LinopMats. More... | |
| template<class T > | |
| LinopMat< T > | sis::operator- (LinopMat< T > left, LinopMat< T > right) |
| Subtraction of LinopMats. More... | |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator- (LinopMat< std::complex< T > > left, LinopMat< T > right) |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator- (LinopMat< T > left, LinopMat< std::complex< T > > right) |
| template<class T > | |
| LinopMat< T > | sis::operator/ (LinopMat< T > left_, T right) |
| template<class T > | |
| LinopMat< std::complex< T > > | sis::operator/ (LinopMat< std::complex< T > > left_, T right) |
| template<class T > | |
| ChebfunMat< std::complex< T > > | sis::linSolve (const LinopMat< std::complex< T > > &Lmat_, const BcMat< std::complex< T > > &bcmat_, const ChebfunMat< std::complex< T > > &forc_) |
| Linear equation solver. More... | |
Variables | |
| int | ind = 0 |
| int | sis::N = 31 |
| Specifies number of Chebyshev polynomials, default N = 31. More... | |
| Eigen::Matrix< std::complex< SIS_TYPE >, Eigen::Dynamic, Eigen::Dynamic > | sis::ycEigen |
| Eigen::Matrix< SIS_TYPE, Eigen::Dynamic, Eigen::Dynamic > | sis::yEigen |
Macro Definition Documentation
◆ lapack_complex_double
◆ lapack_complex_float
◆ PI
| #define PI 3.141592653589793 |
Definition at line 464 of file sis.hpp.
Referenced by sis::Chebfun< T >::Chebfun(), sis::Chebfun< std::complex< T > >::Chebfun(), sis::operator<<(), and sis::setChebPts().
◆ SIS_CHEB_SPACE
| #define SIS_CHEB_SPACE 0 |
Definition at line 471 of file sis.hpp.
Referenced by sis::Chebfun< T >::c2p(), sis::Chebfun< std::complex< T > >::c2p(), sis::ChebfunMat< T >::c2p(), sis::ChebfunMat< std::complex< T > >::c2p(), sis::ChebfunMat< T >::ChebfunMat2EigenMat(), sis::ChebfunMat< std::complex< T > >::ChebfunMat2EigenMat(), sis::EigenSorter< T >::compute(), sis::GeneralizedEigenSolver< T >::compute(), sis::GeneralizedEigenSolver< std::complex< T > >::compute(), sis::GeneralizedEigenSolver< T >::compute_with_constraints(), sis::Chebfun< T >::cumsum(), sis::Chebfun< std::complex< T > >::cumsum(), sis::linSolve(), sis::Chebfun< T >::operator+=(), sis::Chebfun< std::complex< T > >::operator+=(), sis::operator<<(), sis::Chebfun< T >::operator=(), sis::Chebfun< std::complex< T > >::operator=(), sis::Chebfun< T >::p2c(), and sis::Chebfun< std::complex< T > >::p2c().
◆ SIS_PHYS_SPACE
| #define SIS_PHYS_SPACE 1 |
Definition at line 470 of file sis.hpp.
Referenced by sis::SingularValueDecomposition< std::complex< T > >::AdjointBc_analytical(), sis::Chebfun< T >::c2p(), sis::Chebfun< std::complex< T > >::c2p(), sis::Chebfun< T >::Chebfun(), sis::Chebfun< std::complex< T > >::Chebfun(), sis::Chebfun< T >::cumsum(), sis::Chebfun< std::complex< T > >::cumsum(), sis::diff(), sis::Chebfun< T >::L2norm(), sis::Chebfun< std::complex< T > >::L2norm(), sis::Chebfun< T >::MultMat(), sis::Chebfun< std::complex< T > >::MultMat(), sis::Chebfun< T >::operator()(), sis::Chebfun< std::complex< T > >::operator()(), sis::operator*(), sis::operator+(), sis::Chebfun< T >::operator+=(), sis::Chebfun< std::complex< T > >::operator+=(), sis::Linop< T >::operator=(), sis::Linop< std::complex< T > >::operator=(), sis::Chebfun< T >::p2c(), sis::Chebfun< std::complex< T > >::p2c(), sis::ChebfunMat< T >::p2c(), and sis::ChebfunMat< std::complex< T > >::p2c().
◆ SIS_SINGULAR
◆ SIS_SVD
| #define SIS_SVD 0 |
Definition at line 467 of file sis.hpp.
Referenced by sis::SingularValueDecomposition< std::complex< T > >::compute().
◆ SIS_SVD_LEFT
| #define SIS_SVD_LEFT 1 |
Definition at line 468 of file sis.hpp.
Referenced by sis::SingularValueDecomposition< std::complex< T > >::compute().
◆ SIS_SVD_RIGHT
| #define SIS_SVD_RIGHT 2 |
Definition at line 469 of file sis.hpp.
Referenced by sis::SingularValueDecomposition< std::complex< T > >::compute().
◆ SIS_TYPE
Variable Documentation
◆ ind
| int ind = 0 |
Definition at line 256 of file sis.hpp.
Referenced by sis::SingularValueDecomposition< T >::Adjoint(), sis::SingularValueDecomposition< T >::compute(), and main().
