Methods (ie member functions) are associated with the class indicated between parenthesis. If no parenthesis is present after the name, it is a function.
| absSquare | returns the square modulus of a number |
| Add | adds two vectors/matrices |
| Add | adds a distributed matrix to another one |
| AddDistantInteraction (DistributedMatrix) | adds a value to A(i, j) where i is local and j global |
| AddInteraction (Vector<T, VectSparse>) | adds a coefficient to the vector |
| AddInteractionRow (Vector<T, VectSparse>) | adds coefficients to the vector |
| AddInteraction (Matrix<T, General, ArrayRowSparse>) | adds/inserts an element in the matrix |
| AddInteractionColumn (Matrix<T, General, ArrayRowSparse>) | adds/inserts elements in a matrix column |
| AddInteractionRow (Matrix<T, General, ArrayRowSparse>) | adds/inserts an element in a matrix row |
| AddRowDistantInteraction (DistributedMatrix) | adds a value to A(i, j) where i is global and j local |
| Allocate (ArpackSolver) | allocation of internal arrays |
| Append (Vector<T>) | appends an element to the end of the vector |
| ApplyInversePermutation | permutes row and column numbers of a matrix |
| ApplyInversePermutation | applies the inverse of a permutation to a distributed matrix |
| ApplyPermutation | applies a permutation (rows and columns) to a distributed matrix |
| ApplyModifRot | applies rotation to 2-D points |
| ApplyPermutation | permutes row and column numbers of a matrix |
| ApplyRot | applies rotation to 2-D points |
| ApplyScalingEigenvec | applies spectral transformation to eigenvalues/eigenvectors |
| ApplySor (VirtualMatrix) | performs a over-relaxation step |
| Assemble | assembles a vector |
| Assemble (Vector<T, VectSparse>) | sorts row numbers (duplicate values are summed) |
| Assemble (Matrix<T, General, ArrayRowSparse>) | assembles the matrix (duplicate values are summed) |
| AssembleDistributed | assembles a distributed matrix |
| AssembleImagRow / AssembleImagColumn (Matrix<T, General, ArrayRowComplexSparse>) | assembles a row of imaginary part |
| AssembleRealRow / AssembleRealColumn (Matrix<T, General, ArrayRowComplexSparse>) | assembles a row of real part |
| AssembleRow / AssembleColumn (Matrix<T, General, ArrayRowSparse>) | assembles a row |
| AssembleVector | Assembles a distributed vector |
| AssembleVectorMin | Assembles a distributed vector by taking the minimum of two arrays |
| BiCg | BIConjugate Gradient |
| BiCgcr | BIConjugate Gradient Conjugate Residual |
| BiCgStab | BIConjugate Gradient STABilized |
| BiCgStabl | BIConjugate Gradient STABilized (L) |
| Cg | Conjugate Gradient |
| Cgne | Conjugate Gradient Normal Equation |
| Cgs | Conjugate Gradient Squared |
| CheckBounds | Checks if the indexes of an array/matrix are out of bounds |
| CheckBoundsSym | Checks if the indexes of a symmetric matrix are out of bounds |
| CheckBoundsTriang | Checks if the indexes of a triangular matrix are out of bounds |
| CheckParameter (ArpackSolver) | Checking input parameters |
| Clear (Vector) | removes all elements of the vector |
| Clear (Vector<T, VectSparse>) | removes all elements of the vector |
| Clear (VirtualMatrix) | removes all elements of the matrix |
| Clear (Matrix<T, General, ArrayRowSparse>) | removes all elements of the matrix |
| Clear (Array3D<T>) | removes all elements of the 3-D array |
| Clear (Array4D<T>) | removes all elements of the 4-D array |
| Clear (Array<T, N>) | removes all elements of the N-D array |
| Clear (Vector2) | removes all elements of an inner or outer vector |
| Clear (Vector3) | removes all elements of an inner or outer vector |
| Clear (SparseDirectSolver) | Releases memory used by factorization |
| Clear(IlutPreconditioning) | clears memory used by incomplete factorisation |
| Clear (EigenProblem_Base) | Clears memory used by factorizations (if any present) |
| Clear (ArpackSolver) | Clears memory used by internal arrays |
| Clear (DistributedMatrix) | erases the matrix |
| Clear (DistributedMatrixIntegerArray) | clears stored arrays |
| ClearArpackVerbose (ArpackSolver) | returns to silent mode |
| ClearImagRow / ClearImagColumn (Matrix<T, General, ArrayRowComplexSparse>) | clears a row of imaginary part |
| ClearRealRow / ClearRealColumn (Matrix<T, General, ArrayRowComplexSparse>) | clears a row of real part |
| ClearRow / ClearColumn (Matrix<T, General, ArrayRowSparse>) | clears a row |
| CoCg | Conjugate Orthogonal Conjugate Gradient |
| ComplexAbs | returns the modulus of a number |
| ComputeAndFactorizeStiffnessMatrix (EigenProblem_Base) | Computation and factorization of a M + b K |
| ComputeDiagonalMass (EigenProblem_Base) | Computation of diagonal of M |
| ComputeMassForCholesky (EigenProblem_Base) | Computes the mass matrix for a Cholesky factorization |
| ComputeMassMatrix (EigenProblem_Base) | Computation of mass matrix M |
| ComputeOperator (PolynomialEigenProblem_Base) | computes a linear combination of matrices Ai |
| ComputeSolution (EigenProblem_Base) | Solves (a M + b K) x = b by using factorization |
| ComputeStiffnessMatrix (EigenProblem_Base) | Computation of stiffness matrix K |
| conjugate | returns the conjugate of a number |
| Conjugate | conjugates a vector/matrix |
| Conjugate | computes the conjugate of a distributed matrix |
| ConstructArrays (DistributedMatrixIntegerArray) | constructs stored arrays from global row numbers |
| ConstructPreconditioner (HyprePreconditioner) | Constructs the preconditioning by calling Hypre |
| Continue (ArpackSolver) | performs one step of the algorithm, returns true if the iterative algorithm has ended |
| ConvertMatrix_from_Coordinates | conversion of a matrix given as a triplet (i, j, val) to a sparse matrix |
| ConvertMatrix_to_Coordinates | conversion of a sparse matrix into coordinates format |
| ConvertToCSC | converts a sparse matrix to CSC (Compressed Sparse Column) format |
| ConvertToCSR | converts a sparse matrix to CSR (Compressed Sparse Row) format |
| ConvertToSparse | converts dense matrices to sparse matrices by specifying a threshold. |
| Copy | copies one vector into another one |
| Copy (Vector) | copies a vector |
| Copy | copies a sparse matrix into another one (conversion of format if needed) |
| Copy (Vector<T, VectSparse>) | copies a vector |
| Copy (Matrix<T>) | copies a matrix |
| Copy | Copies/Converts a distributed matrix into another one |
| Copy (Array3D<T>) | copies a 3-D array |
| Copy (Array4D<T>) | copies a 4-D array |
| Copy (Array<T, N>) | copies a N-D array |
| Copy (Vector2) | copies a vector of vectors |
| CopySubMatrix | extracts a sub-matrix from a sparse matrix |
| Deallocate (ArpackSolver) | deallocation of internal arrays |
| DiagonalMass (EigenProblem_Base) | Returns true if eigenvalues of M-1/2 K M-1/2are searched (M diagonal) |
| DiagonalMass (PolynomialEigenProblem_Base) | returns true if the mass matrix is diagonal |
| DisableOutOfCore(MatrixMumps) | Disable out-of-core computations |
| DistributeEigenvectors (GeneralEigenProblem) | Distributes eigenvectors among processors (parallel) |
| DoNotRefineSolution(SparseDirectSolver) | Does not refine the solution when calling solve |
| DotProd | scalar product between two vectors |
| DotProd | returns the scalar product between distributed vectors |
| DotProdConj | scalar product between two vectors, first vector being conjugated |
| DotProdConj | returns the scalar product between distributed vectors, the first one being conjugated |
| EnableCommandLineOptions (SlepcParamNep) | allows the user to provide parameters of the solver through the command line |
| EnableEstimateNumberEigenval (FeastParam) | Asks Feast to estimate the number of eigenvalues contained in the selected region |
| EnableOutOfCore(MatrixMumps) | Enables out-of-core computations |
| ExchangeVector | Exchanges values shared by processors |
| ExchangeRelaxVector | Exchanges with relaxation values shared by processors |
| ErrorCode (Iteration) | returns error code |
| EraseCol | erases columns in the distributed matrix |
| EraseCol | erases several columns of a sparse matrix |
| EraseRow | erases rows in the distributed matrix |
| EraseRow | erases several rows of a sparse matrix |
| EstimateNumberEigenval (FeastParam) | returns true if we require an estimate of the number of eigenvalues contained in the selected region |
| Factorize (SparseDirectSolver) | Performs the factorization of a sparse matrix |
| Factorize (SparseCholeskySolver) | Performs the factorization of a sparse matrix |
| Factorize (SparseDistributedSolver) | Factorize a sequential matrix or a distributed matrix |
| Factorize (DistributedCholeskySolver) | Factorize a sequential matrix or a distributed matrix |
| FactorizeCholeskyMass (EigenProblem_Base) | Computation of Cholesky factor L of mass matrix (M = L LT |
| FactorizeDiagonalMass (EigenProblem_Base) | Computation of M1/2, once M is known |
| FactorizeDistributed (SparseDirectSolver) | Performs the factorization of a distributed matrix (parallel execution) |
| FactorizeMass (PolynomialEigenProblem_Base) | factorizes the mass matrix |
| FactorizeMatrix(MatrixCholmod) | Factorizes a matrix using cholmod |
| FactorizeMatrix(MatrixMumps) | Factorizes a matrix using Mumps |
| FactorizeMatrix(MatrixPardiso) | Factorizes a matrix using Pardiso |
| FactorizeMatrix(MatrixPastix) | Factorizes a matrix using Pastix |
| FactorizeMatrix(SparseSeldonSolver) | Factorizes a matrix using Seldon |
| FactorizeMatrix(MatrixSuperLU) | Factorizes a matrix using SuperLU |
| FactorizeMatrix(MatrixUmfPack) | Factorizes a matrix using UmfPack |
| FactorizeMatrix(MatrixWsmp) | Factorizes a matrix using Wsmp |
| FactorizeMatrix (IlutPreconditioning) | performs incomplete factorisation |
| FactorizeOperator (PolynomialEigenProblem_Base) | factorizes a linear combination of matrices Ai |
| Fail (Iteration) | informs that the iterative solver failed |
| Fill (Vector) | sets all elements to a given value |
| Fill (Vector<T, VectSparse>) | sets all elements to a given value |
| Fill (Matrix<T>) | sets all elements to a given value |
| Fill (Matrix<T, General, ArrayRowSparse>) | sets all elements to a given value |
| Fill (Array3D<T>) | sets all elements to a given value |
| Fill (Array4D<T>) | sets all elements to a given value |
| Fill (Array<T, N>) | sets all elements to a given value |
| Fill (Vector2) | fills outer or inner vectors with the same value |
| Fill (Vector3) | fills outer or inner vectors with the same value |
| Fill (DistributedMatrix) | fills non-zero entries with 0, 1, 2, etc |
| FillComplexEigenvectors (GeneralEigenProblem) | Fills complex eigenvectors (instead of using Lapack form) |
| FillRand (Vector) | fills randomly the vector |
| FillRand (Vector<T, VectSparse>) | fills randomly the vector |
| FillRand (Matrix<T>) | fills randomly the matrix |
| FillRand (Matrix<T, General, ArrayRowSparse>) | fills randomly the matrix |
| FillRand (Array3D<T>) | fills randomly the elements |
| FillRand (Array4D<T>) | fills randomly the elements |
| FillRand (Array<T, N>) | fills randomly the elements |
| FillRand (DistributedMatrix) | fills non-zero entries with random values |
| FinalizeSeldon | initializes Seldon (at the beginning of the program) |
| FindEigenvaluesArpack | computes eigenvalues and eigenvectors of a given problem by calling Arpack |
| FindEigenvaluesFeast | computes eigenvalues and eigenvectors of a given problem by calling Feast |
| FindEigenvaluesSlepc | computes eigenvalues and eigenvectors of a given problem by calling Slepc |
| FindOrdering(MatrixMumps) | computes matrix ordering to reduce fill-in during factorisation |
| FindSparseOrdering | computes matrix ordering to reduce fill-in during factorisation |
| Finish (ArpackSolver) | completes computation of eigenvalues and eigenvectors |
| Finished (Iteration) | returns true if the stopping criteria are satisfied |
| First (Iteration) | returns true for the first iteration |
| Flatten (Vector2) | copies the elements into a simple vector |
| Flatten (Vector3) | copies the elements into a simple vector |
| FullBasis (SlepcParamNep) | returns true if a full basis in nep solver is used |
| GatherSparseEntry | fills a sparse vector with a dense one |
| GatherSparseEntryZero | fills a sparse vector with a dense one, the dense vector is zeroed. |
| Gauss | basic Gauss pivoting for dense matrices. |
| GaussSeidel | performs a Gauss-Seidel iteration for dense matrices. |
| Gcr | Generalized Conjugate Residual |
| Get (Matrix<T>) | returns reference to A(i, j) |
| Get (Matrix<T, General, ArrayRowSparse>) | returns reference to A(i, j) |
| GetAdditionalFillNumber (IlutPreconditioning) | returns the number of additional elements per row (used for ILUT(k)) |
| GetAnasaziParameters (EigenProblem_Base) | Returns the class storing parameters specific to Anasazi |
| GetAndSolveLU | factorisation and resolution of a linear system |
| GetAngleEllipseSpectrum (FeastParam) | Gets the angle of the ellipse where eigenvalues are searched |
| GetBaseString | returns the base (without the extension) of a file name |
| GetBlockSize (SlepcParam) | Returns the block size |
| GetBorthogonalization (SlepcParam) | Returns the orthogonalization used in GD/JD solver |
| GetCholesky | performs a Cholesky factorization of a sparse matrix |
| GetCholesky | performs a Cholesky (A = LLT) factorization for symmetric positive definite matrices |
| GetCircleCenterSpectrum (FeastParam) | Gets the center of the circle where eigenvalues are searched |
| GetCircleRadiusSpectrum (FeastParam) | Gets the radius of the circle where eigenvalues are searched |
| GetCol | extracts a matrix column |
| GetCol | extracts a column of a distributed matrix |
| GetColPermutation(MatrixSuperLU) | returns the permutation used for the rows |
| GetColSum | sums absolute values of non-zero entries by column |
| GetColSum | computes the sum of absolute values for each column of distributed matrices |
| GetCommunicator (DistributedVector) | returns the communicator associated with the distributed vector |
| GetCommunicator (DistributedMatrix) | returns the MPI communicator associated with the matrix |
| GetCommunicator (GeneralEigenProblem) | Returns the MPI communicator associated with the eigenvalue problem |
| GetComparisonEigenvalueSlepc (GeneralEigenProblem) | compares two eigenvalues with a user-defined function |
| GetComplexShift (GeneralEigenProblem) | Forms a complex shift from real/imaginary part |
| GetConvergedNumber (ArpackSolver) | returns the number of converged eigenvalues |
| GetComputationalMode (EigenProblem_Base) | Returns the computational mode used (regular, shifted, ...) |
| GetData (Vector) | returns a pointer to the array contained in the vector |
| GetData (Vector<T, VectSparse>) | returns a pointer to the values |
| GetData (Matrix<T>) | returns a pointer to the array containing the values |
| GetData (Matrix<T, General, ArrayRowSparse>) | returns a pointer to the array containing the values |
| GetData (Matrix<T, General, RowSparse>) | returns a pointer to the array containing the values |
| GetData (Array3D<T>) | returns a pointer to the array containing the values |
| GetData (Array4D<T>) | returns a pointer to the array containing the values |
| GetData (Array<T, N>) | returns a pointer to the array containing the values |
| GetDataConst (Vector) | returns a pointer to the array contained in the vector |
| GetDataConst (Vector<T, VectSparse>) | returns a pointer to the values |
| GetDataConst (Matrix<T>) | returns a pointer to the array containing the values |
| GetDataConstVoid (Vector) | returns a pointer to the array contained in the vector |
| GetDataConstVoid (Vector<T, VectSparse>) | returns a pointer to the values |
| GetDataConstVoid (Matrix<T>) | returns a pointer to the array containing the values |
| GetDataPointer (Array3D<T>) | returns a pointer to A(i, j, k) |
| GetDataPointer (Array4D<T>) | returns a pointer to A(i, j, k, l) |
| GetDataSize (Vector) | returns the number of elements in the vector |
| GetDataSize (Vector<T, VectSparse>) | returns the number of elements in the vector |
| GetDataSize (Matrix<T>) | returns the number of elements effectively stored |
| GetDataSize (Matrix<T, General, ArrayRowSparse>) | returns the number of elements effectively stored |
| GetDataSize (Array3D<T>) | returns the number of elements effectively stored |
| GetDataSize (Array4D<T>) | returns the number of elements effectively stored |
| GetDataSize (Array<T, N>) | returns the number of elements effectively stored |
| GetDataSize (DistributedMatrix) | returns the number of non-zero entries stored in the matrix |
| GetDataVoid (Vector) | returns a pointer to the array contained in the vector |
| GetDataVoid (Vector<T, VectSparse>) | returns a pointer to the values |
| GetDataVoid (Matrix<T>) | returns a pointer to the array containing the values |
| GetDiagonalCoefficient (IlutPreconditioning) | returns diagonal coefficient used in ILUD |
| GetDirectSolver (SparseDirectSolver) | Returns the direct solver that will be used during the factorization |
| GetDirectSolver (SplitSparseNonLinearEigenProblem) | returns the direct solver used for preconditioning |
| GetDistantColSize (DistributedMatrix) | returns the number of distant non-zero entries for row i |
| GetDistantRowSize (DistributedMatrix) | returns the number of distant non-zero entries for column i |
| GetDoubleExpansion (SlepcParam) | Returns the double expansion flag used in GD/JD solver |
| GetDroppingThreshold (IlutPreconditioning) | returns threshold to determine elements to drop in ilut preconditioning |
| GetEigenvalues | computes eigenvalues |
| GetEigensolverType (AnasaziParam) | Returns the eigensolver to use in Anasazi |
| GetEigensolverType (SlepcParam) | Returns the eigensolver to use |
| GetEigensolverType (SlepcParamPep) | returns the eigensolver to use in PEP |
| GetEigensolverType (SlepcParamNep) | returns the eigensolver to use in NEP |
| GetEigensolverChar (SlepcParam) | Returns the eigensolver to use (as a string) |
| GetEigenvaluesEigenvectors | computes eigenvalues and eigenvectors |
| GetEigenvaluesEigenvectors | computes some eigenvalues and eigenvectors of sparse matrices |
| GetEigenValue (ArpackSolver) | returns i-th eigenvalue |
| GetEigenVector (ArpackSolver) | returns pointer to i-th eigenvector |
| GetExtension | returns the extension (without the point) of a file name |
| GetExtractionType (SlepcParam) | Returns the type of extraction to use in CISS |
| GetFactorisationType(IlutPreconditioning) | returns the type of incomplete factorisation |
| GetFeastParameters (EigenProblem_Base) | Returns the class storing parameters specific to FEAST |
| GetFeastParameters (PolynomialEigenProblem_Base) | returns the parameters for Feast |
| GetFillLevel (IlutPreconditioning) | returns the fill-level k (if ILU(k) is set) |
| GetFirstWorkVector (ArpackSolver) | returns pointer to first working vector |
| GetGlobalCommunicator (GeneralEigenProblem) | Returns the global MPI communicator associated with the eigenvalue problem |
| GetGlobalM (DistributedMatrix) | returns the global number of rows |
| GetGlobalM (GeneralEigenProblem) | Returns the global number of rows of the eigenproblem |
| GetGlobalRankCommunicator (GeneralEigenProblem) | Gets the rank of the processor in the global MPI communicator |
| GetGlobalRowNumber (DistributedMatrix) | returns local to global numbering |
| GetHessenberg | reduces a dense matrix to its Hessenberg form |
| GetImag (Matrix<T, General, ArrayRowComplexSparse>) | returns a reference to imaginary part of A(i, j) |
| GetImagData (Matrix<T, General, ArrayRowComplexSparse>) | returns a pointer to the array containing the values of the imaginary part |
| GetImagDataSize (Matrix<T, General, ArrayRowComplexSparse>) | returns the number of elements effectively stored for the imaginary part |
| GetImagInd (Matrix<T, General, ArrayRowComplexSparse>) | returns a pointer to the array containing the column indexes of the imaginary part |
| GetImagIndSize (Matrix<T, General, RowComplexSparse>) | returns size of array Ind of imaginary part |
| GetImagNonZeros (Matrix<T, General, ArrayRowComplexSparse>) | returns the number of elements effectively stored for the imaginary part |
| GetImagPtr (Matrix<T, General, RowComplexSparse>) | returns size of array Ptr of imaginary part |
| GetImagPtrSize (Matrix<T, General, RowComplexSparse>) | returns a pointer to the array containing row numbers of imaginary part |
| GetImagRowSize / GetImagColumnSize (Matrix<T, General, ArrayRowComplexSparse>) | returns the number of elements in the row of imaginary part |
| GetImagShiftValue (GeneralEigenProblem) | Returns imaginary part of the shift (real unsymmetric problem) |
| GetInd (Matrix<T, General, RowSparse>) | returns a pointer to the array containing column numbers |
| GetIndex (Vector<T, VectSparse>) | returns a pointer to the row numbers |
| GetIndex (Matrix<T, General, ArrayRowSparse>) | returns a pointer to the array containing column numbers |
| GetIndSize (Matrix<T, General, RowSparse>) | returns size of array Ind |
| GetInfoFactorization (SparseDirectSolver) | Returns an error code associated with the factorisation (0 if successful) |
| GetInfoFlag (ArpackSolver) | returns info parameter (result of iterative algorithm) |
| GetInitialSize (SlepcParam) | Returns the initial size used in GD/JD solver |
| GetInnerSteps (SlepcParam) | Returns the number of inner steps |
| GetInterpolationDegree (SlepcParamNep) | returns the polynomial degree to use for the interpolation |
| GetInterpolationTolerance (SlepcParamNep) | returns the threshold to use for the interpolation |
| GetInverse | computes the matrix inverse |
| GetKrylovRestart (SlepcParam) | Returns the Krylov start flag used in GD/JD solver |
| GetLength (Vector) | returns the number of elements in the vector |
| GetLength (Vector<T, VectSparse>) | returns the number of elements in the vector |
| GetLength (Array<T, N>) | returns the number of elements along a dimension of the array |
| GetLength (Vector2) | returns the size of inner vectors or outer vectors |
| GetLength ((Vector3) | returns the size of inner vectors or outer vectors |
| GetLength1 (Array3D<T>) | returns the number of elements in the first dimension of 3-D array |
| GetLength1 (Array4D<T>) | returns the number of elements in the first dimension of 4-D array |
| GetLength2 (Array3D<T>) | returns the number of elements in the second dimension of 3-D array |
| GetLength2 (Array4D<T>) | returns the number of elements in the second dimension of 4-D array |
| GetLength3 (Array3D<T>) | returns the number of elements in the third dimension of 3-D array |
| GetLength3 (Array4D<T>) | returns the number of elements in the third dimension of 4-D array |
| GetLength4 (Array4D<T>) | returns the number of elements in the fourth dimension of 4-D array |
| GetLiMin (SlepcParamNep) | returns the minimal value of imaginary part of λ |
| GetLiMax (SlepcParamNep) | returns the maximal value of imaginary part of lambda |
| GetLocalM (DistributedMatrix) | returns the local number of rows |
| GetLocalN (DistributedMatrix) | returns the local number of rows |
| GetLowerBoundInterval (FeastParam) | Returns the lower bound for the interval where eigenvalues are searched (Feast) |
| GetLowerTriangular | extracts lower triangular part of a matrix |
| GetLQ | LQ factorization of matrix |
| GetLrMin (SlepcParamNep) | returns the minimal value of real part of λ |
| GetLrMax (SlepcParamNep) | returns the maximal value of real part of lambda |
| GetLU | performs a LU (or LDL^t) factorization |
| GetLU | performs a LU factorization of a sparse matrix |
| GetM (Vector) | returns the number of elements in the vector |
| GetM (Vector<T, VectSparse>) | returns the number of non-zero entries in the vector |
| GetM (VirtualMatrix) | returns the number of rows in the matrix |
| GetM (Matrix<T, General, ArrayRowSparse>) | returns the number of rows in the matrix |
| GetM (GeneralEigenProblem) | Returns the local number of rows of the eigenproblem |
| GetM (SparseDirectSolver) | Returns the number of rows of the factorized linear system |
| GetMaxAbsIndex | returns index where highest absolute value is reached |
| GetMaxDataSizeDistantCol (DistributedMatrix) | returns the number of values in distant columns stored in all the processors |
| GetMaxDataSizeDistantRow (DistributedMatrix) | returns the number of values in distant rows stored in all the processors |
| GetMaximumBlockSize (SlepcParam) | Returns the maximum block size |
| GetMemorySize (Vector<T, VectSparse>) | returns the memory used to store the vector in bytes |
| GetMemorySize (DistributedMatrix) | returns the size used by this object in bytes |
| GetMemorySize (Matrix<T, General, ArrayRowSparse>) | returns the memory used to store the matrix in bytes |
| GetMemorySize (Array3D<T>) | returns the memory used to store the array |
| GetMemorySize (Array4D<T>) | returns the memory used to store the array |
| GetMemorySize(SparseDirectSolver) | returns the memory used by the solver in bytes |
| GetMemorySize (Vector2) | returns the memory used by the object in bytes |
| GetMemorySize (Vector3) | returns the memory used by the object in bytes |
| GetMethod (SlepcParam) | Returns the method to use in PRIMME solver |
| GetMomentSize (SlepcParam) | Returns the moment size |
| GetN (VirtualMatrix) | returns the number of columns in the matrix |
| GetN (Matrix<T, General, ArrayRowSparse>) | returns the number of columns in the matrix |
| GetN (GeneralEigenProblem) | Returns the local number of columns of the eigenproblem |
| GetN (SparseDirectSolver) | Returns the number of columns of the factorized linear system |
| GetNbAdditionalEigenvalues (EigenProblem_Base) | Returns the number of additional eigenvalues (workaround due to Arpack bug) |
| GetNbArnoldiVectors (GeneralEigenProblem) | Returns the number of Arnoldi vectors |
| GetNbAskedEigenvalues (GeneralEigenProblem) | Returns the number of wanted eigenvalues |
| GetNbBlocks (AnasaziParam) | Returns the number of blocks to use in Anasazi solvers |
| GetNbLinearSolves (GeneralEigenProblem) | returns the number of linear solves performed by the eigensolver |
| GetNbMatrixVectorProducts (GeneralEigenProblem) | Returns the number of matrix-vector products performed by the eigenvalue solver |
| GetNbMaximumIterations (GeneralEigenProblem) | Returns the maximum number of iterations allowed for the iterative process |
| GetNbMaximumRestarts (AnasaziParam) | Returns the maximal number of restarts in Anasazi |
| GetNbOverlap (DistributedVector) | returns the numbers of rows already handled by another processor |
| GetNbScalarUnknowns (DistributedMatrix) | returns the number of scalar unknowns |
| GetNelement (Vector2) | returns the total number of elements stored |
| GetNelement (Vector3) | returns the total number of elements stored |
| GetNonZeros (Matrix<T, General, RowSparse>) | returns the number of elements effectively stored |
| GetNodlScalar (DistributedMatrix) | returns the number of rows for a scalar unknown |
| GetNonZeros (DistributedMatrix) | returns the number of non-zero entries stored in the matrix |
| GetNonZeros (Matrix<T, General, ArrayRowSparse>) | returns the number of non-zero entries stored in the matrix |
| GetNormInf (Vector) | returns highest absolute value |
| GetNormInf (Vector<T, VectSparse>) | returns highest absolute value |
| GetNormInfIndex (Vector) | returns the index of the highest absolute value |
| GetNormInfIndex (Vector<T, VectSparse>) | returns the index of the highest absolute value |
| GetNumberConvergedVectors (SlepcParam) | Returns the number of converged vectors |
| GetNumberConvergedVectorsProjected (SlepcParam) | Returns the number of projected converged vectors |
| GetNumberIntegrationPoints (SlepcParam) | Returns the number of integration points to use |
| GetNumberIteration (Iteration) | returns iteration number |
| GetNumberOfSteps (SlepcParam) | Returns the number of steps |
| GetNumberOfThreadPerNode (SparseDirectSolver) | Returns the number of threads per node (relevant for Pastix only) |
| GetNumberPartitions (SlepcParam) | Returns the number of partitions |
| GetNumOfQuadraturePoints (FeastParam) | returns the number of quadrature points used in the contour |
| GetOrthoManager (AnasaziParam) | Returns the orthogonalization manager in Anasazi |
| GetOuterSteps (SlepcParam) | Returns the number of outer steps |
| GetOverlapProcNumber (DistributedMatrix) | returns the array containing the processor numbers of rows already handled by an another processor |
| GetOverlapRow (DistributedVector) | returns a row number already handled by another processor |
| GetOverlapRowNumber (DistributedMatrix) | returns the array containing the numbers of rows already handled by an another processor |
| GetPivotBlockInteger (IlutPreconditioning) | returns the maximum k = |i-j| allowed when pivoting for ilut preconditioning |
| GetPivotThreshold (IlutPreconditioning) | returns threshold used when pivoting columns for ilut preconditioning |
| GetPolynomialDegree (PolynomialEigenProblem_Base) | returns the polynomial degree |
| GetPrintLevel (GeneralEigenProblem) | Returns the print level |
| GetPrintLevel (IlutPreconditioning) | returns the verbose level |
| GetProcessorSharingRows (DistributedMatrix) | returns the list of processors that share rows with the current processor |
| GetPseudoInverse | computes the pseudo-inverse of a given matrix |
| GetPtr (Matrix<T, General, RowSparse>) | returns a pointer to the array containing row numbers |
| GetPtrSize (Matrix<T, General, RowSparse>) | returns size of array Ptr |
| GetQ_FromQR | Forms explicitely Q from QR factorization |
| GetQ_FromLQ | Forms explicitely Q from LQ factorization |
| GetQR | QR factorization of matrix |
| GetQR_Pivot | QR factorization of matrix with pivoting |
| GetQuadratureRuleType (SlepcParam) | Returns the type of quadrature rules to use in CISS |
| GetRankCommunicator (GeneralEigenProblem) | Gets the rank of the processor in the MPI communicator |
| GetRatioEllipseSpectrum (FeastParam) | Gets the ratio of the ellipse where eigenvalues are searched |
| GetRciCommunicator (GeneralEigenProblem_Base) | Returns an intermediate MPI communicator associated with the eigenvalue problem (L2 for Feast) |
| GetReal (Matrix<T, General, ArrayRowComplexSparse>) | returns a reference to real part of A(i, j) |
| GetRealData (Matrix<T, General, ArrayRowComplexSparse>) | returns a pointer to the array containing the values of the real part |
| GetRealDataSize (Matrix<T, General, ArrayRowComplexSparse>) | returns the number of elements effectively stored for the real part |
| GetRealInd (Matrix<T, General, ArrayRowComplexSparse>) | returns a pointer to the array containing the column indexes of the real part |
| GetRealIndSize (Matrix<T, General, RowComplexSparse>) | returns size of array Ind of real part |
| GetRealNonZeros (Matrix<T, General, ArrayRowComplexSparse>) | returns the number of elements effectively stored for the real part |
| GetRealPtr (Matrix<T, General, RowComplexSparse>) | returns a pointer to the array containing row numbers of real part |
| GetRealPtrSize (Matrix<T, General, RowComplexSparse>) | returns size of array Ptr of real part |
| GetRealRowSize / GetRealColumnSize (Matrix<T, General, ArrayRowComplexSparse>) | returns the number of elements in the row of real part |
| GetRestart (Iteration) | returns restart parameter |
| GetRestartNleigs (SlepcParamNep) | returns the restart parameter for Nleigs |
| GetRestartNumber (SlepcParam) | Returns the restart number |
| GetRestartNumberAdd (SlepcParam) | Returns the incremental restart number |
| GetRestartRatio (SlepcParam) | Returns the restart ratio |
| GetReverseCommunicationFlag (ArpackSolver) | returns reverse-communication flag (ido parameter) |
| GetRKShifts (SlepcParamNep) | returns the shifts to use in Nleigs |
| GetRow | extracts a matrix row |
| GetRow | extracts a row of a distributed matrix |
| GetRowPermutation(MatrixSuperLU) | returns the permutation used for the rows |
| GetRowSize / GetColumnSize (Matrix<T, General, ArrayRowSparse>) | returns the number of elements in the row |
| GetRowColSum | sums absolute values of non-zero entries by row and by column |
| GetRowColSum | computes the sum of absolute value for each column and row of distributed matrices |
| GetRowSum | computes the sum of absolute values for each row (distributed matrices) |
| GetRowSum | sums absolute values of non-zero entries by row |
| GetSecondWorkVector (ArpackSolver) | returns pointer to second working vector |
| GetScalingFactors | computes row and column scalings to equilibrate a matrix |
| GetSchurComplement (SparseDistributedSolver) | Computes the Schur complement |
| GetSchurMatrix(MatrixMumps) | forms Schur complement |
| GetSchurMatrix | forms Schur complement |
| GetShape (Vector2) | returns the number of elements contained in an inner vector |
| GetShape (Vector3) | returns the number of vectors contained in an inner vector |
| GetSharingRowNumbers (DistributedMatrix) | returns the list of rows shared with each processor |
| GetShiftType (SlepcParam) | Returns the type of shift to use |
| GetShiftValue (GeneralEigenProblem) | Returns the shift |
| GetSize (Vector) | returns the number of elements in the vector |
| GetSize (Vector<T, VectSparse>) | returns the number of elements in the vector |
| GetSize (VirtualMatrix) | returns the number of elements in the matrix |
| GetSize (Array3D<T>) | returns the number of elements in the 3-D array |
| GetSize (Array4D<T>) | returns the number of elements in the 4-D array |
| GetSize (Array<T, N>) | returns the number of elements in the multidimensional array |
| GetSize (Vector2) | returns the size of inner vector or outer vectors |
| GetSize (Vector3) | returns the size of inner vector or outer vectors |
| GetSlepcParameters (EigenProblem_Base) | Returns the class storing parameters specific to SLEPc |
| GetSlepcParameters (PolynomialEigenProblem_Base) | returns the parameters of PEP solver |
| GetSqrtDiagonal (EigenProblem_Base) | Retrieves the square root of diagonal mass matrix |
| GetStoppingCriterion (GeneralEigenProblem) | Returns the stopping criterion used by iterative process |
| GetSubMatrix | extracts a sub-matrix from a given distributed matrix |
| GetSVD | performs singular value decomposition (SVD) |
| GetSymmetricPattern | computes the sparsity pattern of A + A' |
| GetThresholdMatrix (SparseDirectSolver) | Returns the threshold used to drop values in ILUT |
| GetThresholdRank (SlepcParam) | Returns the rank threshold |
| GetThresholdSpurious (SlepcParam) | Returns the spurious threshold |
| GetTypeIntegration (FeastParam) | returns the integration rule used in Feast |
| GetTypeOrdering (SparseDirectSolver) | Returns the ordering to use when the matrix will be reordered |
| GetTypeSorting (GeneralEigenProblem) | Returns how eigenvalues are sorted |
| GetTypeSpectrum (GeneralEigenProblem) | Returns the type of spectrum wanted by the user |
| GetTolerance (Iteration) | returns stopping criterion |
| GetUpperBoundInterval (FeastParam) | Returns the upper bound for the interval where eigenvalues are searched (Feast) |
| GetUpperTriangular | extracts upper triangular part of a matrix |
| GetVector (Vector2) | returns outer or inner vectors as reference |
| GetVector (Vector3) | returns outer or inner vectors as reference |
| Gmres | Generalized Minimum RESidual |
| HasElement | returns true if the vector contains a given value |
| HasSameShape (Vector2) | returns true if all inner vectors have the same size |
| HideMessages (SparseDirectSolver) | Hides all messages of the direct solver |
| HideMessages(Iteration) | displays nothing |
| IncrementLinearSolves (GeneralEigenProblem) | increments the number of linear solves |
| IncrementProdMatVect (GeneralEigenProblem) | Increments the number of matrix-vector products performed by the eigensolver |
| Index (Vector<T, VectSparse>) | access to row number |
| Index (Matrix<T, General, ArrayRowSparse>) | direct access to a column number |
| IndexGlobalCol (DistributedMatrix) | returns the global column number of distant non-zero entry j of local row i |
| IndexGlobalRow (DistributedMatrix) | returns the global row number of distant non-zero entry j of local column i |
| IndexImag (Matrix<T, General, ArrayRowComplexSparse>) | direct access to a column number of imaginary part |
| IndexReal (Matrix<T, General, ArrayRowComplexSparse>) | direct access to a column number of real part |
| Init (Iteration) | provides right hand side |
| Init (GeneralEigenProblem) | Initializes the local number of rows of the eigensolver |
| Init (ArpackSolver) | Initialization of eigenvalue problem |
| Init (DistributedMatrix) | sets pointers to the arrays containing global row numbers and overlapped rows |
| InitMatrix (EigenProblem_Base) | Stiffness matrix (and optionally mass matrix) is given |
| InitMatrix (PolynomialEigenProblem_Base) | Matrices defining the eigenproblem are given |
| InitMatrix (SplitSparseNonLinearEigenProblem) | provides the matrices Ai, numerators Pi and denominators Qi |
| InitSeldon | initializes Seldon (at the beginning of the program) |
| InitSymmetricPreconditioning(SorPreconditioner) | Symmetric SOR will be used |
| InitUnSymmetricPreconditioning (SorPreconditioner) | SOR will be used |
| InsideRegion (SlepcParamNep) | returns true if the eigenvalue belongs to the provided region |
| IsAvailableSolver(SparseDirectSolver) | Returns true if the given solver is available |
| IsComplex (VirtualMatrix) | returns true if the matrix is complex |
| IsComplexMatrix | returns true if the matrix is complex |
| IsEmpty (Vector2) | returns true if all inner vectors have 0-length |
| IsHermitianProblem (GeneralEigenProblem) | Returns true if the eigenproblem is hermitian |
| IsSymmetric (VirtualMatrix) | returns true if the matrix is symmetric |
| IsSymmetricMatrix | returns true if the matrix is symmetric |
| IsSymmetricProblem (GeneralEigenProblem) | Returns true if the involved matrices defining the eigenproblem are symmetric |
| IsInitGuess_Null (Iteration) | returns true if the initial guess is zero |
| IsReadyForMltAdd (DistributedMatrix) | returns true if the structure is ready to perform a matrix vector without preparation |
| IsSymmetricProblem (eigenvalue solver) | Returns true if the stiffness matrix is symmetric |
| LockingVariant (SlepcParamNep) | returns true if a locking-variant is used in nep solver |
| Lsqr | Least SQuaRes |
| MaxAbs | returns highest absolute value of A |
| MaxAbs | returns the maximum absolute value of entries in the distributed matrix |
| MergeSort | sorts a vector with merge sort algorithm |
| MinRes | Minimum RESidual |
| Mlt(MatrixCholmod) | Computes L x or LT where L is a Cholmod factor |
| Mlt (DistributedCholeskySolver) | computation of y = LT x or y = L x for Cholesky solver |
| Mlt (SparseCholeskySolver) | computation of y = LT x or y = L x for Cholesky solver |
| Mlt(MatrixPastix) | computes y = L x or y = LT x |
| Mlt | multiplication by a scalar or matrix-vector product |
| Mlt | performs a matrix-vector product for distributed matrices |
| MltAdd | performs a matrix-vector or matrix-matrix product |
| MltAdd | performs a matrix-vector product for distributed matrices |
| MltAddVector (VirtualMatrix) | performs a matrix-vector product |
| MltCholesky | performs matrix vector product by using Cholesky factorization |
| MltCholesky | computes y = L x or y = LT x once GetCholesky has been called |
| MltCholeskyMass (EigenProblem_Base) | Multiplication by L or LT |
| MltInvSqrtDiagonalMass (EigenProblem_Base) | Multiplication by M-1/2 |
| MltMass (EigenProblem_Base) | Multiplication by mass matrix M |
| MltOperator (PolynomialEigenProblem_Base) | applies the computed operator to a given vector |
| MltQ_FromQR | multiplies vector by Q |
| MltQ_FromLQ | multiplies vector by Q |
| MltSqrtDiagonalMass (EigenProblem_Base) | Multiplication by M1/2 |
| MltStiffness (EigenProblem_Base) | Multiplication by stiffness matrix K |
| MltVector (VirtualMatrix) | performs a matrix-vector product |
| Norm1 | returns 1-norm of a vector |
| Norm1 | returns 1-norm of A |
| Norm1 | returns the 1-norm of the distributed matrix |
| Norm2 | returns 2-norm of a vector |
| Norm2 | returns the euclidian norm of a distributed vector |
| NormInf | returns infinity-norm of A |
| NormInf | returns the infinite norm of the distributed matrix |
| NormFro | returns the Froebenius norm of the distributed matrix |
| Nullify (Vector) | clears the vector without releasing memory |
| Nullify (Vector<T, VectSparse>) | clears the vector without releasing memory |
| Nullify (Matrix<T>) | clears the matrix without releasing memory |
| Nullify (Matrix<T, General, ArrayRowSparse>) | removes elements of the matrix without releasing memory |
| Nullify (Matrix<T, General, RowSparse>) | clears the matrix without releasing memory |
| Nullify (Array3D<T>) | clears the 3-D array without releasing memory |
| Nullify (DistributedMatrixIntegerArray) | nullifies stored arrays |
| NullifyImag (Matrix<T, General, ArrayRowComplexSparse>) | removes imaginary part of the matrix without releasing memory |
| NullifyReal (Matrix<T, General, ArrayRowComplexSparse>) | removes real part of the matrix without releasing memory |
| PerformAnalysis(MatrixMumps, SparseDirectSolver) | Performs an analysis of linear system to factorize |
| PerformAnalysis (SparseDistributedSolver) | Performs the symbolic factorization of a matrix (distributed or not) |
| PerformAnalysisDistributed (SparseDirectSolver) | Performs the analysis of a distributed matrix (parallel execution) |
| PerformFactorization(MatrixMumps, SparseDirectSolver) | Performs a factorization of linear system, assuming that PerformAnalysis has been called |
| PerformFactorization (SparseDistributedSolver) | Performs the numerical factorization of a matrix (distributed or not) |
| PerformFactorizationDistributed (SparseDirectSolver) | Performs the factorization of a distributed matrix (parallel execution), assuming that PerformAnalysisDistributed has been called |
| Print (Vector) | displays the vector |
| Print (Vector<T, VectSparse>) | displays the vector |
| Print (Matrix<T>) | displays the matrix |
| Print (Matrix<T, General, ArrayRowSparse>) | displays the matrix |
| Print (Array3D<T>) | displays the 3-D array |
| Print (Array4D<T>) | displays the 4-D array |
| Print (Array<T, N>) | displays the N-D array |
| Print (Vector2) | displays the object |
| Print (Vector3) | displays the object |
| PrintErrorInit (EigenProblem_Base) | Prints an error message if InitMatrix has not been called |
| PrintImagRow / PrintImagColumn (Matrix<T, General, ArrayRowComplexSparse>) | prints a row of imaginary part |
| PrintRealRow / PrintRealColumn (Matrix<T, General, ArrayRowComplexSparse>) | prints a row of real part |
| PrintRow / PrintColumn (Matrix<T, General, ArrayRowSparse>) | prints a row |
| ProcessorDistantCol (DistributedMatrix) | returns the processor number of distant non-zero entry j of local row i |
| ProcessorDistantRow (DistributedMatrix) | returns the processor number of distant non-zero entry j of local column i |
| PushBack (Vector) | adds an element to the end of the vector |
| PushBack (Vector2) | appends outer or inner vectors at the end |
| PushBack (Vector3) | appends outer or inner vectors at the end |
| QCgs | Quasi Conjugate Gradient Squared |
| Qmr | Quasi Minimum Residual |
| QmrSym | Quasi Minimum Residual SYMmetric |
| QuickSort | sorts a vector with quick sort algorithm |
| Rank1Update | Adds a contribution X.Y' to a matrix |
| Rank2Update | Adds a contribution X.Y' + Y.X' to a symmetric matrix |
| Read (Vector) | reads the vector in binary format |
| Read (Vector<T, VectSparse>) | reads the vector in binary format |
| Read (Matrix<T>) | reads the matrix in binary format |
| Read (Matrix<T, General, ArrayRowSparse>) | reads the matrix in binary format |
| Read (Array3D<T>) | reads the 3-D array in binary format |
| Read (Array4D<T>) | reads the 4-D array in binary format |
| Read (Array<T, N>) | reads the N-D array in binary format |
| Read (DistributedMatrix) | reads the distributed matrix on several files (one per processor) in binary format |
| Read (Vector3) | reads the object from an output stream |
| ReadCoordinateMatrix | reads a matrix in coordinate format (as in Matlab) |
| ReadCoordinateMatrix | reads a matrix in coordinate format (as in Matlab) |
| ReadHarwellBoeing | reads a matrix in Harwell-Boeing format |
| ReadMatrixMarket | reads a matrix in Matrix Market format |
| ReadText (Vector) | reads the vector in text format |
| ReadText (Vector<T, VectSparse>) | reads the vector in text format |
| ReadText (Matrix<T>) | reads the matrix in text format |
| ReadText (Matrix<T, General, ArrayRowSparse>) | reads the matrix in text format |
| ReadText (DistributedMatrix) | reads the distributed matrix on several files (one per processor) in ascii format |
| Reallocate (Vector) | changes the size of vector (removes previous elements) |
| Reallocate (Vector<T, VectSparse>) | changes the size of vector (removes previous elements) |
| Reallocate (VirtualMatrix) | changes the size of matrix (does not keep previous elements) |
| Reallocate (Matrix<T, General, ArrayRowSparse>) | changes the size of matrix (does not keep previous elements) |
| Reallocate (Array3D<T>) | changes the size of 3-D array (does not keep previous elements) |
| Reallocate (Array4D<T>) | changes the size of 4-D array (does not keep previous elements) |
| Reallocate (Array<T, N>) | changes the size of N-D array (does not keep previous elements) |
| Reallocate (Vector2) | modifies the size of outer vectors or inner vectors |
| Reallocate (Vector3) | modifies the size of outer vectors or inner vectors |
| Reallocate (DistributedMatrix) | changes the size of the matrix |
| ReallocateImagRow / ReallocateImagColumn (Matrix<T, General, ArrayRowComplexSparse>) | changes the size of a row of the imaginary part |
| ReallocateRealRow / ReallocateRealColumn (Matrix<T, General, ArrayRowComplexSparse>) | changes the size of a row of the real part |
| ReallocateRow / ReallocateColumn (Matrix<T, General, ArrayRowSparse>) | changes the size of a row |
| realpart | returns the real part of a number |
| ReciprocalConditionNumber | computes the inverse of matrix condition number |
| RefineSolution(SparseDirectSolver) | Refines the solution when calling solve |
| RefineSolutionLU | improves solution computed by SolveLU |
| RemoveDuplicate | sorts and removes duplicate elements of a vector |
| RemoveSmallEntry (Vector<T, VectSparse>) | drops small entries of the vector |
| RemoveSmallEntry (Matrix<T, General, ArrayRowSparse>) | drops small entries of the matrix |
| RemoveSmallEntry (DistributedMatrix) | drops small non-zero entries present in the matrix |
| ReplaceImagIndexRow / ReplaceImagIndexColumn (Matrix<T, General, ArrayRowComplexSparse>) | changes column numbers of imaginary part |
| ReplaceIndexRow / ReplaceIndexColumn (Matrix<T, General, ArrayRowSparse>) | changes column numbers |
| ReplaceRealIndexRow / ReplaceRealIndexColumn (Matrix<T, General, ArrayRowComplexSparse>) | changes column numbers of real part |
| Resize (Vector) | changes the size of vector (keeps previous elements) |
| Resize (Vector<T, VectSparse>) | changes the size of vector (keeps previous elements) |
| Resize (Matrix<T>) | changes the size of matrix (keeps previous elements) |
| Resize (Matrix<T, General, ArrayRowSparse>) | changes the size of matrix (keeps previous elements) |
| Resize (DistributedMatrix) | changes the size of the matrix and keeps previous entries |
| ResizeImagRow / ResizeImagColumn (Matrix<T, General, ArrayRowComplexSparse>) | changes the size of a row of imaginary part and keeps previous values |
| ResizeRealRow / ResizeRealColumn (Matrix<T, General, ArrayRowComplexSparse>) | changes the size of a row of real part and keeps previous values |
| ResizeRow / ResizeColumn (Matrix<T, General, ArrayRowSparse>) | changes the size of a row and keeps previous values |
| SaveFullHistory(Iteration) | saves the history of residuals in a file |
| ScaleMatrix | scales rows and columns of the distributed matrix |
| ScaleLeftMatrix | multiplies rows of a matrix by coefficients |
| ScaleLeftMatrix | scales rows of the distributed matrix |
| ScaleMatrix | multiplies rows and columns of a matrix by coefficients |
| ScaleRightMatrix | multiplies columns of a matrix by coefficients |
| ScaleRightMatrix | scales columns of the distributed matrix |
| ScatterSparseEntry | fills a dense vector with a sparse one |
| Select (Vector2) | keeps a subset of inner vectors |
| SelectDirectSolver (SparseDirectSolver) | Sets the direct solver to use (e.g. Mumps, Pastix, SuperLU) |
| SelectDirectSolver (SparseCholeskySolver) | Sets the direct solver to use (e.g. Cholmod, Pastix) |
| SelectOrdering (SparseDirectSolver) | Sets the ordering to use when the matrix will be reordered |
| SelectParallelOrdering(VirtualSparseDirectSolver) | Sets the ordering to use during distributed factorization |
| Set (Matrix<T>) | modifies value of A(i, j) |
| SetEntry (VirtualMatrix) | modifies value of A(i, j) |
| Set (Matrix<T, General, ArrayRowSparse>) | modifies value of A(i, j) |
| SetAdditionalFillNumber (ilut preconditioning) | sets the number of additional elements per row (used for ILUT(k)) |
| SetArpackVerbose (ArpackSolver) | switches to verbose mode |
| SetBlockSize (SlepcParam) | Sets the block size |
| SetBorthogonalization (SlepcParam) | Selects the orthogonalization used in GD/JD solver |
| SetCircleSpectrum (FeastParam) | Sets the circle where eigenvalues are searched |
| SetCholeskyFacto(MatrixPastix) | selects a Cholesky factorisation to be performed |
| SetCholeskyFactoForMass (EigenProblem_Base) | Tells to find eigenvalues of L-1 K L-T if M = L LT |
| SetCoefficientEstimationNeededMemory(SparseDirectSolver) | Sets the safety coefficient used to allocate needed memory the first time |
| SetCol | changes a matrix column |
| SetCol | sets a column of a distributed matrix |
| SetCommunicator (DistributedVector) | sets the communicator associated with the distributed vector |
| SetCommunicator (GeneralEigenProblem) | Sets the MPI communicator associated with the eigenvalue problem |
| SetComplexOne | sets a complex number to one |
| SetComplexReal | sets a complex number to a given value |
| SetComplexZero | sets a complex number to zero |
| SetComputationalMode (EigenProblem_Base) | Sets the computational mode used (regular, shifted, ...) |
| SetData (Vector) | sets the pointer to the array contained in the vector |
| SetData (Vector<T, VectSparse>) | sets the pointer to the array contained in the vector |
| SetData (Matrix<T>) | sets the pointer to the array containing the values |
| SetData (Matrix<T, General, ArrayRowSparse>) | sets the pointer to the arrays containing values and column numbers |
| SetData (Matrix<T, General, RowSparse>) | sets the pointer to the array containing the values |
| SetData (Array3D<T>) | sets the pointer to the array containing the values |
| SetData (DistributedMatrixIntegerArray) | copies pointers to fill arrays |
| SetDefaultPetscSolver (SlepcParamNep) | allows the use of KSP solver in Petsc for the solution of linear systems |
| SetDiagonalCoefficient (IlutPreconditioning) | sets diagonal coefficient used in ILUD |
| SetDiagonalMass (EigenProblem_Base) | Tells to find eigenvalues of M-1/2 K M-1/2are searched (M diagonal) |
| SetDiagonalMass (PolynomialEigenProblem_Base) | sets a diagonal mass matrix |
| SetDoubleExpansion (SlepcParam) | Sets the double expansion flag used in GD/JD solver |
| SetDroppingThreshold (IlutPreconditioning) | sets threshold to determine elements to drop for ilut preconditioning |
| SetEigensolverType (AnasaziParam) | Sets the eigensolver to use in Anasazi |
| SetEigensolverType (SlepcParam) | Sets the eigensolver to use |
| SetEigensolverType (SlepcParamPep) | sets the eigensolver to use in PEP |
| SetEigensolverType (SlepcParamNep) | sets the eigensolver to use in NEP |
| SetEllipseSpectrum (FeastParam) | Sets the ellipse where eigenvalues are searched |
| SetExtractionType (SlepcParam) | Sets the type of extraction to use in CISS |
| SetFactorisationType(IlutPreconditioning) | sets the type of incomplete factorisation |
| SetFillLevel (IlutPreconditioning) | sets the fill-level k (if ILU(k) is set) |
| SetFullBasis (SlepcParamNep) | constructs a full basis in nep solver |
| SetGlobalCommunicator (GeneralEigenProblem) | Sets the global MPI communicator associated with the eigenvalue problem |
| SetIdentity (Matrix<T>) | sets matrix to identity matrix |
| SetIdentity (Matrix<T, General, ArrayRowSparse>) | sets matrix to identity matrix |
| SetIdentity (DistributedMatrix) | sets the matrix to the identity matrix |
| SetImagData (Matrix<T, General, ArrayRowComplexSparse>) | sets imaginary part of the matrix |
| SetImagShiftValue (GeneralEigenProblem) | Sets the imaginary part of the shift (real unsymmetric problem) |
| SetIncreaseCoefficientEstimationNeededMemory(SparseDirectSolver) | Sets the multiplication factor to increase the safety coefficient used to allocate needed memory |
| SetInfoFlag (ArpackSolver) | modifies info parameter |
| SetInitGuess (Iteration) | informs if the initial guess is zero or no |
| SetInitialSize (SlepcParam) | Sets the initial size used in GD/JD solver |
| SetInnerSteps (SlepcParam) | Sets the number of inner steps |
| SetInputPreconditioning (HyprePreconditioner) | Sets the preconditioning parameters in Hypre |
| SetInterpolationDegree (SlepcParamNep) | sets the polynomial degree to use for the interpolation |
| SetInterpolationTolerance (SlepcParamNep) | sets the threshold to use for the interpolation |
| SetIntervalRegion (SlepcParamNep) | sets the region where eigenvalues are sought |
| SetIntervalSpectrum (FeastParam) | Sets the interval where eigenvalues are searched (Feast) |
| SetKrylovRestart (SlepcParam) | Sets the Krylov start flag used in GD/JD solver |
| SetLevelEuclid(HyprePreconditioner) | Sets parameter k for Euclid solver in Hypre |
| SetLockingVariant (SlepcParamNep) | enables a locking-variant in nep solver |
| SetMaximumBlockSize (SlepcParam) | Sets the maximum block size |
| SetMaximumCoefficientEstimationNeededMemory(SparseDirectSolver) | Sets the maximal safety coefficient used to allocate needed memory |
| SetMaxIterationNumber (Iteration) | changes maximum number of iterations |
| SetMethod (SlepcParam) | Sets the method to use in PRIMME solver |
| SetMomentSize (SlepcParam) | Sets the moment size |
| SetNbAdditionalEigenvalues (EigenProblem_Base) | Sets the number of additional eigenvalues (workaround due to Arpack bug) |
| SetNbArnoldiVectors (GeneralEigenProblem) | Sets the number of Arnoldi vectors |
| SetNbAskedEigenvalues (GeneralEigenProblem) | Sets the number of wanted eigenvalues |
| SetNbBlocks (AnasaziParam) | Sets the number of blocks to use in Anasazi solvers |
| SetNbMaximumIterations (GeneralEigenProblem) | Sets the maximum number of iterations allowed for the iterative process |
| SetNbMaximumRestarts (AnasaziParam) | Sets the maximal number of restarts in Anasazi |
| SetNonLockingVariant (SlepcParam) | Sets the non-locking variant to use |
| SetNonSymmetricIlut (SparseDirectSolver) | Selects non-symmetric incomplete factorization |
| SetNumberConvergedVectors (SlepcParam) | Sets the number of converged vectors |
| SetNumberConvergedVectorsProjected (SlepcParam) | Sets the number of projected converged vectors |
| SetNumberIntegrationPoints (SlepcParam) | Sets the number of integration points to use |
| SetNumberIteration (Iteration) | changes iteration number |
| SetNumberIterations (SorPreconditioner) | changes the number of iterations for SOR preconditioning |
| SetNumberOfSteps (SlepcParam) | Sets the number of steps |
| SetNumberOfThreadPerNode (SparseDirectSolver) | Sets the number of threads per node (relevant for Pastix only) |
| SetNumberPartitions (SlepcParam) | Sets the number of partitions |
| SetNumOfQuadraturePoints <(FeastParam)/td> | sets the number of quadrature points used in the contour |
| SetOuterSteps (SlepcParam) | Sets the number of outer steps |
| SetOverlapRow (DistributedVector) | sets the row numbers already handled by another processor and MPI communicator |
| SetParameterRelaxation (SorPreconditioner) | changes the relaxation parameter of SOR preconditioning |
| SetPermutation (SparseDirectSolver) | Provides manually the permutation array used to reorder the matrix |
| SetPivotBlockInteger (ilut preconditioning) | sets the maximum k = |i-j| allowed when pivoting for ilut preconditioning |
| SetPivotThreshold (SparseDirectSolver, IlutPreconditioning) | Sets the threshold used for pivoting |
| SetPivotThreshold (ilut preconditioning) | sets threshold used when pivoting columns for ilut preconditioning |
| SetPreconditioner (HyprePreconditioner) | Sets preconditioning used in Hypre |
| SetPrintLevel (GeneralEigenProblem) | Sets the print level |
| SetPrintLevel (SparseDistributedSolver) | Modifies the level of verbosity |
| SetQuadratureRuleType (SlepcParam) | Sets the type of quadrature rules to use in CISS |
| SetRealData (Matrix<T, General, ArrayRowComplexSparse>) | sets real part of the matrix |
| SetRestart (Iteration) | changes restart parameter |
| SetRestartNleigs (SlepcParamNep) | sets the restart parameter for Nleigs |
| SetRestartNumber (SlepcParam) | Sets the restart number |
| SetRestartNumberAdd (SlepcParam) | Sets the incremental restart number |
| SetRestartRatio (SlepcParam) | Sets the restart ratio |
| SetReverseCommunicationFlag (ArpackSolver) | modifies reverse-communication flag (ido parameter) |
| SetRKShifts (SlepcParamNep) | sets the shifts to use in Nleigs |
| SetShiftType (SlepcParam) | Sets the type of shift to use |
| SetShiftValue (GeneralEigenProblem) | sets the shift |
| SetSmoother (HyprePreconditioner) | Sets smoothing used in Hypre |
| SetRow | changes a matrix row |
| SetRow | sets a row of a distributed matrix |
| SetSpectralTransformation (PolynomialEigenProblem_Base) | sets the use of a spectral transformation |
| SetStoppingCriterion (GeneralEigenProblem) | Sets the stopping criterion used by iterative process |
| SetSymmetricAlgorithm (IlutPreconditioning) | sets symmetric incomplete factorisation |
| SetThresholdMatrix (SparseDirectSolver) | Sets the threshold used to drop values in ILUT |
| SetThresholdRank (SlepcParam) | Sets the rank threshold |
| SetThresholdSpurious (SlepcParam) | Sets the spurious threshold |
| SetTolerance (Iteration) | changes stopping criterion |
| SetTypeIntegration (FeastParam) | sets the integration rule used in Feast |
| SetTypeSpectrum (GeneralEigenProblem) | Sets the of spectrum wanted by the user |
| SetSymmetricAlgorithm (IlutPreconditioning) | sets unsymmetric incomplete factorisation (even for symmetric matrices) |
| SetUserComparisonClass (GeneralEigenProblem) | Sets an ordering of eigenvalues defined by the user |
| ShowMessages (SparseDirectSolver) | Shows messages of the direct solver |
| ShowMessages (Iteration) | displays residual each 100 iterations |
| ShowFullHistory (SparseDirectSolver) | Shows all messages of the direct solver |
| ShowFullHistory (Iteration) | displays residual each iteration |
| ShowMessages(HyprePreconditioner) | Enables the display of statistics in Hypre |
| Solve | solves a triangular system |
| Solve (SparseDirectSolver) | Solves A x = b or AT x = b, assuming that Factorize has been called |
| Solve (SparseDistributedSolver) | Solves a linear system assuming that Factorize has been called |
| Solve (DistributedCholeskySolver) | Solves L x = b or LT x = b assuming that Factorize has been called |
| Solve(MatrixMumps) | Solves A x = b using factorization computed by Mumps |
| Solve(MatrixPardiso) | Solves A x = b using factorization computed by Pardiso |
| Solve(MatrixPastix) | Solves A x = b using factorization computed by Pastix |
| Solve(SparseSeldonSolver) | Solves A x = b using factorization computed by Seldon |
| Solve(MatrixSuperLU) | Solves A x = b using factorization computed by SuperLU |
| Solve(MatrixUmfPack) | Solves A x = b using factorization computed by UmfPack |
| Solve(MatrixWsmp) | Solves A x = b using factorization computed by Wsmp |
| Solve(MatrixCholmod) | Solves A x = b using Cholesky factorization computed by Cholmod |
| Solve (SparseCholeskySolver) | Solves L x = b or LT x = b, assuming that Factorize has been called |
| Solve (Preconditioner_Base) | Applies the preconditioner |
| Solve(SorPreconditioner) | Applies SOR preconditioning |
| Solve(IlutPreconditioning) | Applies ilut preconditioning |
| Solve (HyprePreconditioner) | applies the preconditioning by calling Hypre |
| SolveCholesky | solves linear system by using Cholesky factorization |
| SolveCholesky | solves L x = b or LT x = b once GetCholesky has been called |
| SolveCholeskyMass (EigenProblem_Base) | Resolution of L x = b or LT x = b |
| SolveDistributed (SparseDirectSolver) | Solves A x = b or AT x = b, assuming that FactorizeDistributed has been called |
| SolveHessenberg | resolution of H X = Y with H an Hessenberg matrix |
| SolveHessenbergTwo | resolution of H X = Y with H a matrix with two sub-diagonals non-null |
| SolveLQ | solves least-square problems by using LQ factorization |
| SolveLU | solve linear system by using LU factorization |
| SolveLU | uses LU factorization to solve a linear system |
| SolveMass (PolynomialEigenProblem_Base) | solves the mass matrix |
| SolveOperator (PolynomialEigenProblem_Base) | solves a linear combination of matrices Ai |
| SolveQR | solves least-square problems by using QR factorization |
| SolveSylvester | resolution of Sylvester equation A X B* + C X D* = E |
| SOR | applies successive over-relaxations to matrix |
| SOR | Applies Successive Over Relaxation (S.O.R) iterations to solve a distributed linear system |
| Sort | sorts a vector |
| SortEigenvalues | sorts eigenvalues and associated eigenvectors |
| Swap | exchanges two vectors |
| SwapImagRow / SwapImagColumn (Matrix<T, General, ArrayRowComplexSparse>) | exchanges two rows of imaginary part |
| SwapPointer | exchanges two vectors (only adresses are exchanged) |
| SwapRealRow / SwapRealColumn (Matrix<T, General, ArrayRowComplexSparse>) | exchanges two rows of real part |
| SwapRow / SwapColumn (Matrix<T, General, ArrayRowSparse>) | exchanges two rows |
| Symmlq | SYMMetric Least sQuares |
| TfQmr | Transpose Free Quasi Minimum Residual |
| to_complex_eigen | Converts a real/complex number into another one |
| to_num | converts a string into a number |
| to_str | converts a number into a string |
| Transpose | replaces a matrix by its transpose |
| Transpose | computes the transpose of a distributed matrix |
| TransposeConj | replaces a matrix by its conjugate transpose |
| TransposeConj | computes the transpose conjugate of a distributed matrix |
| TransSolve (SparseDistributedSolver) | Solves a transpose linear system assuming that Factorize has been called |
| TransSolve (Preconditioner_Base) | Applies the transpose of the preconditioner |
| TransSolve(SorPreconditioner) | Applies transpose of SOR preconditioning |
| TransSolveIlutPreconditioning) | Applies the transpose of ilut preconditioning |
| TransSolve (HyprePreconditioner) | applies the transpose preconditioning by calling Hypre |
| UseCholeskyFactoForMass (EigenProblem_Base) | Returns true if eigenvalues of L-1 K L-Tare searched (M = L LT) |
| UseCommandLineOptions (SlepcParamNep) | returns true if the user is allowed to provide parameters of the solver through the command line |
| UseDefaultPetscSolver (SlepcParamNep) | returns true if the KSP solver in Petsc is used for the solution of linear systems |
| UseInteger8 (VirtualSparseDirectSolver) | returns true if the solver is using 64-bits integers (integer*8 in Fortran) |
| UseNonLockingVariant (SlepcParam) | Returns true if the non-locking variant is used |
| UseSpectralTransformation (PolynomialEigenProblem_Base) | returns true if a spectral transformation is used |
| Val (Vector<T, VectSparse>) | access to V(i) |
| Val (Matrix<T>) | access to a matrix element |
| Val (Matrix<T, General, ArrayRowSparse>) | access to a matrix element |
| ValImag (Matrix<T, General, ArrayRowComplexSparse>) | returns a reference to imaginary part of A(i, j) |
| ValReal (Matrix<T, General, ArrayRowComplexSparse>) | returns a reference to real part of A(i, j) |
| Value (Vector<T, VectSparse>) | access to value |
| Value (Matrix<T, General, ArrayRowSparse>) | direct access to a value |
| ValueDistantCol (DistributedMatrix) | returns the value associated with distant non-zero entry j of local row i |
| ValueDistantRow (DistributedMatrix) | returns the value associated with distant non-zero entry j of local column i |
| ValueImag (Matrix<T, General, ArrayRowComplexSparse>) | direct access to an imaginary value |
| ValueReal (Matrix<T, General, ArrayRowComplexSparse>) | direct access to a real value |
| Write (Vector) | writes the vector in binary format |
| Write (Vector<T, VectSparse>) | writes the vector in binary format |
| Write (Matrix<T>) | writes the matrix in binary format |
| Write (Matrix<T, General, ArrayRowSparse>) | writes the matrix in binary format |
| Write (Array3D<T>) | writes the 3-D array in binary format |
| Write (Array4D<T>) | writes the 4-D array in binary format |
| Write (Array<T, N>) | writes the N-D array in binary format |
| Write (DistributedMatrix) | writes the distributed matrix on several files (one per processor) in binary format |
| Write (Vector3) | writes the object in an output stream |
| WriteCoordinateMatrix | writes a matrix in coordinate format (as in Matlab) |
| WriteHarwellBoeing | writes a matrix in Harwell-Boeing format |
| WriteMatrixMarket | writes a matrix in Matrix Market format |
| WriteText (Vector) | writes the vector in text format |
| WriteText (Vector<T, VectSparse>) | writes the vector in text format |
| WriteText (Matrix<T>) | writes the matrix in text format |
| WriteText (Matrix<T, General, ArrayRowSparse>) | writes the matrix in text format |
| WriteText (DistributedMatrix) | writes the distributed matrix on several files (one per processor) in ascii format |
| Zero (Vector) | sets all elements to zero |
| Zero (Vector<T, VectSparse>) | sets all elements to zero |
| Zero (VirtualMatrix) | sets all elements to zero |
| Zero (Matrix<T, General, ArrayRowSparse>) | sets all elements to zero |
| Zero (Array3D<T>) | sets all elements to zero |
| Zero (Array4D<T>) | sets all elements to zero |
| Zero (Array<T, N>) | sets all elements to zero |
| AnasaziParam | Class storing parameters for Anasazi interface |
| ArpackSolver | Basic reverse communication class for interfacing Arpack |
| Array<T, N> | Multi-dimensional array |
| Array3D<T> | three-dimensional array |
| Array4D<T> | four-dimensional array |
| CallocAlloc<T> | Allocator using calloc/free |
| class_SeldonConjTrans | Class for variable SeldonConjTrans |
| class_SeldonLeft | Class for variable SeldonLeft |
| class_SeldonNonUnit | Class for variable SeldonNonUnit |
| class_SeldonNoTrans | Class for variable SeldonNoTrans |
| class_SeldonRight | Class for variable SeldonRight |
| class_SeldonTrans | Class for variable SeldonTrans |
| class_SeldonUnit | Class for variable SeldonUnit |
| ClassComplexType | retrieves real or complex number from a given type |
| DenseEigenProblem | Class for dense eigenvalue problems |
| DistributedCholeskySolver | Class handling distributed Cholesky solvers |
| DistributedMatrix<T, Prop, Storage> | Class for distributed matrices |
| DistributedMatrixIntegerArray | Class storing arrays needed for distributed matrices |
| DistributedVector<T, VectFull> | Distributed vectors |
| EigenProblem_Base | Base class for linear eigenproblem |
| EigenvalueComparisonClass | Class for a used-defined sorting of eigenvalues |
| FeastParam | Class storing parameters for FEAST interface |
| GeneralEigenProblem_Base | Base class for an eigenvalue problem |
| GeneralEigenProblem | Base class for an eigenvalue problem |
| EigenProblem_Base | Base class for a linear eigenvalue problem |
| Error | Base class for any Seldon exception |
| General | Class to specify a general matrix (without particular property) |
| Hermitian | Class to specify an hermitian matrix |
| HyprePreconditioner | Hypre preconditioning |
| IlutPreconditioning | Ilut preconditioning |
| IOError | Seldon exception thrown for input/output errors |
| Iteration | Class defining stopping criteria for iterative solvers |
| LapackError | Seldon exception when Lapack encounters an error |
| LapackInfo | Lapack error code |
| MallocAlloc<T> | Allocator using malloc/free |
| MallocObject<T> | Allocator using malloc/free and dealing with objects |
| Matrix_Base<T, Allocator> | Base class for any matrix (dense or sparse) |
| Matrix<T, General, ArrayColSparse> | Easily modifiable sparse matrix stored by columns |
| Matrix<T, General, ArrayColComplexSparse> | Easily modifiable complex sparse matrix stored by columns |
| Matrix<T, General, ArrayRowSparse> | Easily modifiable sparse matrix stored by rows |
| Matrix<T, General, ArrayRowComplexSparse> | |
| Matrix<T, General, ColLoTriang> | Lower triangular dense matrix stored by columns |
| Matrix<T, General, ColLoTriangPacked> | Lower triangular dense matrix stored by columns (compressed) |
| Matrix<T, General, ColMajor> | Dense matrix stored by columns |
| Matrix<T, General, ColSparse> | Sparse matrix stored by columns |
| Matrix<T, General, ColComplexSparse> | Sparse complex matrix stored by columns |
| Matrix<T, General, ColUpTriang> | Upper triangular dense matrix stored by columns |
| Matrix<T, General, ColUpTriangPacked> | Upper triangular dense matrix stored by columns (compressed) |
| Matrix<T, General, RowLoTriang> | Lower triangular dense matrix stored by rows |
| Matrix<T, General, RowLoTriangPacked> | Lower triangular dense matrix stored by rows (compressed) |
| Matrix<T, General, RowMajor> | Dense matrix stored by rows |
| Matrix<T, General, RowSparse> | Sparse matrix stored by rows |
| Matrix<T, General, RowComplexSparse> | Sparse complex matrix stored by rows |
| Matrix<T, General, RowUpTriang> | Upper triangular dense matrix stored by rows |
| Matrix<T, General, RowUpTriangPacked> | Upper triangular dense matrix stored by rows (compressed) |
| Matrix<T, Hermitian, ColHerm> | Hermitian dense matrix stored by columns |
| Matrix<T, Hermitian, ColHermPacked> | Hermitian dense matrix stored by columns (compressed) |
| Matrix<T, Hermitian, RowHerm> | Hermitian dense matrix stored by rows |
| Matrix<T, Hermitian, RowHermPacked> | Hermitian dense matrix stored by rows (compressed) |
| Matrix<T, Symmetric, ArrayColSymSparse> | Easily modifiable symmetric sparse matrix stored by columns |
| Matrix<T, Symmetric, ArrayColSymComplexSparse> | Easily modifiable symmetric complex sparse matrix stored by columns |
| Matrix<T, Symmetric, ArrayRowSymSparse> | Easily modifiable symmetric sparse matrix stored by rows |
| Matrix<T, Symmetric, ArrayRowSymComplexSparse> | Easily modifiable symmetric complex sparse matrix stored by rows |
| Matrix<T, Symmetric, ColSym> | Symmetric dense matrix stored by columns |
| Matrix<T, Symmetric, ColSymPacked> | Symmetric dense matrix stored by columns (compressed) |
| Matrix<T, Symmetric, ColSymSparse> | Symmetric sparse matrix stored by columns |
| Matrix<T, Symmetric, RowSym> | Symmetric dense matrix stored by rows |
| Matrix<T, Symmetric, RowSymPacked> | Symmetric dense matrix stored by rows (compressed) |
| Matrix<T, Symmetric, RowSymSparse> | Symmetric sparse matrix stored by rows |
| MatrixCholmod | Object storing Cholesky factorization (interface with Cholmod) |
| MatrixMumps | Object storing LU factorization (interface with Mumps) |
| MatrixPardiso | Object storing LU factorization (interface with Pardiso) |
| MatrixPastix | Object storing LU factorization (interface with Pastix) |
| MatrixSuperLU | Object storing LU factorization (interface with SuperLU) |
| MatrixUmfPack | Object storing LU factorization (interface with UmfPack) |
| MatrixWsmp | Object storing LU factorization (interface with Wsmp) |
| NaNAlloc<T> | Allocator using malloc/free by filling with nan |
| NewAlloc<T> | Allocator using new/delete |
| NoMemory | Seldon exception thrown when allocating an array too large |
| NonLinearEigenProblem_Base | Base class for non-linear eigenvalue problems |
| PolynomialDenseEigenProblem | Class for polynomial eigenvalue problems (with dense matrices) |
| PolynomialEigenProblem_Base | Base class for polynomial eigenvalue problems |
| PolynomialEigenProblem | Class for polynomial eigenvalue problems (matrix-free implementation) |
| PolynomialSparseEigenProblem | Class for polynomial eigenvalue problems (with sparse matrices) |
| Preconditioner_Base | Base class for any preconditioning |
| SeldonDefaultAllocator<Storage, T> | Default allocator to use for Matrix<T, Prop, Storage> |
| SeldonConjugate | Base class for SeldonConj and SeldonUnconj flags |
| SeldonDiag | Base class for Unit and NonUnit flags |
| SeldonSide | Base class for SeldonLeft and SeldonRight flags |
| SeldonNorm | Base class for Norm1 or NormInf |
| SeldonTranspose | Base class for transpose flags |
| SeldonUplo | Base class for upper/lower flags |
| SlepcParam | Class storing parameters for SLEPc interface |
| SlepcParamPep | Class storing parameters for SLEPc interface (PEP solver) |
| SlepcParamNep | Class storing parameters for SLEPc interface (NEP solver) |
| SolverMaximumIterationError | Error for maximal iterations reached for a solver |
| SolverDivergenceError | Error because of a divergent algorithm |
| SorPreconditioner | SOR preconditioning |
| SparseCholeskySolver | Class interfacing all Cholesky solvers |
| SparseDirectSolver | Class interfacing all direct solvers |
| SparseDistributedSolver | Class interfacing all direct solvers both in parallel and sequential |
| SparseEigenProblem | Class for sparse eigenvalue problems |
| SparseMatrixOrdering | Class enumerating sparse orderings |
| SparseSeldonSolver | Seldon direct solver (slow) |
| SplitSparseNonLinearEigenProblem | Class for sparse non-linear eigenvalue problems (split form) |
| Str | formats easily to a string |
| Symmetric | Class to specify a symmetric matric |
| TypeEigenvalueSolver | Class enumerating eigenvalue solvers |
| Undefined | Seldon exception for undefined function |
| Vector<T, VectFull> | Dense vectors |
| Vector<T, VectSparse> | Sparse vectors |
| Vector2<T> | Vector of vectors |
| Vector3<T> | Vector of vector of vectors |
| VectorExpression<T, E> | Expression of vectors |
| VirtualEigenProblem | Class for matrix-free eigenvalue problems |
| VirtualMatrix<T> | Base class for any matrix (dense or sparse) |
| VirtualSparseDirectSolver | Base class for each interface with a direct solver |
| WrongArgument | Seldon exception for a wrong argument |
| WrongCol | Seldon exception when accessing to an incorrect column |
| WrongDim | Seldon exception for incorrect dimensions |
| WrongIndex | Seldon exception when accessing to an index out of range |
| WrongRow | Seldon exception when accessing to an incorrect row |
| lapack_info | Default argument used to retrieve Lapack error code |
| SeldonConj | Argument used for selecting the conjugate |
| SeldonConjTrans | Argument used for selecting the conjugate transpose matrix |
| SeldonLeft | Argument used to multiply on the left |
| SeldonLower | Argument used to consider lower part of the matrix |
| SeldonNonUnit | Argument used to tell that the diagonal is non-unitary |
| SeldonNormInf | Argument used to consider the infinite norm |
| SeldonNorm1 | Argument used to consider the 1-norm |
| SeldonNoTrans | Argument used for selecting the non transpose matrix |
| SeldonRight | Argument used to multiply on the right |
| SeldonTrans | Argument used for selecting the transpose matrix |
| SeldonUnconj | Argument used for not selecting the conjugate |
| SeldonUnit | Argument used to tell that the diagonal is unitary |
| SeldonUpper | Argument used to consider upper part of the matrix |