intro_lapack(3S)

INTRO_LAPACK - Introduction to LAPACK solvers for dense linear systems

As shipped in IRIX 6.5.30. Last changed in IRIX 6.5.19.

NAME
     INTRO_LAPACK - Introduction to LAPACK solvers for dense linear systems

IMPLEMENTATION
     See individual man pages for implementation details

     These routines are part of the SCSL Scientific Library and can be loaded
     using either the -lscs or the -lscs_mp option.  The -lscs_mp option
     directs the linker to use the multi-processor version of the library.

     When linking to SCSL with -lscs or -lscs_mp, the default integer size is
     4 bytes (32 bits). Another version of SCSL is available in which integers
     are 8 bytes (64 bits).  This version allows the user access to larger
     memory sizes and helps when porting legacy Cray codes.  It can be loaded
     by using the -lscs_i8 option or the -lscs_i8_mp option. A program may use
     only one of the two versions; 4-byte integer and 8-byte integer library
     calls cannot be mixed.

DESCRIPTION
     The preferred solvers for dense linear systems are those parts of the
     LAPACK package that are included in the current version of the SGI
     Scientific Computing Software Library (SCSL).

   LAPACK Routines
     LAPACK is a public domain library of subroutines for solving dense linear
     algebra problems, including the following:

     *   Systems of linear equations

     *   Linear least squares problems

     *   Eigenvalue problems

     *   Singular value decomposition (SVD) problems

     For details about which routines are supported, see "LAPACK Routines
     Contained in the Scientific Library," which follows.

     The LAPACK package is designed to be the successor to the older LINPACK
     and EISPACK packages.  It uses today's high-performance computers more
     efficiently than the older packages.  It also extends the functionality
     of these packages by including equilibration, iterative refinement, error
     bounds, and driver routines for linear systems, routines for computing
     and reordering the Schur factorization, and condition estimation routines
     for eigenvalue problems.

     Performance issues are addressed by implementing the most
     computationally-intensive algorithms by using the Level 2 and 3 Basic
     Linear Algebra Subprograms (BLAS).  Because most of the BLAS were
     optimized in single- and multiple-processor environments, these
     algorithms give near optimal performance.

     The original Fortran programs are described in the LAPACK User's Guide by
     E. Anderson, Z. Bai, C. Bischof, J. Demmel, J. Dongarra, J. Du Croz, A.
     Greenbaum, S. Hammarling, A. McKenney, S. Ostrouchov, and D. Sorensen,
     published by the Society for Industrial and Applied Mathematics (SIAM),
     Philadelphia, 1992.  The manual is also available online at
     http://www.netlib.org/lapack/lug/index.html.

   LAPACK Routines Contained in the Scientific Library
     All of the real and complex routines from LAPACK 3.0 are supported in
     SCSL.  This includes driver routines and computational routines for
     solving linear systems, least squares problems, and eigenvalue and
     singular value problems.  Selected auxiliary routines for generating and
     manipulating elementary orthogonal transformations are also supported.

     The LAPACK routines in SCSL are described online in man pages.  For
     example, to see a description of the arguments to the expert driver
     routine for solving a general system of equations, enter the following
     command:

          % man sgesvx


     The user interface to all supported LAPACK routines is exactly the same
     as the standard LAPACK interface.

     Tuning parameters for the block algorithms provided in the SCSL are set
     within the LAPACK routine ILAENV(3S).  ILAENV(3S) is an integer function
     subprogram that accepts information about the problem type and
     dimensions, and it returns one integer parameter, such as the optimal
     block size, the minimum block size for which a block algorithm should be
     used, or the crossover point (the problem size at which it becomes more
     efficient to switch to an unblocked algorithm).  The setting of tuning
     parameters occurs without user intervention, but users may call
     ILAENV(3S) directly to discover the values that will be used (for
     example, to determine how much workspace to provide).

   Calling LAPACK Routines from C
     Although LAPACK is a library of Fortran 77 subroutines, C and C++ users
     have full access to LAPACK functionality provided that they follow
     conventions documented in Chapter 8 of the MIPSpro 7 Fortran 90 Commands
     and Directives Reference Manual, "Interlanguage Calling" (available from
     http://techpubs.sgi.com/).  The large majority of LAPACK routines can be
     called from C/C++ using the following four rules:

     *   The name of the LAPACK subprogram must be declared in the C/C++
         program using all lowercase letters, appended with a trailing
         underscore.

     *   The correspondence between Fortran and C data types is as follows:

              Fortran                 C/C++
              -------                 -----
              INTEGER                 int       (32-bit integer library)
                                      long long (64-bit integer library)
              LOGICAL                 int       (32-bit integer library)
                                      long long (64-bit integer library)
              REAL                    float
              DOUBLE PRECISION        double
              COMPLEX                 struct{float real, imag;};
              DOUBLE COMPLEX          struct{double real, imag;};
              CHARACTER               char


     *   All subroutine arguments should be passed by reference.

     *   The LAPACK routines expect multidimensional arrays to be stored in
         column-major format in a contiguous region of memory.

     Note that the list above represents a subset of the general set of
     interlanguage calling conventions described in the Fortran 90 reference
     manual.  Character strings, in particular, require special handling when
     passed as subroutine arguments or when returned from a function:  if a
     string is longer than one character in extent, its length must be passed
     as an additional argument.  Since most LAPACK subprograms employ
     character strings of length one, however, this special case can usually
     be ignored.  Two important exceptions, ILAENV(3S) and XERBLA(3S), are
     discussed more fully below.

     To call the double precision Cholesky factorization routine DPOTRF(3S),
     for example, the following prototype and code might apply:

          void dpotrf_(char *, int *, double *, int *, int *);

          char uplo;
          int info, lda, n;
          double a[1000][1001];

          uplo = 'U';
          lda = 1001;
          n = 1000;
          dpotrf_(&uplo, &n, (double *) a, &lda, &info);

     Or, to calculate the eigenvalues and eigenvectors of a double complex
     Hermitian matrix using ZHEEVD(3S) from the 64-bit integer version of
     SCSL, one might have:

          typedef struct {double real, imag;} zomplex;

          void zheevd_(char *, char *, long long *, zomplex *,
                       long long *, double *, zomplex *, long long *,
                       double *, long long *, long long *, long long *,
                       long long *);

          char jobz, uplo;
          long long info, lda, liwork, lrwork, lwork, n;
          long long *iwork;
          double *rwork, *w;
          zomplex *a, *work;

          ...
          (array allocations and variable assignments)
          ...

          zheevd_(&jobz, &uplo, &n, a, &lda, w, work, &lwork, rwork,
                  &lrwork iwork, &liwork, &info);

     Two LAPACK routines involving character string arguments are XERBLA(3S)
     and ILAENV(3S).  The corresponding C/C++ prototypes, assuming 32-bit
     integers in the former case and 64-bit integers in the latter, would be

          void xerbla_(char *, int *, const int);

          long long ilaenv_(long long *, char *str1, char *str2, long long *,
                            long long *, long long *, long long *,
                            const int len_str1, const int len_str2);

     Here the lengths of the strings are passed as implicit arguments, in
     order of use, following the explicit argument list.  Note that,
     regardless of the default integer size in the version of SCSL one uses,
     the length of the character string is always passed as type int.

   Naming Scheme
     The name of each LAPACK routine is a coded specification of its function
     (within the limits of the FORTRAN 77 standard for six-character names).

     All driver and computational routines have five- or six-character names
     of the form XYYZZ or XYYZZZ.

     The first letter in each name, X, indicates the data type, as follows:

     S      REAL

     D      DOUBLE PRECISION

     C      COMPLEX

     Z      DOUBLE COMPLEX

     The next two letters, YY, indicate the type of matrix (or the
     most-significant matrix).  Most of these two-letter codes apply to both
     real and complex matrices, but a few apply specifically to only one or
     the other.  The matrix types are as follows:

     BD     BiDiagonal

     DI     Diagonal

     GB     General Band

     GE     GEneral (nonsymmetric)

     GG     General matrices, Generalized problem

     GT     General Tridiagonal

     HB     Hermitian Band (complex only)

     HE     HErmitian (possibly indefinite) (complex only)

     HG     Hessenberg matrix, Generalized problem

     HP     Hermitian Packed (possibly indefinite) (complex only)

     HS     upper HeSsenberg

     OP     Orthogonal Packed (real only)

     OR     ORthogonal (real only)

     PB     Positive definite Band (symmetric or Hermitian)

     PO     POsitive definite (symmetric or Hermitian)

     PP     Positive definite Packed (symmetric or Hermitian)

     PT     Positive definite Tridiagonal (symmetric or Hermitian)

     SB     Symmetric Band (real only)

     SP     Symmetric Packed (possibly indefinite)

     ST     Symmetric Tridiagonal

     SY     SYmmetric (possibly indefinite)

     TB     Triangular Band

     TG     Triangular matrices, Generalized problem

     TP     Triangular Packed

     TR     TRiangular

     TZ     TrapeZoidal

     UN     UNitary (complex only)

     UP     Unitary Packed (complex only)

     The last two or three letters, ZZ or ZZZ, indicate the computation
     performed.  For example, SGETRF performs a TRiangular Factorization of a
     Single-precision (real) GEneral matrix; CGETRF performs the factorization
     of a Complex GEneral matrix.

   Lists of Available LAPACK Routines
     The following pages contain lists of driver and computational routines
     from LAPACK available in the SCSL Scientific Library.  For details about
     the argument lists and usage of these routines, see the individual online
     man pages or the LAPACK User's Guide.

     These routines are listed in alphabetical order.

     *   CHESV, ZHESV: Solves a complex Hermitian indefinite system of linear
         equations AX = B.

     *   CHESVX, ZHESVX:  Solves a complex Hermitian indefinite system of
         linear equations AX = B and provides an estimate of the condition
         number and error bounds on the solution.

     *   CHPSV, ZHPSV:  Solves a complex Hermitian indefinite system of linear
         equations AX = B; A is held in packed storage.

     *   CHPSVX, ZHPSVX:  Solves a complex Hermitian indefinite system of
         linear equations AX = B (A is held in packed storage) and provides an
         estimate of the condition number and error bounds on the solution.

     *   SGBSV, DGBSV, CGBSV, ZGBSV:  Solves a general banded system of linear
         equations AX = B.

     *   SGBSVX, DGBSVX, CGBSVX, ZGBSVX:  Solves any of the following general
         banded systems of linear equations and provides an estimate of the
         condition number and error bounds on the solution.

              A X = B

               T
              A = B

               H
              A X = B


     *   SGEES, DGEES, CGEES, ZGEES: Computes eigenvalues, Schur form, and
         Schur vectors of a general matrix.

     *   SGEESX, DGEESX, CGEESX, ZGEESX:  Computes eigenvalues, Schur form,
         Schur vectors, and condition numbers of a general matrix.

     *   SGEEV, DGEEV, CGEEV, ZGEEV:  Computes eigenvalues and eigenvectors of
         a general matrix.

     *   SGEEVX, DGEEVX, CGEEVX, ZGEEVX:  Compute eigenvalues, eigenvectors,
         and condition numbers of a general matrix.

     *   SGEGS, DGEGS, CGEGS, ZGEGS:  Computes the generalized Schur
         factorization of a matrix pair (A,B).

     *   SGEGV, DGEGV, CGEGV, ZGEGV:  Computes the eigenvalues and
         eigenvectors of a matrix pair (A,B).

     *   SGELS, DGELS, CGELS, ZGELS:  Finds a least squares or minimum norm
         solution of an overdetermined or underdetermined linear.  system.

     *   SGELSD, DGELSD, CGELSD, ZGELSD: Solves linear least squares problem
         using divide-and-conquer.

     *   SGELSS, DGELSS, CGELSS, ZGELSS:  Solves linear least squares problem
         using SVD.

     *   SGELSY, DGELSY, CGELSY, ZGELSY:  Computes a minimum norm solution of
         a linear least squares problem using a complete orthogonal
         factorization.

     *   SGESDD, DGESDD, CGESDD, ZGESDD: Computes the singular value
         decomposition (SVD) of a general matrix using divide-and-conquer.

     *   SGESV, DGESV, CGESV, ZGESV:  Solves a general system of linear
         equations AX = B.

     *   SGESVD, DGESVD, CGESVD, ZGESVD:  Computes the singular value
         decomposition (SVD) of a general matrix.

     *   SGESVX, DGESVX, CGESVX, ZGESVX:  Solves any of the following general
         systems of linear equations and provides an estimate of the condition
         number and error bounds on the solution.

              A X = B

               T
              A X = B

               H
              A X = B

     *   SGGES, DGGES, CGGES, ZGGES: Computes the generalized Schur
         factorization of a matrix pair (A,B).

     *   SGGESX, DGGESX, CGGESX, ZGGESX: Computes the generalized Schur
         factorization of a matrix pair (A,B), expert driver.

     *   SGGEV, DGGEV, CGGEV, ZGGEV: Computes the eigenvalues and eigenvectors
         of a matrix pair (A,B).

     *   SGGEVX, DGGEVX, CGGEVX, ZGGEVX: Computes the eigenvalues and
         eigenvectors of a matrix pair (A,B), expert driver.

     *   SGGLSE, DGGLSE, CGGLSE, ZGGLSE: Solves a linear equality-constrained
         least squares problem (LSE) using GRQ.

     *   SGGGLM, DGGGLM, CGGGLM, ZGGGLM: Solves a general (Gauss-Markov)
         linear model problem (GLM) using GQR.

     *   SGGSVD, DGGSVD, CGGSVD, ZGGSVD: Computes the generalized singular
         value decomposition (SVD) of a matrix pair (A,B).

     *   SGTSV, DGTSV, CGTSV, ZGTSV:  Solves a general tridiagonal system of
         linear equations AX = B.

     *   SGTSVX, DGTSVX, CGTSVX, ZGTSVX:  Solves any of the following general
         tridiagonal systems of linear equations and provides an estimate of
         the condition number and error bounds on the solution.

              A X = B

               T
              A = B

               H
              A X = B


     *   SPBSV, DPBSV, CPBSV, ZPBSV:  Solves a symmetric or Hermitian positive
         definite banded system of linear equations AX = B.

     *   SPBSVX, DPBSVX, CPBSVX, ZPBSVX:  Solves a symmetric or Hermitian
         positive definite banded system of linear equations AX = B and
         provides an estimate of the condition number and error bounds on the
         solution.

     *   SPOSV, DPOSV, CPOSV, ZPOSV:  Solves a symmetric or Hermitian positive
         definite system of linear equations AX = B.

     *   SPOSVX, DPOSVX, CPOSVX, ZPOSVX:  Solves a symmetric or Hermitian
         positive definite system of linear equations AX = B and provides an
         estimate of the condition number and error bounds on the solution.

     *   SPPSV, DPPSV, CPPSV, ZPPSV:  Solves a symmetric or Hermitian positive
         definite system of linear equations AX = B; A is held in packed
         storage.

     *   SPPSVX, DPPSVX, CPPSVX, ZPPSVX:  Solves a symmetric or Hermitian
         positive definite system of linear equations AX = B (A is held in
         packed storage) and provides an estimate of the condition number and
         error bounds on the solution.

     *   SPTSV, DPTSV, CPTSV, ZPTSV:  Solves a symmetric or Hermitian positive
         definite tridiagonal system of linear equations AX = B.

     *   SPTSVX, DPTSVX, CPTSVX, ZPTSVX:  Solves a symmetric or Hermitian
         positive definite tridiagonal system of linear equations AX = B and
         provides an estimate of the condition number and error bounds on the
         solution.

     *   SSBEV, DSBEV, CHBEV, ZHBEV:  Compute all eigenvalues and eigenvectors
         of a symmetric or Hermitian band matrix.

     *   SSBEVD, DSBEVD, CHBEVD, ZHBEVD: Compute all eigenvalues and
         eigenvectors of a symmetric or Hermitian band matrix using divide-
         and-conquer.

     *   SSBEVX, DSBEVX, CHBEVX, ZHBEVX:  Compute selected eigenvalues and
         eigenvectors of a symmetric or Hermitian band matrix.

     *   SSBGV, DSBGV, CHBGV, ZHBGV:  Computes all eigenvalues and
         eigenvectors of a generalized symmetric-definite or Hermitian-
         definite banded eigenproblem.

     *   SSBGVD, DSBGVD, CHBGVD, ZHBGVD: Computes all eigenvalues and
         eigenvectors of a generalized symmetric-definite or Hermitian-
         definite banded eigenproblem using divide-and-conquer.

     *   SSBGVX, DSBGVX, CHBGVX, ZHBGVX: Computes all eigenvalues and
         eigenvectors of a generalized symmetric-definite or Hermitian-
         definite banded eigenproblem expert driver.

     *   SSPEV, DSPEV, CHPEV, ZHPEV:  Computes all eigenvalues and
         eigenvectors of a symmetric or Hermitian packed matrix.

     *   SSPEVD, DSPEVD, CHPEVD, ZHPEVD: Computes all eigenvalues and
         eigenvectors of a symmetric or Hermitian packed matrix using divide-
         and-conquer.

     *   SSPEVX, DSPEVX, CHPEVX, ZHPEVX:  Computes selected eigenvalues and
         eigenvectors of a symmetric or Hermitian packed matrix.

     *   SSPGV, DSPGV, CHPGV, ZHPGV:  Computes all eigenvalues and
         eigenvectors of a generalized symmetric-definite or
         Hermitian-definite packed eigenproblem.
     *   SSPSV, DSPSV, CSPSV, ZSPSV:  Solves a real or complex symmetric
         indefinite system of linear equations AX = B; A is held in packed
         storage.

     *   SSPSVX, DSPSVX, CSPSVX, ZSPSVX:  Solves a real or complex symmetric
         indefinite system of linear equations AX = B (A is held in packed
         storage) and provides an estimate of the condition number and error
         bounds on the solution.

     *   SSTEV, DSTEV:  Compute all eigenvalues and eigenvectors of a real
         symmetric tridiagonal matrix.

     *   SSTEVD, DSTEVD:  Compute all eigenvalues and eigenvectors of a real
         symmetric tridiagonal matrix using divide-and-conquer.

     *   SSTEVR, DSTEVR:  Compute all eigenvalues and eigenvectors of a real
         symmetric tridiagonal matrix using RRR (relatively robust
         representation).

     *   SSTEVX, DSTEVX:  Computes selected eigenvalues and eigenvectors of a
         real symmetric tridiagonal matrix.

     *   SSYEV, DSYEV, CHEEV, ZHEEV:  Computes all eigenvalues and
         eigenvectors of a symmetric or Hermitian matrix.

     *   SSYEVD, DSYEVD, CHEEVD, ZHEEVD: Computes all eigenvalues and
         eigenvectors of a symmetric or Hermitian matrix using divide-and-
         conquer.

     *   SSYEVR, DSYEVR, CHEEVR, ZHEEVR: Computes all eigenvalues and
         eigenvectors of a symmetric or Hermitian matrix using RRR (relatively
         robust representation).

     *   SSYEVX, DSYEVX, CHEEVX, ZHEEVX:  Computes selected eigenvalues and
         eigenvectors of a symmetric or Hermitian matrix.

     *   SSYGV, DSYGV, CHEGV, ZHEGV:  Computes all eigenvalues and
         eigenvectors of a generalized symmetric-definite or
         Hermitian-definite eigenproblem.

     *   SSYGVD, DSYGVD, CHEGVD, ZHEGVD: Computes all eigenvalues and
         eigenvectors of a generalized symmetric-definite or Hermitian-
         definite eigenproblem using divide-and-conquer.

     *   SSYGVX, DSYGVX, CHEGVX, ZHEGVX: Computes all eigenvalues and
         eigenvectors of a generalized symmetric-definite or Hermitian-
         definite eigenproblem expert driver.

     *   SSYSV, DSYSV, CSYSV, ZSYSV:  Solves a real or complex symmetric
         indefinite system of linear equations AX = B.

     *   SSYSVX, DSYSVX, CSYSVX, ZSYSVX:  Solves a real or complex symmetric
         indefinite system of linear equations AX = B and provides an estimate
         of the condition number and error bounds on the solution.

     These computational routines are listed in alphabetical order, with real
     matrix routines and complex matrix routines grouped together as
     appropriate.

     *   CHECON, ZHECON:  Estimates the reciprocal of the condition number of
         a complex Hermitian indefinite matrix, using the factorization
         computed by CHETRF.

     *   CHERFS, ZHERFS:  Improves the computed solution to a complex
         Hermitian indefinite system of linear equations AX = B and provides
         error bounds for the solution.

     *   CHETRF, ZHETRF:  Computes the factorization of a complex Hermitian
         indefinite matrix, using the diagonal pivoting method.

     *   CHETRI, ZHETRI:  Computes the inverse of a complex Hermitian
         indefinite matrix, using the factorization computed by CHETRF.

     *   CHETRS, ZHETRS:  Solves a complex Hermitian indefinite system of
         linear equations AX = B, using the factorization computed by CHETRF.

     *   CHPCON, ZHPCON:  Estimates the reciprocal of the condition number of
         a complex Hermitian indefinite matrix in packed storage, using the
         factorization computed by CHPTRF.

     *   CHPRFS, ZHPRFS:  Improves the computed solution to a complex
         Hermitian indefinite system of linear equations AX = B (A is held in
         packed storage) and provides error bounds for the solution.

     *   CHPTRF, ZHPTRF:  Computes the factorization of a complex Hermitian
         indefinite matrix in packed storage, using the diagonal pivoting
         method.

     *   CHPTRI, ZHPTRI:  Computes the inverse of a complex Hermitian
         indefinite matrix in packed storage, using the factorization computed
         by CHPTRF.

     *   CHPTRS, ZHPTRS:  Solves a complex Hermitian indefinite system of
         linear equations AX = B (A is held in packed storage) using the
         factorization computed by CHPTRF.

     *   ILAENV:  Determines tuning parameters (such as the block size).

     *   SBDSDC, DBDSDC, CBDSDC, ZBDSDC: Compute the singular value
         decomposition of a general matrix reduced to bidiagonal form using
         divide-and-conquer.

     *   SBDSQR, DBDSQR, CBDSQR, ZBDSQR:  Compute the singular value
         decomposition of a general matrix reduced to bidiagonal form

     *   SDISNA, DDISNA, CDISNA, ZDISNA: Computes the reciprocal condition
         numbers for the eigenvectors of a real symmetric or complex Hermitian
         matrix or for the left or right singular vectors of a general matrix.

     *   SGBBRD, DGBBRD, CGBBRD, ZGBBRD: Reduces a general band matrix to real
         upper bidiagonal form by an orthogonal/unitary transformation.

     *   SGBCON, DGBCON, CGBCON, ZGBCON:  Estimates the reciprocal of the
         condition number of a general band matrix, in either the 1-norm or
         the infinity-norm, using the LU factorization computed by SGBTRF or
         CGBTRF.

     *   SGBEQU, DGBEQU, CGBEQU, ZGBEQU:  Computes row and column scalings to
         equilibrate a general band matrix and reduce its condition number.
         Does not multiprocess or call any multiprocessing routines.

     *   SGBRFS, DGBRFS, CGBRFS, ZGBRFS:  Improves the computed solution to
         any of the following general banded systems of linear equations and
         provides error bounds for the solution.

              A X = B

               T
              A X = B

               H
              A X = B


     *   SGBTRF, DGBTRF, CGBTRF, ZGBTRF:  Computes an LU factorization of a
         general band matrix, using partial pivoting with row interchanges.

     *   SGBTRS, DGBTRS, CGBTRS, ZGBTRS:  Solves any of the following general
         banded systems of linear equations using the LU factorization
         computed by SGBTRF or CGBTRF.

              A X = B

               T
              A X = B

               H
              A X = B


     *   SGEBAK, DGEBAK, CGEBAK, ZGEBAK:  Back transform the eigenvectors of a
         matrix transformed by SGEBAL/CGEBAL.

     *   SGEBAL, DGEBAL, CGEBAL, ZGEBAL:  Balances a general matrix A.

     *   SGEBRD, DGEBRD, CGEBRD, ZGEBRD:  Reduces a general matrix to upper or
         lower bidiagonal form by an orthogonal/unitary transformation.

     *   SGECON, DGECON, CGECON, ZGECON:  Estimates the reciprocal of the
         condition number of a general matrix, in either the 1-norm or the
         infinity-norm, using the LU factorization computed by SGETRF or
         CGETRF.

     *   SGEEQU, DGEEQU, CGEEQU, ZGEEQU:  Computes row and column scalings to
         equilibrate a general rectangular matrix and to reduce its condition
         number.

     *   SGEHRD, DGEHRD, CGEHRD, ZGEHRD:  Reduces a general matrix to upper
         Hessenberg form by an orthogonal/unitary transformation.

     *   SGELQF, DGELQF, CGELQF, ZGELQF:  Computes an LQ factorization of a
         general rectangular matrix.

     *   SGEQLF, DGEQLF, CGEQLF, ZGEQLF:  Computes a QL factorization of a
         general rectangular matrix.

     *   SGEQP3, DGEQP3, CGEQP3, ZGEQP3: Computes a QR factorization with
         column pivoting of a general rectangular matrix using level-3 BLAS.

     *   SGEQPF, DGEQPF, CGEQPF, ZGEQPF:  Computes a QR factorization with
         column pivoting of a general rectangular matrix.

     *   SGEQRF, DGEQRF, CGEQRF, ZGEQRF:  Computes a QR factorization of a
         general rectangular matrix.

     *   SGERFS, DGERFS, CGERFS, ZGERFS:  Improves the computed solution to
         any of the following general systems of linear equations and provides
         error bounds for the solution.

              A X = B

               T
              A X = B

               H
              A X = B


     *   SGERQF, DGERQF, CGERQF, ZGERQF:  Computes an RQ factorization of a
         general rectangular matrix.

     *   SGETRF, DGETRF, CGETRF, ZGETRF:  Computes an LU factorization of a
         general matrix, using partial pivoting with row interchanges.

     *   SGETRI, DGETRI, CGETRI, ZGETRI:  Computes the inverse of a general
         matrix, using the LU factorization computed by SGETRF or CGETRF.

     *   SGETRS, DGETRS, CGETRS, ZGETRS:  Solves any of the following general
         systems of linear equations using the LU factorization computed by
         SGETRF or CGETRF.

              A X = B

               T
              A X = B

               H
              A X = B


     *   SGGBAK, DGGBAK, CGGBAK, ZGGBAK:  Back transform the eigenvectors of a
         generalized eigenvalue problem transformed by SGGBAL

     *   SGGBAL, DGGBAL, CGGBAL, ZGGBAL:  Balance a pair of general matrices
         (A,B)

     *   SGGHRD, DGGHRD, CGGHRD, ZGGHRD:  Reduce a pair of matrices (A,B) to
         generalized upper Hessenberg form

     *   SGGQRF, DGGQRF, CGGQRF, ZGGQRF: Computes a generalized QR
         factorization of a pair of matrices (A,B).

     *   SGGRQF, DGGRQF, CGGRQF, ZGGRQF: Computes a generalized RQ
         factorization of a pair of matrices (A,B).

     *   SGGSVP, DGGSVP, CGGSVP, ZGGSVP: Computes orthogonal/unitary matrices
         U, V, and Q as the preprocessing step for computing the generalized
         singular value decomposition (GSVD).

     *   SGTCON, DGTCON, CGTCON, ZGTCON:  Estimates the reciprocal of the
         condition number of a general tridiagonal matrix, in either the 1-
         norm or the infinity-norm, using the LU factorization computed by
         SGTTRF or CGTTRF.

     *   SGTRFS, DGTRFS, CGTRFS, ZGTRFS:  Improves the computed solution to
         any of the following general tridiagonal systems of linear equations
         and provides error bounds for the solution.

              A X = B

               T
              A X = B

               H
              A X = B

     *   SGTTRF, DGTTRF, CGTTRF, ZGTTRF:  Computes an LU factorization of a
         general tridiagonal matrix, using partial pivoting with row
         interchanges.

     *   SGTTRS, DGTTRS, CGTTRS, ZGTTRS:  Solves a general tridiagonal system
         of linear equations using the LU factorization computed by SGTTRF or
         CGTTRF.

              A X = B

               T
              A X = B

               H
              A X = B


     *   SHGEQZ, DHGEQZ, CHGEQZ, ZHGEQZ:  Compute the eigenvalues of a matrix
         pair (A,B) in generalized upper Hessenberg form using the QZ method

     *   SHSEIN, DHSEIN, CHSEIN, ZHSEIN:  Compute eigenvectors of a upper
         Hessenberg matrix by inverse iteration

     *   SHSEQR, DHSEQR, CHSEQR, ZHSEQR:  Compute eigenvalues, Schur form, and
         Schur vectors of a upper Hessenberg matrix

     *   SLAMCH, DLAMCH:  Computes machine-specific constants.

     *   SLARF, DLARF, CLARF, ZLARF:  Applies an elementary reflector.

     *   SLARFB, DLARFB, CLARFB, ZLARFB:  Applies a block reflector.

     *   SLARFG, DLARFG, CLARFG, ZLARFG:  Generates an elementary reflector.

     *   SLARFT, DLARFT, CLARFT, ZLARFT:  Forms the triangular factor of a
         block reflector.

     *   SLARGV, DLARGV, CLARGV, ZLARGV:  Generate a vector of real or complex
         plane rotations

     *   SLARNV, DLARNV, CLARNV, ZLARNV:  Generates a vector of random
         numbers.

     *   SLARTG, DLARTG, CLARTG, ZLARTG:  Generates a plane rotation.

     *   SLARTV, DLARTV, CLARTV, ZLARTV:  Apply a vector of real or complex
         plane rotations to two vectors

     *   SLASR, DLASR, CLASR, ZLASR:  Apply a sequence of real plane rotations
         to a matrix

     *   SOPGTR, DOPGTR, CUPGTR, ZUPGTR:  Generates the orthogonal/unitary
         matrix Q from SSPTRD/CHPTRD.

     *   SOPMTR, DOPMTR, CUPMTR, ZUPMTR:  Multiplies by the orthogonal/unitary
         matrix Q from SSPTRD/CHPTRD.

     *   SORGBR, DORGBR, CUNGBR, ZUNGBR:  Generates one of the
         orghogonal/unitary matrices:

                    H
              Q or P


         from SGEBRD/CGEBRD.

     *   SORGHR, DORGHR, CUNGHR, ZUNGHR:  Generates the orthogonal/unitary
         matrix Q from SGEHRD/CGEHRD.

     *   SORGLQ, DORGLQ, CUNGLQ, ZUNGLQ:  Generates all or part of the
         orthogonal or unitary matrix Q from an LQ factorization determined by
         SGELQF or CGELQF.

     *   SORGQL, DORGQL, CUNGQL, ZUNGQL:  Generates all or part of the
         orthogonal or unitary matrix Q from a QL factorization determined by
         SGEQLF or CGEQLF.

     *   SORGQR, DORGQR, CUNGQR, ZUNGQR:  Generates all or part of the
         orthogonal or unitary matrix Q from a QR factorization determined by
         SGEQRF or CGEQRF.

     *   SORGRQ, DORGRQ, CUNGRQ, ZUNGRQ:  Generates all or part of the
         orthogonal or unitary matrix Q from an RQ factorization determined by
         SGERQF or CGERQF.

     *   SORGTR, DORGTR, CUNGTR, ZUNGTR:  Generates the orthogonal/unitary
         matrix Q from SSYTRD/CHETRD.

     *   SORMBR, DORMBR, CUNMBR, ZUNMBR:  Multiplies by one of the
         orthogonal/unitary matrices Q or P from SGEBRD/CGEBRD.

     *   SORMHR, DORMHR, CUNMHR, ZUNMHR:  Multiplies by the orthogonal/unitary
         matrix Q from SGEHRD/CGEHRD.

     *   SORMLQ, DORMLQ, CUNMLQ, ZUNMLQ:  Multiplies a general matrix by the
         orthogonal or unitary matrix from an LQ factorization determined by
         SGELQF or CGELQF.

     *   SORMQL, DORMQL, CUNMQL, ZUNMQL:  Multiplies a general matrix by the
         orthogonal or unitary matrix from a QL factorization determined by
         SGEQLF or CGEQLF.

     *   SORMQR, DORMQR, CUNMQR, ZUNMQR:  Multiplies a general matrix by the
         orthogonal or unitary matrix from a QR factorization determined by
         SGEQRF or CGEQRF.

     *   SORMRQ, DORMRQ, CUNMRQ, ZUNMRQ:  Multiplies a general matrix by the
         orthogonal or unitary matrix from an RQ factorization determined by
         SGERQF or CGERQF.

     *   SORMRZ, DORMRZ, CUNMRZ, ZUNMRZ: Multiplies a general matrix by the
         orthogonal or unitary matrix from an RZ factorization determined by
         STZRZF or CTZRZF.

     *   SORMTR, DORMTR, CUNMTR, ZUNMTR:  Multiplies by the orthogonal/unitary
         matrix Q from SSYTRD/CHETRD.

     *   SPBCON, DPBCON, CPBCON, ZPBCON:  Estimates the reciprocal of the
         condition number of a symmetric or Hermitian positive definite band
         matrix, using the Cholesky factorization computed by SPBTRF or
         CPBTRF.

     *   SPBEQU, DPBEQU, CPBEQU, ZPBEQU:  Computes row and column scalings to
         equilibrate a symmetric or Hermitian positive definite band matrix
         and to reduce its condition number.

     *   SPBRFS, DPBRFS, CPBRFS, ZPBRFS:  Improves the computed solution to a
         symmetric or Hermitian positive definite banded system of linear
         equations AX = B and provides error bounds for the solution.

     *   SPBSTF, DPBSTF, CPBSTF, ZPBSTF:  Compute a split Cholesky
         factorization of a symmetric or Hermitian positive definite band
         matrix.

     *   SPBTRF, DPBTRF, CPBTRF, ZPBTRF:  Computes the Cholesky factorization
         of a symmetric or Hermitian positive definite band matrix.

     *   SPBTRS, DPBTRS, CPBTRS, ZPBTRS:  Solves a symmetric or Hermitian
         positive definite banded system of linear equations AX = B, using the
         Cholesky factorization computed by SPBTRF or CPBTRF.

     *   SPOCON, DPOCON, CPOCON, ZPOCON:  Estimates the reciprocal of the
         condition number of a symmetric or Hermitian positive definite
         matrix, using the Cholesky factorization computed by SPOTRF or
         CPOTRF.

     *   SPOEQU, DPOEQU, CPOEQU, ZPOEQU:  Computes row and column scalings to
         equilibrate a symmetric or Hermitian positive definite matrix and
         reduces its condition number.

     *   SPORFS, DPORFS, CPORFS, ZPORFS:  Improves the computed solution to a
         symmetric or Hermitian positive definite system of linear equations
         AX = B and provides error bounds for the solution.

     *   SPOTRF, DPOTRF, CPOTRF, ZPOTRF:  Computes the Cholesky factorization
         of a symmetric or Hermitian positive definite matrix.

     *   SPOTRI, DPOTRI, CPOTRI, ZPOTRI:  Computes the inverse of a symmetric
         or Hermitian positive definite matrix, using the Cholesky
         factorization computed by SPOTRF or CPOTRF.

     *   SPOTRS, DPOTRS, CPOTRS, ZPOTRS:  Solves a symmetric or Hermitian
         positive definite system of linear equations AX = B, using the
         Cholesky factorization computed by SPOTRF or CPOTRF.

     *   SPPCON, DPPCON, CPPCON, ZPPCON:  Estimates the reciprocal of the
         condition number of a symmetric or Hermitian positive definite matrix
         in packed storage, using the Cholesky factorization computed by
         SPPTRF or CPPTRF.

     *   SPPEQU, DPPEQU, CPPEQU, ZPPEQU:  Computes row and column scalings to
         equilibrate a symmetric or Hermitian positive definite matrix in
         packed storage and reduces its condition number.

     *   SPPRFS, DPPRFS, CPPRFS, ZPPRFS:  Improves the computed solution to a
         symmetric or Hermitian positive definite system of linear equations
         AX = B (A is held in packed storage) and provides error bounds for
         the solution.

     *   SPPTRF, DPPTRF, CPPTRF, ZPPTRF:  Computes the Cholesky factorization
         of a symmetric or Hermitian positive definite matrix in packed
         storage.

     *   SPPTRI, DPPTRI, CPPTRI, ZPPTRI:  Computes the inverse of a symmetric
         or Hermitian positive definite matrix in packed storage, using the
         Cholesky factorization computed by SPPTRF or CPPTRF.

     *   SPPTRS, DPPTRS, CPPTRS, ZPPTRS:  Solves a symmetric or Hermitian
         positive definite system of linear equations AX = B (A is held in
         packed storage) using the Cholesky factorization computed by SPPTRF
         or CPPTRF.

     *   SPTCON, DPTCON, CPTCON, ZPTCON:  Uses the LDLH factorization computed
         by SPTTRF or CPTTRF to compute the reciprocal of the condition number
         of a symmetric or Hermitian positive definite tridiagonal matrix.

     *   SPTEQR, DPTEQR, CPTEQR, ZPTEQR:  Compute eigenvalues and eigenvectors
         of a symmetric or Hermitian positive definite tridiagonal matrix.

     *   SPTRFS, DPTRFS, CPTRFS, ZPTRFS:  Improves the computed solution to a
         symmetric or Hermitian positive definite tridiagonal system of linear
         equations AX = B and provides error bounds for the solution.

     *   SPTTRF, DPTTRF, CPTTRF, ZPTTRF:  Computes the LDLH factorization of a
         symmetric or Hermitian positive definite tridiagonal matrix.

     *   SPTTRS, DPTTRS, CPTTRS, ZPTTRS:  Uses the LDLH factorization computed
         by SPTTRF or CPTTRF to solve a symmetric or Hermitian positive
         definite tridiagonal system of linear equations.

     *   SSBGST, DSBGST, CHBGST, ZHBGST:  Reduce a symmetric or Hermitian
         definite banded generalized eigenproblem to standard form.

     *   SSBTRD, DSBTRD, CHBTRD, ZHBTRD:  Reduce a symmetric or Hermitian band
         matrix to real symmetric tridiagonal form by an orthogonal/unitary
         transformation.

     *   SSPCON, DSPCON, CSPCON, ZSPCON:  Estimates the reciprocal of the
         condition number of a real or complex symmetric indefinite matrix in
         packed storage, using the factorization computed by SSPTRF or CSPTRF.

     *   SSPGST, DSPGST, CHPGST, ZHPGST:  Reduce a symmetric or Hermitian
         definite generalized eigenproblem to standard form, using packed
         storage.

     *   SSPRFS, DSPRFS, CSPRFS, ZSPRFS:  Improves the computed solution to a
         real or complex symmetric indefinite system of linear equations AX =
         B (A is held in packed storage) and provides error bounds for the
         solution.

     *   SSPTRD, DSPTRD, CHPTRD, ZHPTRD:  Reduces a symmetric/Hermitian packed
         matrix A to real symmetric tridiagonal form by an orthogonal/unitary
         transformation.

     *   SSPTRF, DSPTRF, CSPTRF, ZSPTRF:  Computes the factorization of a real
         or complex symmetric indefinite matrix in packed storage, using the
         diagonal pivoting method.

     *   SSPTRI, DSPTRI, CSPTRI, ZSPTRI:  Computes the inverse of a real or
         complex symmetric indefinite matrix in packed storage, using the
         factorization computed by SSPTRF or CSPTRF.

     *   SSPTRS, DSPTRS, CSPTRS, ZSPTRS:  Solves a real or complex symmetric
         indefinite system of linear equations AX = B (A is held in packed
         storage) using the factorization computed by SSPTRF or CSPTRF.

     *   SSTEBZ, DSTEBZ:  Compute eigenvalues of a symmetric tridiagonal
         matrix by bisection.

     *   SSTEDC, DSTEDC, CSTEDC, ZSTEDC: Computes all eigenvalues and,
         optionally, eigenvectors of a symmetric tridiagonal matrix using the
         divide and conquer algorithm.

     *   SSTEGR, DSTEGR, CSTEGR, ZSTEGR: Computes selected eigenvalues and,
         optionally, eigenvectors of a real symmetric tridiagonal matrix using
         the Relatively Robust Representations.

     *   SSTEIN, DSTEIN, CSTEIN, ZSTEIN:  Compute eigenvectors of a real
         symmetric tridiagonal matrix by inverse iteration.

     *   SSTEQR, DSTEQR, CSTEQR, ZSTEQR:  Compute eigenvalues and eigenvectors
         of a real symmetric tridiagonal matrix using the implicit QL or QR
         method.

     *   SSTERF, DSTERF:  Compute all eigenvalues of a symmetric tridiagonal
         matrix using the root-free variant of the QL or QR algorithm.

     *   SSYCON, DSYCON, CSYCON, ZSYCON:  Estimates the reciprocal of the
         condition number of a real or complex symmetric indefinite matrix,
         using the factorization computed by SSYTRF or CSYTRF.

     *   SSYGST, DSYGST, CHEGST, ZHEGST:  Reduce a symmetric or Hermitian
         definite generalized eigenproblem to standard form.

     *   SSYRFS, DSYRFS, CSYRFS, ZSYRFS:  Improves the computed solution to a
         real or complex symmetric indefinite system of linear equations AX =
         B and provides error bounds for the solution.

     *   SSYTRD, DSYTRD, CHETRD, ZHETRD:  Reduces a symmetric/Hermitian matrix
         A to real symmetric tridiagonal form by an orthogonal/unitary
         transformation.

     *   SSYTRF, DSYTRF, CSYTRF, ZSYTRF:  Computes the factorization of a real
         complex symmetric indefinite matrix, using the diagonal pivoting
         method.

     *   SSYTRI, DSYTRI, CSYTRI, ZSYTRI:  Computes the inverse of a real or
         complex symmetric indefinite matrix, using the factorization computed
         by SSYTRF or CSYTRF.

     *   SSYTRS, DSYTRS, CSYTRS, ZSYTRS:  Solves a real or complex symmetric
         indefinite system of linear equations AX = B, using the factorization
         computed by SSYTRF or CSYTRF.

     *   STBCON, DTBCON, CTBCON, ZTBCON:  Estimates the reciprocal of the
         condition number of a triangular band matrix, in either the 1-norm or
         the infinity-norm.

     *   STBRFS, DTBRFS, CTBRFS, ZTBRFS:  Provides error bounds for the
         solution of any of the following triangular banded systems of linear
         equations:

              A X = B

               T
              A X = B

               H
              A X = B
     *   STBTRS, DTBTRS, CTBTRS, ZTBTRS:  Solves any of the following
         triangular banded systems of linear equations:

              A X = B

               T
              A X = B

               H
              A X = B


     *   STGEVC, DTGEVC, CTGEVC, ZTGEVC:  Compute eigenvectors of a pair of
         matrices (A,B) in generalized Schur form.

     *   STGEXC, DTGEXC, CTGEXC, ZTGEXC: Reorders the generalized real-
         Schur/Schur decomposition of a matrix pair (A,B) using an
         orthogonal/unitary equivalence transformation so that the diagonal
         block of (A,B) with row index IFST is moved to row ILST.

     *   STGSEN, DTGSEN, CTGSEN, ZTGSEN: Reorders the generalized real-
         Schur/Schur decomposition of a matrix pair (A,B), computes the
         generalized eigenvalues of the reordered matrix pair, and,
         optionally, computes the estimates of reciprocal condition numbers
         for eigenvalues and eigenspaces.

     *   STGSJA, DTGSJA, CTGSJA, ZTGSJA: Computes the generalized singular
         value decomposition (GSVD) of a pair of upper triangular (or
         trapezoidal) matrices, which may be obtained by the preprocessing
         subroutine SGGSVP/CGGSVP.

     *   STGSNA, DTGSNA, CTGSNA, ZTGSNA: Estimates reciprocal condition
         numbers for specified eigenvalues and/or eigenvectors of a matrix
         pair (A,B) in generalized real-Schur/Schur canonical form.

     *   STGSYL, DTGSYL, CTGSYL, ZTGSYL: Solves the generalized Sylvester
         equation.

     *   STPCON, DTPCON, CTPCON, ZTPCON:  Estimates the reciprocal of the
         condition number of a triangular matrix in packed storage, in either
         the 1-norm or the infinity-norm.

     *   STPRFS, DTPRFS, CTPRFS, ZTPRFS:  Provides error bounds for the
         solution of any of the following triangular systems of linear
         equations where A is held in packed storage.

              A X = B

               T
              A X = B

               H
              A X = B


     *   STPTRI, DTPTRI, CTPTRI, ZTPTRI:  Computes the inverse of a triangular
         matrix in packed storage.

     *   STPTRS, DTPTRS, CTPTRS, ZTPTRS:  Solves any of the following
         triangular systems of linear equations where A is held in packed
         storage.

              A X = B

               T
              A X = B

               H
              A X = B


     *   STRCON, DTRCON, CTRCON, ZTRCON:  Estimates the reciprocal of the
         condition number of a triangular matrix, in either the 1-norm or the
         infinity-norm.

     *   STREVC, DTREVC, CTREVC, ZTREVC:  Compute eigenvectors of a real upper
         quasi-triangular matrix or a complex triangular matrix.

     *   STREXC, DTREXC, CTREXC, ZTREXC:  Exchange diagonal blocks in the real
         Schur factorization of a real or complex matrix.

     *   STRRFS, DTRRFS, CTRRFS, ZTRRFS:  Provides error bounds for the
         solution of any of the following triangular systems of linear
         equations:

              A X = B

               T
              A X = B

               H
              A X = B


     *   STRSEN, DTRSEN, CTRSEN, ZTRSEN:  Compute condition numbers to measure
         the sensitivity of a cluster of eigenvalues and its corresponding
         invariant subspace.

     *   STRSNA, DTRSNA, CTRSNA, ZTRSNA:  Compute condition numbers for
         specified eigenvalues and eigenvectors of a real upper quasi-
         triangular matrix or complex upper triangular matrix.

     *   STRSYL, DTRSYL, CTRSYL, ZTRSYL:  Solve the Sylvester matrix equation.

     *   STRTRI, DTRTRI, CTRTRI, ZTRTRI:  Computes the inverse of a triangular
         matrix.

     *   STRTRS, DTRTRS, CTRTRS, ZTRTRS:  Solves any of the following
         triangular systems of linear equations:

              A X = B
               T
              A X = B

               H
              A X = B


     *   STZRQF, DTZRQF, CTZRQF, ZTZRQF:  Reduces an upper trapezoidal matrix
         to upper triangular form by an orthogonal/unitary transformation.

     *   STZRZF, DTZRZF, CTZRZF, ZTZRZF: Reduces an upper trapezoidal matrix
         to upper triangular form by an orthogonal/unitary transformation.

     In addition to the driver and computational routines, the following
     auxiliary routines are also available.  For information about using these
     routines, see the individual man pages.

     CLACGV ZLACGV                           CLACRM ZLACRM

     CLACRT ZLACRT                           CLAESY ZLAESY

     CROT ZROT CSROT ZDROT                   CSPMV ZSPMV

     CSPR ZSPR                               CSYMV ZSYMV

     CSYR ZSYR                               ICMAX1 IZMAX1

     SCSUM1 DZSUM1                           SGBTF2 DGBTF2 CGBTF2 ZGBTF2

     SGEBD2 DGEBD2 CGEBD2 ZGEBD2             SGEHD2 DGEHD2 CGEHD2 ZGEHD2

     SGELQ2 DGELQ2 CGELQ2 ZGELQ2             SGEQL2 DGEQL2 CGEQL2 ZGEQL2

     SGEQR2 DGEQR2 CGEQR2 ZGEQR2             SGETF2 DGETF2 CGETF2 ZGETF2

     SLABAD DLABAD                           SLABRD DLABRD CLABRD ZLABRD

     SLACON DLACON CLACON ZLACON             SLACPY DLACPY CLACPY ZLACPY

     SLADIV DLADIV CLADIV ZLADIV             SLAE2 DLAE2

     SLAEBZ DLAEBZ                           SLAED0 DLAED0 CLAED0 ZLAED0

     SLAED1 DLAED1                           SLAED2 DLAED2

     SLAED3 DLAED3                           SLAED4 DLAED4

     SLAED5 DLAED5                           SLAED6 DLAED6

     SLAED7 DLAED7 CLAED7 ZLAED7             SLAED8 DLAED8 CLAED8 ZLAED8

     SLAED9 DLAED9                           SLAEDA DLAEDA

     SLAEIN DLAEIN CLAEIN ZLAEIN             SLAEV2 DLAEV2 CLAEV2 ZLAEV2

     SLAEXC DLAEXC                           SLAG2 DLAG2

     SLAGTF DLAGTF                           SLAGTM DLAGTM CLAGTM ZLAGTM

     SLAGTS DLAGTS                           SLAHQR DLAHQR CLAHQR ZLAHQR

     SLAHRD DLAHRD CLAHRD ZLAHRD             SLAIC1 DLAIC1 CLAIC1 ZLAIC1

     SLALN2 DLALN2                           SLAMRG DLAMRG

     SLANGB DLANGB CLANGB ZLANGB             SLANGE DLANGE CLANGE ZLANGE

     SLANGT DLANGT CLANGT ZLANGT             SLANHS DLANHS CLANHS ZLANHS

     SLANSB DLANSB CLANSB ZLANSB             CLANHB ZLANHB

     SLANSP DLANSP CLANSP ZLANSP             CLANHP ZLANHP

     SLANST DLANST CLANST ZLANST             SLANSY DLANSY CLANSY ZLANSY

     CLANHE ZLANHE                           SLANTB DLANTB CLANTB ZLANTB

     SLANTP DLANTP CLANTP ZLANTP             SLANTR DLANTR CLANTR ZLANTR

     SLANV2 DLANV2                           SLAPLL DLAPLL CLAPLL ZLAPLL

     SLAPMT DLAPMT CLAPMT ZLAPMT             SLAPY2 DLAPY2

     SLAPY3 DLAPY3                           SLAQGB DLAQGB CLAQGB ZLAQGB

     SLAQGE DLAQGE CLAQGE ZLAQGE             SLAQSB DLAQSB CLAQSB ZLAQSB

     SLAQSP DLAQSP CLAQSP ZLAQSP             SLAQSY DLAQSY CLAQSY ZLAQSY

     SLAQTR DLAQTR                           SLAR2V DLAR2V CLAR2V ZLAR2V

     SLARFX DLARFX CLARFX ZLARFX             SLARUV DLARUV

     SLAS2 DLAS2                             SLASCL DLASCL CLASCL ZLASCL

     SLASET DLASET CLASET ZLASET             SLASQ1 DLASQ1

     SLASQ2 DLASQ2                           SLASQ3 DLASQ3

     SLASQ4 DLASQ4                           SLASRT DLASRT

     SLASSQ DLASSQ CLASSQ ZLASSQ             SLASV2 DLASV2

     SLASWP DLASWP CLASWP ZLASWP             SLASY2 DLASY2

     SLASYF DLASYF CLASYF ZLASYF             CLAHEF ZLAHEF

     SLATBS DLATBS CLATBS ZLATBS             SLATPS DLATPS CLATPS ZLATPS

     SLATRD DLATRD CLATRD ZLATRD             SLATRS DLATRS CLATRS ZLATRS

     SLATZM DLATZM CLATZM ZLATZM             SLAUU2 DLAUU2 CLAUU2 ZLAUU2

     SLAUUM DLAUUM CLAUUM ZLAUUM             SORG2L DORG2L CUNG2L ZUNG2L

     SORG2R DORG2R CUNG2R ZUNG2R             SORGL2 DORGL2 CUNGL2 ZUNGL2

     SORGR2 DORGR2 CUNGR2 ZUNGR2             SORM2L DORM2L CUNM2L ZUNM2L

     SORM2R DORM2R CUNM2R ZUNM2R             SORML2 DORML2 CUNML2 ZUNML2

     SORMR2 DORMR2 CUNMR2 ZUNMR2             SPBTF2 DPBTF2 CPBTF2 ZPBTF2

     SPOTF2 DPOTF2 CPOTF2 ZPOTF2             SRSCL DRSCL CSRSCL ZDRSCL

     SSYGS2 DSYGS2 CHEGS2 ZHEGS2             SSYTD2 DSYTD2 CHETD2 ZHETD2

     SSYTF2 DSYTF2 CSYTF2 ZSYTF2             CHETF2 ZHETF2

     STRTI2 DTRTI2 CTRTI2 ZTRTI2

     LSNAME LSAMEN XERBLA

NOTES
     SCSL does not currently support reshaped arrays.

SEE ALSO
     LAPACK User's Guide

     INTRO_BLAS1(3S), INTRO_BLAS2(3S), INTRO_BLAS3(3S), INTRO_SCSL(3S),
     INTRO_SOLVERS(3S)