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 Harwell-Boeing Sparse Matrix 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:

1. 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:

• nspcg.f, the source code
• nspcg.sh, commands to compile the source code

Examples and Tests:

NSPCG_PRB1 is a test program.

• nspcg_prb1.f, a sample problem;
• nspcg_prb1.sh, commands to compile, link, load and run the sample problem;
• nspcg_prb1_output.txt, the output file.

NSPCG_PRB2 is a test program.

• nspcg_prb2.f, a sample problem;
• nspcg_prb2.sh, commands to compile, link, load and run the sample problem;
• nspcg_prb2_output.txt, the output file.

NSPCG_PRB3 is a test program.

• nspcg_prb3.f, a sample problem;
• nspcg_prb3.sh, commands to compile, link, load and run the sample problem;
• nspcg_prb3_output.txt, the output file.

NSPCG_PRB4 is a test program.

• nspcg_prb4.f, a sample problem;
• nspcg_prb4.sh, commands to compile, link, load and run the sample problem;
• nspcg_prb4_output.txt, the output file.

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 FORTRAN77 source codes.