NSPCG
Nonsymmetric Preconditioned Conjugate Gradient
NSPCG
is a FORTRAN77 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 FORTRAN77 version and
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 which
solves sparse linear systems.
HB_IO
is a FORTRAN90 library which
reads and writes sparse linear systems stored in the HarwellBoeing Sparse Matrix format.
HB_TO_ST
is a FORTRAN77 program which
converts a sparse matrix from HarwellBoeing 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,
CNA216, April 1988.
Source Code:
Examples and Tests:
NSPCG_PRB1 is a test program.
NSPCG_PRB2 is a test program.
NSPCG_PRB3 is a test program.
NSPCG_PRB4 is a test program.
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 biconjugategradientsquared algorithm.

BCGSW runs the biconjugategradientsquared 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. (multicolor ordering)

BICOLOR determines whether or not a matrix is bicolorable.

BICX2 drives the block factorization (version 2) method.

BICX3 drives the block factorization (version 2) method.

BICX7 drives the block factorization (version 2) method (multicolor 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 blockstructured matrices.

DEFINE defines block constants for blockstructured 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 fillin for block factorization methods.

FILLBC sets up WKSP for block factorization methods.

FILLBN calculates block fillin for block factorization methods.

FILLN determines the fillin diagonals for nonsymmetric diagonal storage.

FILLNP determines the fillin structure.

FILLS determines the fillin diagonals for symmetric diagonal storage.

FILLSP determines the fillin 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 OMEGA1.

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 semiiterative iterations.

ITSOR does the SOR iterations.

ITSRCG does the SSOR conjugate gradient iterations.

ITSRSI does the SSOR semiiterative 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 multicolor 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 matrixvector product.

MUL2NT computes y = (A**t)*x, a matrixvector product.

MUL3NT computes y = (A**t)*x, a matrixvector 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 matrixvector product.

MULT2N computes y = A*x, a matrixvector product.

MULT2S computes y = A*x, a matrixvector product.

MULT3 computes y = A*x, a matrixvector product.

MULT3N computes y = A*x, a matrixvector 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 pentadiagonal back substitution.

PBSM does a pentadiagonal 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 pentadiagonal forward substitution.

PFSM does a pentadiagonal 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 GramSchmidt 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 rowwise or diagonalwise algorithm should be used.

ROWSUM computes the row sum of a matrix.

RS6 drives the reduced system method (Purdue storage with redblack coloring).

RS7 drives the reduced system method (diagonal storage with redblack 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 explicitlycomputed reduced systems.

RSPREP is the preprocessor for explicitlycomputed 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 multicolor SOR method.

SOR7 drives the multicolor 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 overrelaxation 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 multicolor SSOR method.

SSOR7 drives the multicolor 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 multicolor 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 multicolor BIC preconditioning.

SUBQ35 calls IBSLNT for multicolor bic preconditioning.

SUBQ36 calls IBSLN1 for multicolor BIC preconditioning.

SUBQ37 calls IBSLN3 for multicolor BIC preconditioning.

SUBQ38 calls IBSLN2 for multicolor BIC preconditioning.

SUBQ39 calls IBSLN4 for multicolor 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 multicolor 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 tmatrix 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 FORTRAN77 source codes.
Last revised on 11 January 2013.