|
MyraMath
|
Abstractions and algorithms for iterative solvers. [tutorial] .
More...Files | |
| file | Action.h [code] |
| Applies the "Action" of a linear operator, b := A*x, used in iterative solution algorithms. | |
| file | ActionBase.h [code] |
| Implementation detail, polymorphic base type contained/erased by Action. | |
| file | AllActions.h [code] |
| Blanket include for every Action type and all their composition functions (operator +,-,*, etc). | |
| file | bicgstab.h [code] |
| Linear system solution via bicgstab (for invertible action A) | |
| file | bothcat.h [code] |
| Routines to concatenate Action's in two-by-two fashion. | |
| file | ConcatenateAction.h [code] |
| An Action that concatenates other Action's, think horzcat() or vertcat(). | |
| file | diagcat.h [code] |
| Routines to concatenate Action's in diagonal fashion. | |
| file | DifferenceAction.h [code] |
| Composes two Action's A and B, yielding an Action that applies (A-B)*X. | |
| file | DimmAction.h [code] |
| An Action for multiplying by a DiagonalMatrix using dimm() | |
| file | fgmres.h [code] |
| Linear system solution via (flexible) fgmres (for invertible action A) | |
| file | GemmAction.h [code] |
| An Action for multiplying by a dense Matrix or SparseMatrix using gemm(). | |
| file | gmres.h [code] |
| Linear system solution via gmres (for invertible action A) | |
| file | HemmAction.h [code] |
| An Action for multiplying by a hermitian dense Matrix or SparseMatrix using hemm() | |
| file | horzcat.h [code] |
| Routines to concatenate Action's in left/right fashion. | |
| file | ICholeskySolver.h [code] |
| Incomplete Cholesky preconditioner. Presents a solve() function, but it's only approximate. | |
| file | IdentityAction.h [code] |
| An Action that is just the identity operator. | |
| file | ILUSolver.h [code] |
| Incomplete LU preconditioner. Presents a solve() function, but it's only approximate. | |
| file | lanczos1.h [code] |
| Finds one dominant eigenpair of a real symmetric Action. | |
| file | lanczosn.h [code] |
| Finds several dominant eigenpairs of a real symmetric Action. | |
| file | lopcg1.h [code] |
| Finds one small eigenpair of a real symmetric Action. | |
| file | lopcgn.h [code] |
| Finds several small eigenpairs of a real symmetric Action. | |
| file | LowerAction.h [code] |
| Routines for making double-precision Action's act like float-precision ones, accepting some loss of accuracy. Complementary to raise_precision() | |
| file | minres.h [code] |
| Linear system solution via minimum residual method (symmetric action A, can be indefinite) | |
| file | mixed_refine.h [code] |
| Like refine(), but uses a low-precision M to solve/refine a high-precision A. | |
| file | MrhsReshaper.h [code] |
| Implementation detail for iterative linear solvers that operate on multiple right hand sides (Mrhs). | |
| file | NegateAction.h [code] |
| Returns the negation of an Action A. | |
| file | pcg.h [code] |
| Linear system solution via conjugate gradients (symmetric positive definite action A) | |
| file | power.h [code] |
| Applies the power method to extract dominant eigenpair. | |
| file | ProductAction.h [code] |
| Composes two Action's A and B, yielding an Action that cascades A*(B*X) | |
| file | RaiseAction.h [code] |
| Routines for making float-precision Action's act like double-precision ones, accepting some loss of accuracy. Used in the context of backwards refinement or krylov solution that operates in mixed precision. (e.g. use a float- precision preconditioner to solve a double-precision forward operator) | |
| file | refine.h [code] |
| Generic algorithm for solving with backwards refinement, implemented in terms of Action's. | |
| file | RefineAction.h [code] |
| Adapts a class with a .refine() method into an Action. | |
| file | ReshapeAction.h [code] |
| Reshapes/clones an Action A into diag(A,A,A,..), used by "thick" iterative solvers to apply A to multiple contiguous column vectors. | |
| file | ScaleAction.h [code] |
| Scales an Action by a constant. | |
| file | SolveAction.h [code] |
| Adapts a class with a .solve() method into an Action. | |
| file | stationary.h [code] |
| Implementations of classical stationary iterations: jacobi(), seidel(), sor() and ssor() | |
| file | SumAction.h [code] |
| Composes two Action's A and B, yielding an Action that applies (A+B)*X. | |
| file | SymmAction.h [code] |
| An Action for multiplying by a symmetric dense Matrix. LowerMatrix or SparseMatrix using symm() | |
| file | TrmmAction.h [code] |
| An Action for multiplying by a triangular Matrix, LowerMatrix or SparseMatrix using trmm(). | |
| file | TrsmAction.h [code] |
| An Action for solving by a triangular Matrix, LowerMatrix or SparseMatrix using trsm(). | |
| file | UserAction.h [code] |
| Adapts user code (encapsulated in a class) into an Action. | |
| file | vertcat.h [code] |
| Routines to concatenate Action's in top/bottom fashion. | |
| file | ZeroAction.h [code] |
| An all-zero Action of specified size. | |
Abstractions and algorithms for iterative solvers. [tutorial] .
1.8.13