NSPCG
Nonsymmetric Preconditioned Conjugate Gradient
NSPCG
is a FORTRAN90 library which
carries out the iterative solution of large nonsymmetric systems of
linear equations. The package includes a
variety of matrix storage formats, preconditioners, and solvers.
Languages:
NSPCG is available in
a FORTRAN90 version.
Related Data and Programs:
CSPARSE
is a C library for direct methods of solving
sparse linear systems.
DLAP
is a FORTRAN90 library for solving sparse linear systems.
HB_IO
is a FORTRAN90 library which
reads and writes sparse linear systems stored in the Harwell-Boeing
Sparse Matrix Collection (HBSMC) format.
HB_TO_ST
is a FORTRAN77 program which
converts a sparse matrix from Harwell-Boeing to sparse triplet format.
LINPLUS
is a FORTRAN90 library which
carries out simple manipulations of matrices in a variety of formats.
MGMRES
is a FORTRAN90 library which
applies the restarted GMRES algorithm
to solve a sparse linear system.
MM_IO
is a FORTRAN90 library which
reads and writes sparse linear systems stored in the Matrix Market format.
SPARSE_CC
is a data directory which
contains a description and examples of the CC format,
("compressed column") for storing a sparse matrix,
including a way to write the matrix as a set of three files.
SPARSE_CR
is a data directory which
contains a description and examples of the CR format,
("compressed row") for storing a sparse matrix,
including a way to write the matrix as a set of three files.
SPARSEKIT
is a FORTRAN90 library which
implements operations on sparse matrices, including conversion
between various formats.
SPARSEPAK
is a FORTRAN90 library which
forms an obsolete version of the Waterloo Sparse Matrix Package.
Reference:
-
Thomas Oppe, Wayne Joubert, David Kincaid,
NSPCG User's Guide, Version 1.0,
A Package for Solving Large Sparse Linear Systems
by Various Iterative Methods,
CNA-216, April 1988
Source Code:
Examples and Tests:
NSPCG_test contains some simple example programs that call NSPCG:
NSPCG_test2 contains some complicated routines that
test all the features of NSPCG. These routines are NOT for
the beginner!:
List of Routines:
-
ADINFN computes an upper bound on the spectral radius of inverse(D)*A.
-
ADJUST makes adjustments to the JCOEF array.
-
AINFN calculates the infinity norm of a matrix.
-
BASIC is the user interface to the basic (unaccelerated) iterative method, with preconditioning.
-
BASICW runs the basic (unaccelerated) iterative method, with preconditioning.
-
BBS does a banded back substitution.
-
BBSM does a banded back solve.
-
BBST does a banded backward substitution.
-
BBSTM does the backward solve.
-
BCGS is the user interface to the biconjugate-gradient-squared algorithm.
-
BCGSW runs the biconjugate-gradient-squared algorithm.
-
BDFAC computes the factorization of a dense banded matrix.
-
BDINV computes the inverse of a dense banded matrix.
-
BDSOL computes the solution to a dense banded matrix.
-
BDSOLT computes the transpose solution to a nonsymmetric dense banded matrix.
-
BFAC computes a factorization to a single banded symmetric matrix.
-
BFACM computes factorizations to multiple banded symmetric matrices.
-
BFACMY computes a block factorization. (multicolor nonsymmetric diagonal)
-
BFACMZ computes a block factorization. (nonsymmetric diagonal)
-
BFACN computes a factorization to a single banded nonsymmetric matrix.
-
BFACNM computes a factorization to multiple banded nonsymmetric matrices.
-
BFACS computes a block factorization. (symmetric diagonal)
-
BFS does a forward substitution.
-
BFSM does the forward solve.
-
BFST does a banded forward substitution.
-
BFSTM does a forward solve.
-
BIC2 drives the block factorization (version 1) method.
-
BIC3 drives the block factorization (version 1) method.
-
BIC7 drives the block factorization (version 1) method. (multi-color ordering)
-
BICOLOR determines whether or not a matrix is bi-colorable.
-
BICX2 drives the block factorization (version 2) method.
-
BICX3 drives the block factorization (version 2) method.
-
BICX7 drives the block factorization (version 2) method (multi-color ordering)
-
BINV computes an approximate inverse to a single banded symmetric matrix.
-
BINVN computes an approximate inverse to a single banded nonsymmetric matrix.
-
BLKDEF defines various block constants for a constant block size matrix.
-
BMUL computes y = A*x, where A is a banded symmetric matrix.
-
BMULN computes y = A*x, where A is in nonsymmetric band format.
-
BMULNT computes y = (A**t)*x, where A is in nonsymmetric band format.
-
BSOL solves A*x = y for a banded and symmetric matrix A.
-
BSOLM solves the system A*x = y where A is multiple symmetric banded matrices
-
BSOLN solves A*x = y for a banded and nonsymmetric matrix.
-
BSOLNM solves A*x = y for a banded and nonsymmetric matrix.
-
BSOLNT solves (A**t)*x = y for a banded and nonsymmetric matrix.
-
BSONTM solves (A**t)*x = y for a banded and nonsymmetric matrix.
-
CG is the user interface to the conjugate gradient algorithm.
-
CGCR implements the constrained residual method.
-
CGCRPR is a right preconditioner routine to use with the CGCR method.
-
CGNR is the user interfact to the conjugate gradient algorithm on the normal equations.
-
CGNRW runs the conjugate gradient algorithm on the normal equations.
-
CGW drives the conjugate gradient algorithm.
-
CHGCON computes the new estimates for the largest and smallest eigenvalues.
-
CHGSI adapts on the iteration parameters.
-
CKCONV checks if the iterative method has stagnated or had other misfortunes.
-
COLOR expands a color pattern to a full grid color array.
-
COPY does a vector copy (null preconditioner).
-
DEFCON defines block constants for block-structured matrices.
-
DEFINE defines block constants for block-structured matrices.
-
DETERM computes the determinant of a symmetric tridiagonal matrix.
-
DETSYM determines if the matrix is symmetric.
-
DFAULT sets the default values of IPARM and RPARM.
-
ECHALL initializes the package common blocks.
-
EIGVSS computes a selected eigenvalue of a symmetric tridiagonal matrix.
-
ELIM removes certains rows of the matrix.
-
ELIM1 removes certina rows of the matrix.
-
ELIM2 removes certain rows of the matrix.
-
ELIM3 removes certain rows of the matrix.
-
ELIM4 removes certain rows of the matrix.
-
ELIM5 removes certain rows of the matrix.
-
ERSHOW prints an appropriate error message for the error numbered IER.
-
FILLB calculates block fill-in for block factorization methods.
-
FILLBC sets up WKSP for block factorization methods.
-
FILLBN calculates block fill-in for block factorization methods.
-
FILLN determines the fill-in diagonals for nonsymmetric diagonal storage.
-
FILLNP determines the fill-in structure.
-
FILLS determines the fill-in diagonals for symmetric diagonal storage.
-
FILLSP determines the fill-in structure.
-
GAUSS is a Gaussian elimination routine.
-
GETBLK computes and factors the matrix (C**t)*A*C and factors it.
-
GMRES is the user interface to the truncated/restarted GMRES algorithm.
-
GMRESW runs the truncated/restarted GMRES algorithm.
-
HESEST calculates the extremal eigenvalue moduli of a banded Hessenberg matrix.
-
HQR finds the eigenvalues of a real upper Hessenberg matrix by the QR method.
-
IBBS does an incomplete block backward pass.
-
IBBSN does an incomplete block backward solve.
-
IBBSNT does an incomplete block transpose backward solve.
-
IBFCN1 does an incomplete block factorization.
-
IBFCN2 does an incomplete block factorization.
-
IBFCN3 does an incomplete block factorization.
-
IBFCN4 does an incomplete block factorization.
-
IBFCS1 does an incomplete block factorization.
-
IBFCS2 does an incomplete block factorization.
-
IBFCS3 does an incomplete block factorization.
-
IBFCS4 does an incomplete block factorization.
-
IBFS does an incomplete block forward pass.
-
IBFSN does an incomplete block forward solve.
-
IBFSNT does an incomplete block transpose forward solve.
-
IBSL does an incomplete block solution.
-
IBSLN does an incomplete block solution.
-
IBSLN1 does an incomplete block forward pass.
-
IBSLN2 does an incomplete block backward pass.
-
IBSLN3 does an incomplete block transpose back solve.
-
IBSLN4 does an incomplete block transpose forward pass.
-
IBSLNT does an incomplete block transpose solution.
-
IC1 drives the IC preconditioner.
-
IC2 drives the symmetric IC preconditioner.
-
IC3 drives the nonsymmetric IC preconditioner.
-
IC6 drives the IC preconditioner.
-
ICBS does an IC back solve (natural ordering, diagonal storage).
-
ICBSCP does a back IC solve. (Purdue storage, multicolor)
-
ICBSCT does a transpose back IC solve. (Purdue storage, multicolor)
-
ICBSP does an IC back solve (natural ordering, Purdue storage).
-
ICBST does an iC back solve (natural ordering, diagonal storage).
-
ICBSTP does a transpose IC back solve (natural ordering, Purdue storage).
-
ICF computes an incomplete factorization. (symmetric diagonal storage)
-
ICFCP computes an incomplete factorization. (Purdue storage, multicolor)
-
ICFN computes an incomplete factorization. (nonsymmetric diagonal storage)
-
ICFNP computes an incomplete factorization. (Purdue storage, nonsymmetric matrix)
-
ICFP computes an incomplete factorization. (Purdue storage, symmetric matrix)
-
ICFS does an IC forward solve (natural ordering, diagonal storage).
-
ICFSCP does a forward IC solve. (Purdue storage, multicolor)
-
ICFSCT does a transpose forward ic solve. (Purdue storage, multicolor)
-
ICFSP does an IC forward solve (natural ordering, Purdue storage).
-
ICFST does an IC forward solve (natural ordering, diagonal storage).
-
ICFSTP does a transpose IC forward solve (natural ordering, Purdue storage).
-
ICFV computes an incomplete factorization. (symmetric diagonal storage, vectorized version)
-
ICS does an IC solution (natural ordering, symmetric diagonal storage).
-
ICS1 does an IC forward solution (natural ordering, symmetric diagonal storage).
-
ICS2 does an IC back solution (natural ordering, symmetric diagonal storage).
-
ICS3 does an IC transpose backward solution (natural ordering, symmetric diagonal storage).
-
ICS4 does an IC transpose forward solution (natural ordering, symmetric diagonal storage).
-
ICSCP does an IC solve. (Purdue storage, multicolor)
-
ICSCP1 does an IC forward solve. (Purdue storage, multicolor)
-
ICSCP2 does an IC back solve. (Purdue storage, multicolor)
-
ICSCP3 does a transpose IC forward solve. (Purdue storage, multicolor)
-
ICSCP4 does a transpose IC back solve. (Purdue storage, multicolor)
-
ICSCPT does a transpose IC solve. (Purdue storage, multicolor)
-
ICSN does an IC solution (natural ordering, nonsymmetric diagonal storage).
-
ICSN1 does an IC forward pass (natural ordering, nonsymmetric diagonal storage).
-
ICSN2 does an IC back pass (natural ordering, nonsymmetric diagonal storage).
-
ICSN3 does an IC transpose back pass (natural ordering, nonsymmetric diagonal storage).
-
ICSN4 does an IC transpose forward pass (natural ordering, nonsymmetric diagonal storage).
-
ICSNP does an IC solution (natural ordering, Purdue storage, nonsymmetric matrix).
-
ICSNP1 does an IC forward solution (natural ordering, Purdue storage, nonsymmetric matrix).
-
ICSNP2 does an IC back solution (natural ordering, Purdue storage, nonsymmetric matrix).
-
ICSNP3 does a transpose IC forward solution (natural ordering, Purdue storage, nonsymmetric matrix).
-
ICSNP4 does a transpose IC back solution (natural ordering, Purdue storage, nonsymmetric matrix).
-
ICSNT does a transpose IC solution (natural ordering, nonsymmetric diagonal storage).
-
ICSNTP does a transpose IC solution (natural ordering, Purdue storage, nonsymmetric matrix).
-
ICSP does an IC solution (natural ordering, Purdue storage, symmetric matrix).
-
ICSP1 does an IC forward solution (natural ordering, Purdue storage, symmetric matrix).
-
ICSP2 does an IC back solution (natural ordering, Purdue storage, symmetric matrix).
-
ICSP3 does an IC transpose forward solution (natural ordering, Purdue storage, symmetric matrix).
-
ICSP4 does an IC transpose back solution (natural ordering, Purdue storage, symmetric matrix).
-
INITHV initializes dot and vector "haves" to FALSE.
-
IOM is the user interface to the (truncated) IOM algorithm.
-
IOMW runs the (truncated) IOM algorithm.
-
IPSTR finds a suitable exponent for OMEGA-1.
-
IPTGEN generates the pointer vector to block rows.
-
ITCG does the conjugate gradient iterations.
-
ITERM produces the iteration summary line at the end of each iteration.
-
ITSI does the semi-iterative iterations.
-
ITSOR does the SOR iterations.
-
ITSRCG does the SSOR conjugate gradient iterations.
-
ITSRSI does the SSOR semi-iterative iterations.
-
JAC1 drives the Jacobi preconditioner.
-
JAC2 drives the Jacobi preconditioner.
-
JAC3 drives the Jacobi preconditioner.
-
JAC4 drives the Jacobi preconditioner.
-
JAC5 drives the Jacobi preconditioner.
-
LANDIR is the user interface to the Lanczos/ORTHODIR algorithm.
-
LANMIN is the user interface to the Lanczos/ORTHOMIN algorithm.
-
LANRES is the user interface to the Lanczos/ORTHORES algorithm.
-
LDIRW runs the Lanczos/ORTHODIR algorithm.
-
LFACT computes a line factorization.
-
LINV computes a line approximate inverse.
-
LJAC2 drives the line Jacobi preconditioner.
-
LJAC3 drives the line Jacobi preconditioner.
-
LJACX2 drives the line Jacobi preconditioner.
-
LJACX3 drives the line Jacobi preconditioner.
-
LLSP2 drives the line least squares polynomial preconditioner.
-
LLSP3 drives the line least squares polynomial preconditioner.
-
LMINW runs the Lanczos/ORTHOMIN algorithm.
-
LNEU2 drives the line Neumann polynomial preconditioner.
-
LNEU3 drives the line Neumann polynomial preconditioner.
-
LRESW runs the Lanczos/ORTHORES algorithm.
-
LSOR2 drives the line SOR method.
-
LSOR3 drives the line SOR method.
-
LSP1 drives the least squares polynomial preconditioner.
-
LSP2 drives the least squares polynomial preconditioner.
-
LSP3 drives the least squares polynomial preconditioner.
-
LSP4 drives the least squares polynomial preconditioner.
-
LSP5 drives the least squares polynomial preconditioner.
-
LSQR is the user interface to the LSQR algorithm.
-
LSQRW runs the LSQR algorithm.
-
LSSOR2 drives the line SSOR method.
-
LSSOR3 drives the line SSOR method.
-
MBIC2 drives the block factorization (version 1, modified) method.
-
MBIC3 drives the block factorization (version 1, modified) method.
-
MBIC7 drives the block factorization (version 1, modified) method.
-
MBICX2 drives the block factorization (version 2, modified) method.
-
MBICX3 drives the block factorization (version 2, modified) method.
-
MBICX7 drives the block factorization (version 2, modified method).
-
MCOPY copies an array into array.
-
ME is the user interface to the minimal error algorithm of Fridman.
-
MEW runs the minimal error algorithm of Fridman.
-
MFACT computes a line factorization of a multi-color matrix.
-
MIC1 drives the MIC preconditioner.
-
MIC2 drives the symmetric MIC preconditioner.
-
MIC3 drives the nonsymmetric MIC preconditioner.
-
MIC6 drives the MIC preconditioner.
-
MOVE1 moves the data structure to the form d/t/b.
-
MOVE2 moves the data structure to the form d/t/b.
-
MOVE3 moves the data structure to the form d/t/b.
-
MOVE4 moves the data structure to the form dc/tc/bc.
-
MOVE5 moves the data structure to the form dc/tc/bc.
-
MUL1T computes y = (A**t)*x, a matrix-vector product.
-
MUL2NT computes y = (A**t)*x, a matrix-vector product.
-
MUL3NT computes y = (A**t)*x, a matrix-vector product.
-
MULDC computes y = A*x for a matrix permuted to an ncolor x ncolor block matrix..
-
MULDCT computes y = (A**t)*x for a matrix permuted to an ncolor x ncolor block matrix.
-
MULT1 computes y = A*x, a matrix-vector product.
-
MULT2N computes y = A*x, a matrix-vector product.
-
MULT2S computes y = A*x, a matrix-vector product.
-
MULT3 computes y = A*x, a matrix-vector product.
-
MULT3N computes y = A*x, a matrix-vector product.
-
NEEDW determines if enough integer or real workspace is available.
-
NEU1 drives the Neumann polynomial preconditioner.
-
NEU2 drives the Neumann polynomial preconditioner.
-
NEU3 drives the Neumann polynomial preconditioner.
-
NEU4 drives the Neumann polynomial preconditioner.
-
NEU5 drives the Neumann polynomial preconditioner.
-
NMCALC calculates the quantities
-
NOADP is a dummy routine to do no adaption.
-
NSPCG is the driver for the NSPCG package.
-
NULLPL applies the left preconditioner.
-
NULLPR applies the right preconditioner.
-
ODIR is the user interface to the ORTHODIR algorithm.
-
ODIRW implements ORTHODIR.
-
OMGCHG changes ALPHAB and BETAB for a new estimate of OMEGA.
-
OMIN is the user interface to the truncated/restarted ORTHOMIN algorithm.
-
OMINGW is a generalized version of the OMINW routine.
-
OMINW implements the truncated/restarted ORTHOMIN algorithm.
-
ORES is the user interface to the ORTHORES algorithm.
-
ORESW implements ORTHORES.
-
OUT prints the residual and solution vectors.
-
PARSI computes the iteration parameters.
-
PBNEU computes a block Neumann polynomial approximation to inverse(A).
-
PBPII computes a block least squares polynomial approximation to inverse(A).
-
PBS does a penta-diagonal back substitution.
-
PBSM does a penta-diagonal back substitution.
-
PERMAS permutes the rows and columns of a sparse matrix.
-
PERMAT permutes the rows and columns of a Purdue sparse matrix.
-
PERMD permutes the matrix, U, UBAR, and RHS. (diagonal format)
-
PERMP permutes the matrix, U, UBAR, and RHS. (Purdue format)
-
PERMS permutes the matrix, U, UBAR, and RHS. (sparse format)
-
PERMUT permutes the matrix, U, UBAR, and RHS.
-
PERROR2 computes the residual, R = RHS - A*U.
-
PERVEC permutes a vector as dictated by the permutation vector.
-
PFAC computes a factorization of a single symmetric pentadiagonal matrix.
-
PFACM factors multiple independent symmetric pentadiagonal matrices.
-
PFACN factors a nonsymmetric pentadiagonal matrix.
-
PFACNM factors multiple independent nonsymmetric pentadiagonal matrices.
-
PFACT1 computes a point incomplete factorization.
-
PFACT2 computes a point incomplete factorization.
-
PFACT3 computes a point incomplete factorization.
-
PFACTC computes a point incomplete factorization. (multicolor ordering)
-
PFS does a penta-diagonal forward substitution.
-
PFSM does a penta-diagonal forward substitution.
-
PGEN constructs the permutation and its inverse for a given coloring.
-
PJAC does the point Jacobi preconditioning.
-
PMDG permutes the matrix according to and index vector.
-
PNEU computes a point Neumann polynomial approximation to inverse(A).
-
POINTR adjusts pointers according to IFACT.
-
PPII computes the least squares polynomial approximation to inverse(A).
-
PRBBLK determines if the matrix has block property A.
-
PRBNDX determines if the matrix has property A.
-
PREP puts the diagonal entries of the matrix into column 1 of COEF.
-
PREP1 puts the diagonal elements of the matrix in column 1 of COEF (Purdue data structure)
-
PREP2 puts the diagonal entries of the matrix into column 1 of COEF. (diagonal data structure)
-
PREP3 puts the diagonal elements of the matrix into the data structure.
-
PRICH does the Richardson preconditioning.
-
PSOLN solves the system A*x = y for x, where A is a pentadiagonal system.
-
PSOLNM solves the system A*x = y for x, where a contains multiple pentadiagonal systems.
-
PSTOP is an interface to the PSTOPG routine using NULLPL and NULLPR.
-
PSTOPG computes one of the stopping tests.
-
PSTOPS performs a test to see if the iterative method has converged.
-
PVEC performs generalized Gram-Schmidt on a collection of vectors.
-
QRUPD updates the QR factorization of a banded upper Hessenberg matrix.
-
REDBLK determines if the matrix has property A.
-
RICH1 drives the Richardson preconditioner.
-
RICH2 drives the Richardson preconditioner.
-
RICH3 drives the Richardson preconditioner.
-
RICH4 drives the Richardson preconditioner.
-
RICH5 drives the Richardson preconditioner.
-
ROWISE determines whether a row-wise or diagonal-wise algorithm should be used.
-
ROWSUM computes the row sum of a matrix.
-
RS6 drives the reduced system method (Purdue storage with red-black coloring).
-
RS7 drives the reduced system method (diagonal storage with red-black coloring).
-
RSAD computes C = ( DR - T * inverse(DB) * B ) * B.
-
RSAP computes C = ( DR - T * inverse(DB) * B ) * B.
-
RSATD computes C = ((dr**t) - (b**t)*(db**(-t))*(t**t))*b.
-
RSATP computes C = (dr - (b**t)*inv(db)*(t**t))*b.
-
RSBEGD computes CR = br - t*inv(db)*bb.
-
RSBEGP computes cr = br - t*inv(db)*bb.
-
RSENDD computes xb = inv(db)*(bb - b*xr).
-
RSENDP computes xb = inv(db)*(bb - b*xr).
-
RSMATD computes RS = dr - ah*inv(db)*ak.
-
RSMATP computes RS = dr - ah*inv(db)*ak.
-
RSNSP is the driver for explicitly computed reduced systems.
-
RSPOST is the postprocessor for explicitly-computed reduced systems.
-
RSPREP is the preprocessor for explicitly-computed reduced systems.
-
RSRHSD computes cr = br - t*inv(db)*bb.
-
RSXBD computes xb = inv(db)*(bb - b*xr).
-
SBBS does an block SSOR backward pass.
-
SBBSN does an block SSOR backward solve.
-
SBBSNT does an block SSOR transpose backward solve.
-
SBFS does an block SSOR forward pass.
-
SBFSN does an block SSOR forward solve.
-
SBFSNT does an block SSOR transpose forward solve.
-
SBSL does an block SSOR solution.
-
SBSLN does an block SSOR solution.
-
SBSLN1 does an block SSOR forward solution.
-
SBSLN2 does an block SSOR back solution.
-
SBSLN3 does an block SSOR transpose forward solution.
-
SBSLN4 does an block SSOR transpose back solution.
-
SBSLNT does an block SSOR transpose solution.
-
SCAL1 scales the original matrix to a unit diagonal matrix.
-
SCAL2 scales the original matrix to a unit diagonal matrix.
-
SCAL3 scales the original matrix to a unit diagonal matrix.
-
SCALE scales the matrix, U, UBAR, and RHS.
-
SCALED scales the matrix, U, UBAR, and RHS.
-
SCALEP scales the matrix, U, UBAR, and RHS.
-
SCALES scales the matrix, U, UBAR, and RHS. (sparse format)
-
SELDOT computes a dot product from a selected pair of vectors.
-
SI is the user interface to the Chebyshev acceleration algorithm.
-
SIW drives the Chebyshev acceleration algorithm.
-
SOR is the user interface to the SOR algorithm.
-
SOR1 drives the point SOR method.
-
SOR2 drives the point SOR method.
-
SOR3 drives the point SOR method.
-
SOR6 drives the multi-color SOR method.
-
SOR7 drives the multi-color SOR method.
-
SORCP does an SOR solve.
-
SORDB does an SOR pass
-
SORDMB does an SOR pass.
-
SORDN does an SOR solve (natural ordering, nonsymmetric diagonal storage).
-
SORDNB does an SOR pass.
-
SORDS does an SOR solve (natural ordering,
-
SORP does an SOR solve.
-
SORSTP tests if the SOR method has converged.
-
SORW drives the successive over-relaxation algorithm.
-
SPLIT determines how to apply the splitting based on IQLR.
-
SRBS does an SOR back solve (natural ordering, diagonal storage).
-
SRBSCP does a back SOR solve. (Purdue storage, multicolor)
-
SRBSCT does a transpose back SOR solve.
-
SRBSP does an SOR backward solve (natural ordering, Purdue storage).
-
SRBST does an SOR transpose back solve (natural ordering, diagonal storage).
-
SRBSTP does an SOR transpose back solve (natural ordering, Purdue storage).
-
SRCG is the user interface to the SSOR conjugate gradient algorithm.
-
SRCGW drives the SSOR conjugate gradient algorithm.
-
SRFS does an SOR forward solve (natural ordering, diagonal storage).
-
SRFSCP does a forward SOR solve. (Purdue storage, multicolor)
-
SRFSCT does a transpose forward SOR solve. (Purdue storage, multicolor)
-
SRFSP does an SOR forward solve (natural ordering, Purdue storage).
-
SRFST does an SOR transpose forward solve (natural ordering, diagonal storage).
-
SRFSTP does an SOR transpose forward solve (natural ordering, Purdue storage).
-
SRS does an SSOR solution (natural ordering, symmetric diagonal storage).
-
SRS1 does an SSOR forward solve (natural ordering, symmetric diagonal storage).
-
SRS2 does an SSOR back solve (natural ordering, symmetric diagonal storage).
-
SRS3 does an SSOR transpose forward solve (natural ordering, symmetric diagonal storage).
-
SRS4 does an SSOR transpose back solve (natural ordering, symmetric diagonal storage).
-
SRSCP does an SSOR solve. (Purdue storage, multicolor)
-
SRSCP1 does an SSOR forward solve. (Purdue storage, multicolor)
-
SRSCP2 does an SSOR back solve. (Purdue storage, multicolor)
-
SRSCP3 does a transpose SSOR back solve. (Purdue storage, multicolor)
-
SRSCP4 does a transpose ssor forward solve. (Purdue storage, multicolor)
-
SRSCPT does a transpose SSOR solve. (Purdue storage, multicolor)
-
SRSI is the user interface to the SSOR Chebyshev acceleration algorithm.
-
SRSIW drives the SSOR Chebyshev acceleration algorithm.
-
SRSN does an SSOR solution (natural ordering, nonsymmetric diagonal storage).
-
SRSN1 does an SSOR forward pass (natural ordering, nonsymmetric diagonal storage).
-
SRSN2 does an SSOR backward pass (natural ordering, nonsymmetric diagonal storage).
-
SRSN3 does a transpose SSOR back pass (natural ordering, nonsymmetric diagonal storage).
-
SRSN4 does a transpose SSOR forward pass (natural ordering, nonsymmetric diagonal storage).
-
SRSNT does a transpose SSOR solution (natural ordering, nonsymmetric diagonal storage).
-
SRSNTP does an SSOR transpose solution (natural ordering, Purdue storage).
-
SRSP does an SSOR solution (natural ordering Purdue storage).
-
SRSP1 does an SSOR forward solve (natural ordering, Purdue storage).
-
SRSP2 does an SSOR back solve (natural ordering, Purdue storage).
-
SRSP3 does an SSOR transpose back solve (natural ordering, Purdue storage).
-
SRSP4 does an SSOR transpose forward solve (natural ordering, Purdue storage).
-
SSOR1 drives the point SSOR method.
-
SSOR2 drives the point SSOR method.
-
SSOR3 drives the point SSOR method.
-
SSOR6 drives the multi-color SSOR method.
-
SSOR7 drives the multi-color SSOR method.
-
SSORAD does the SSOR adaptive process.
-
SSORD computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSORDN computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSORP computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSORPN computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSRCD computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSRCDM computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSRCDN computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSRCP computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SSRCPN computes pdp = (p,d*p) and pldup = (p,l*inv(d)*u*p).
-
SUB100 calls the SRSCP3 preconditioner.
-
SUB101 calls the SRSCP2 preconditioner.
-
SUB102 calls the SRSCP4 preconditioner.
-
SUB103 calls the SSRCP or SSRCPN adaption routine.
-
SUB104 calls the ICSCP preconditioner.
-
SUB105 calls the ICSCPT preconditioner.
-
SUB106 calls the ICSCP1 preconditioner.
-
SUB107 calls the ICSCP3 preconditioner.
-
SUB104 calls the ICSCP2 preconditioner.
-
SUB109 calls the ICSCP4 preconditioner.
-
SUB110 calls PPII, for LSPOLY preconditioning.
-
SUB111 calls PNEU, for Neumann polynomial preconditioning.
-
SUB112 calls PPII for LSPOLY preconditioning.
-
SUB113 calls PPII for LSPOLY preconditioning.
-
SUB114 calls PNEU for Neumann polynomial preconditioning.
-
SUB115 calls PNEU for Neumann polynomial preconditioning.
-
SUBA1 calls MULT2S.
-
SUBA10 calls RSAP.
-
SUBA11 calls RSATP.
-
SUBA12 calls MULT3.
-
SUBA13 calls MULT3N.
-
SUBA14 calls MUL3NT.
-
SUBA2 calls MULDC.
-
SUBA3 calls MULDCT.
-
SUBA4 calls MULT2N.
-
SUBA5 calls MUL2NT.
-
SUBA6 calls RSAD.
-
SUBA7 calls RSATD.
-
SUBA8 calls MULT1.
-
SUBA9 calls MUL1T.
-
SUBQ1 calls PJAC for Jacobi preconditioning.
-
SUBQ10 calls the SSOR preconditioner.
-
SUBQ11 calls the SSOR preconditioner.
-
SUBQ12 calls the SSOR adaption routine.
-
SUBQ13 calls ICS for IC(S) preconditioning.
-
SUBQ14 calls ICS1 for IC(S) preconditioning.
-
SUBQ15 calls ICS3 for IC(S) preconditioning.
-
SUBQ16 calls ICS2 for IC(S) preconditioning.
-
SUBQ17 calls ICS4 for IC(S) preconditioning.
-
SUBQ18 calls PPII for LSPOLY preconditioning.
-
SUBQ19 calls PNEU for Neumann polynomial preconditioning.
-
SUBQ2 calls BDSOL for line Jacobi preconditioning.
-
SUBQ20 calls the basic LSOR iterative step.
-
SUBQ21 calls the LSSOR preconditioner.
-
SUBQ22 calls the LSSOR adaption routine.
-
SUBQ23 calls PBPII for line LSPOLY preconditioning.
-
SUBQ24 calls PBNEU for line Neumann polynomial preconditioning.
-
SUBQ25 calls IBSL for BIC preconditioning.
-
SUBQ26 calls the basic multi-color SOR iterative step
-
SUBQ27 calls the MSSOR preconditioner.
-
SUBQ28 calls the MSSOR preconditioner.
-
SUBQ29 calls the MSSOR preconditioner.
-
SUBQ3 calls BDSOLT for line Jacobi preconditioning.
-
SUBQ30 calls the MSSOR preconditioner.
-
SUBQ31 calls the MSSOR preconditioner.
-
SUBQ32 calls the MSSOR preconditioner.
-
SUBQ33 calls the MSSOR adaption routine.
-
SUBQ34 calls IBSLN for multi-color BIC preconditioning.
-
SUBQ35 calls IBSLNT for multi-color bic preconditioning.
-
SUBQ36 calls IBSLN1 for multi-color BIC preconditioning.
-
SUBQ37 calls IBSLN3 for multi-color BIC preconditioning.
-
SUBQ38 calls IBSLN2 for multi-color BIC preconditioning.
-
SUBQ39 calls IBSLN4 for multi-color BIC preconditioning.
-
SUBQ4 call BMUL or BMULN, for line Jacobi preconditioning
-
SUBQ40 calls the basic SOR iterative step
-
SUBQ41 calls the SSOR preconditioner.
-
SUBQ42 calls the SSOR preconditioner.
-
SUBQ43 calls the SSOR preconditioner.
-
SUBQ44 calls the SSOR preconditioner.
-
SUBQ45 calls the SSOR preconditioner.
-
SUBQ46 calls the SSOR preconditioner.
-
SUBQ47 calls the SSOR adaption routine.
-
SUBQ48 calls ICSN for IC(S) preconditioning.
-
SUBQ49 calls ICSNT for IC(S) preconditioning.
-
SUBQ5 calls BMUL or BMULNT for line Jacobi preconditioning
-
SUBQ50 calls ICSN1 for IC(S) preconditioning.
-
SUBQ51 calls ICSN3 for IC(S) preconditioning.
-
SUBQ52 calls ICSN2 for IC(S) preconditioning.
-
SUBQ53 calls ICSN4 for IC(S) preconditioning.
-
SUBQ54 calls PPII for LSPOLY preconditioning.
-
SUBQ55 calls PPII for LSPOLY preconditioning.
-
SUBQ56 calls PNEU for Neumann polynomial preconditioning.
-
SUBQ57 calls PNEU for Neumann polynomial preconditioning.
-
SUBQ58 calls the basic LSOR iterative step
-
SUBQ59 calls the LSSOR preconditioner.
-
SUBQ6 calls the basic SOR iterative step
-
SUBQ60 calls the LSSOR preconditioner.
-
SUBQ61 calls the LSSOR preconditioner.
-
SUBQ62 calls the LSSOR preconditioner.
-
SUBQ63 calls the LSSOR preconditioner.
-
SUBQ64 calls the LSSOR preconditioner.
-
SUBQ65 calls the LSSOR adaption routine.
-
SUBQ66 calls PBPII for line LSPOLY preconditioning.
-
SUBQ67 calls PBPII for line LSPOLY preconditioning.
-
SUBQ68 calls PBNEU for line Neumann polynomial preconditioning.
-
SUBQ69 calls PBNEU for line Neumann polynomial preconditioning.
-
SUBQ7 calls the SSOR preconditioner.
-
SUBQ70 calls IBSLN for BIC preconditioning.
-
SUBQ71 calls IBSLNT for BIC preconditioning.
-
SUBQ72 calls IBSLN1 for BIC preconditioning.
-
SUBQ73 calls IBSLN3 for BIC preconditioning.
-
SUBQ74 calls IBSLN2 for BIC preconditioning.
-
SUBQ75 calls IBSLN4 for BIC preconditioning.
-
SUBQ76 calls BDSOL for RS preconditioning.
-
SUBQ77 calls BDSOLT for RS preconditioning.
-
SUBQ78 calls the basic SOR iterative step
-
SUBQ79 calls the SRSP preconditioner.
-
SUBQ8 calls the SRS1 preconditioner.
-
SUBQ80 calls the SSOR preconditioner.
-
SUBQ81 calls the SRSP1 preconditioner.
-
SUBQ82 calls the SSOR preconditioner.
-
SUBQ83 calls the SRSP2 preconditioner.
-
SUBQ84 calls the SSOR preconditioner.
-
SUBQ85 calls the SSOR adaption routine.
-
SUBQ86 calls ICS for IC(S) preconditioning.
-
SUBQ87 calls ICS for IC(S) preconditioning.
-
SUBQ88 calls ICS for IC(S) preconditioning.
-
SUBQ89 calls ICS for IC(S) preconditioning.
-
SUBQ9 calls the SSOR preconditioner.
-
SUBQ90 calls ICS for IC(S) preconditioning.
-
SUBQ91 calls ICS for IC(S) preconditioning.
-
SUBQ92 calls PPII for LSPOLY preconditioning.
-
SUBQ93 calls PPII for LSPOLY preconditioning.
-
SUBQ94 calls PNEU for Neumann polynomial preconditioning.
-
SUBQ95 calls PNEU for Neumann polynomial preconditioning.
-
SUBQ96 calls the basic multi-color SOR iterative step
-
SUBQ97 calls the SRSCP preconditioner.
-
SUBQ98 calls the SRSCPT preconditioner.
-
SUBQ99 calls the SRSCP1 preconditioner.
-
T1PROD computes D = D - C*A*B restricted to the sparsity pattern of D.
-
T2PROD computes D = D - (C**t)*A*B restricted to the sparsity pattern of D.
-
TAU sets TAU for the SOR method.
-
TBS does a back substitution.
-
TBSM does a back substitution.
-
TFAC computes a factorization of a single symmetric tridiagonal matrix.
-
TFACM factors of multiple independent symmetric tridiagonal matrices.
-
TFACN factors a nonsymmetric tridiagonal matrix.
-
TFACNM factors multiple independent nonsymmetric tridiagonal matrices.
-
TFS does a forward substitution.
-
TFSM does a forward substitution.
-
TIMER is a routine to return the execution time in seconds.
-
TINV computes an approximate inverse to a single tridiagonal symmetric matrix.
-
TINVM computes an approximate inverse to multiple tridiagonal symmetric matrices.
-
TINVN computes an approximate inverse to a single tridiagonal nonsymmetric matrix.
-
TINVNM computes an approximate inverse to multiple tridiagonal nonsymmetric matrices.
-
TMULT omputes the product of the t-matrix with a vector.
-
TSOLN solves A*x = y for x, for a tridiagonal system.
-
TSOLNM solves A*x = y for x, for multiple tridiagonal systems A.
-
TSUM computes the row and column sum of (C**t)*A*B restricted to the sparsity pattern of JD.
-
TSUMN computes the row sum of C*A*B restricted to the sparsity pattern of JD.
-
UNPMDG reverses the permutation done by PMDIAG.
-
USCAL1 reverses the scaling done in routine SCAL1.
-
USCAL2 reverses the scaling done in routine SCAL2.
-
USCAL3 reverses the scaling done in SCAL3.
-
USLQW runs the USYMLQ algorithm.
-
USQRW runs the USYMQR algorithm.
-
USYMLQ is the user interface to the USYMLQ algorithm.
-
USYMQR is the user interface to the USYMQR algorithm.
-
VADD adds the elements of a vector.
-
VADDD computes y = y + A*x. (diagonal storage)
-
VADDDT computes y = y + (A**t)*x. (diagonal storage)
-
VADDP does y = y + A*x (Purdue format)
-
VADDPT does y = y + (A**t)*x (Purdue format)
-
VADDS does y = y + A*x (sparse format)
-
VCOPY copies vector x to vector y.
-
VDOT computes the dot product of two vectors.
-
VEMTXY computes v = -x * y where v, x, and y are vectors.
-
VEXOPY computes v = x op y where op is one of the operations + - * / .
-
VFILL fills a vector with a constant value.
-
VGATHI gathers elements from an array.
-
VGATHR gathers elements from an array.
-
VICOPY copies one integer vector to another.
-
VIFILL fills an integer vector with a value.
-
VINV computes v = 1/v.
-
VMAX determines the maximum element of a vector.
-
VMIN determines the minimum element of a vector v.
-
VSCATI scatters elements from consecutive locations in an array.
-
VSCATR scatters elements from consecutive locations in an array.
-
VSQRT computes the square root of the entries of a vector.
-
VSRTA1 sorts the sparse data structure by rows and then columns.
-
VSUBD computes y = y - A*x. (diagonal storage)
-
VSUBDT computes y = y - (A**t)*x. (diagonal storage)
-
VSUBP does y = y - A*x (Purdue format).
-
VSUBPT does y = y - (A**t)*x (Purdue format).
-
VSUBS does y = y - A*x (sparse format).
-
VTRIAD computes C = A + CON*B or C = CON*B.
-
ZBRENT finds a zero of a function in a change of sign interval.
You can go up one level to
the FORTRAN90 source codes.
Last revised on 11 January 2013.